def __call__(self, pre_size, post_size):
try:
assert pre_size == post_size
except AssertionError:
raise errors.ModelUseError(
f'One2One connection must be defined in two groups with the same size, '
f'but we got {pre_size} != {post_size}.')
length = utils.size2len(pre_size)
self.num_pre = length
self.num_post = length
self.pre_ids = ops.arange(length)
self.post_ids = ops.arange(length)
return self
def run(self, duration, inputs=(), report=False, report_percent=0.1):
"""The running function.
Parameters
----------
duration : float, int, tuple, list
The running duration.
inputs : list, tuple
The model inputs with the format of ``[(key, value [operation])]``.
report : bool
Whether report the running progress.
report_percent : float
The percent of progress to report.
"""
# times
# ------
start, end = utils.check_duration(duration)
times = ops.arange(start, end, backend.get_dt())
run_length = ops.shape(times)[0]
# build run function
# ------------------
self.run_func = self.build(inputs, inputs_is_formatted=False, mon_length=run_length, return_code=False)
# run the model
# -------------
res = utils.run_model(self.run_func, times, report, report_percent)
self.mon.ts = times
return res
def firing_rate(sp_matrix, width, window='gaussian'):
"""Calculate the mean firing rate over in a neuron group.
This method is adopted from Brian2.
The firing rate in trial :math:`k` is the spike count :math:`n_{k}^{sp}`
in an interval of duration :math:`T` divided by :math:`T`:
.. math::
v_k = {n_k^{sp} \\over T}
Parameters
----------
sp_matrix : bnp.ndarray
The spike matrix which record spiking activities.
width : int, float
The width of the ``window`` in millisecond.
window : str
The window to use for smoothing. It can be a string to chose a
predefined window:
- `flat`: a rectangular,
- `gaussian`: a Gaussian-shaped window.
For the `Gaussian` window, the `width` parameter specifies the
standard deviation of the Gaussian, the width of the actual window
is `4 * width + dt`.
For the `flat` window, the width of the actual window
is `2 * width/2 + dt`.
Returns
-------
rate : numpy.ndarray
The population rate in Hz, smoothed with the given window.
"""
# rate
rate = ops.sum(sp_matrix, axis=1)
# window
dt = backend.get_dt()
if window == 'gaussian':
width1 = 2 * width / dt
width2 = int(round(width1))
window = ops.exp(-ops.arange(-width2, width2 + 1)**2 / (width1**2 * 2))
elif window == 'flat':
width1 = int(width / 2 / dt) * 2 + 1
window = ops.ones(width1)
else:
raise ValueError('Unknown window type "{}".'.format(window))
return np.convolve(rate, window / sum(window), mode='same')
def __init__(self, size, delay_time):
if isinstance(size, int):
size = (size, )
self.size = tuple(size)
self.delay_time = delay_time
if isinstance(delay_time, (int, float)):
self.uniform_delay = True
self.delay_num_step = int(math.ceil(
delay_time / backend.get_dt())) + 1
self.delay_data = ops.zeros((self.delay_num_step, ) + self.size)
else:
if not len(self.size) == 1:
raise NotImplementedError(
f'Currently, BrainPy only supports 1D heterogeneous delays, while does '
f'not implement the heterogeneous delay with {len(self.size)}-dimensions.'
)
self.num = size2len(size)
if isinstance(delay_time, type(ops.as_tensor([1]))):
assert ops.shape(delay_time) == self.size
elif callable(delay_time):
delay_time2 = ops.zeros(size)
for i in range(size[0]):
delay_time2[i] = delay_time()
delay_time = delay_time2
else:
raise NotImplementedError(
f'Currently, BrainPy does not support delay type '
f'of {type(delay_time)}: {delay_time}')
self.uniform_delay = False
delay = delay_time / backend.get_dt()
dint = ops.as_tensor(delay_time / backend.get_dt(), dtype=int)
ddiff = (delay - dint) >= 0.5
self.delay_num_step = ops.as_tensor(delay + ddiff, dtype=int) + 1
self.delay_data = ops.zeros((max(self.delay_num_step), ) + size)
self.diag = ops.arange(self.num)
self.delay_in_idx = self.delay_num_step - 1
if self.uniform_delay:
self.delay_out_idx = 0
else:
self.delay_out_idx = ops.zeros(self.num, dtype=int)
self.name = None
def run(self, duration, inputs=(), report=False, report_percent=0.1):
"""Run the simulation for the given duration.
This function provides the most convenient way to run the network.
For example:
Parameters
----------
duration : int, float, tuple, list
The amount of simulation time to run for.
inputs : list, tuple
The receivers, external inputs and durations.
report : bool
Report the progress of the simulation.
report_percent : float
The speed to report simulation progress.
"""
# preparation
start, end = utils.check_duration(duration)
dt = backend.get_dt()
ts = ops.arange(start, end, dt)
# build the network
run_length = ts.shape[0]
format_inputs = utils.format_net_level_inputs(inputs, run_length)
self.run_func = self.driver.build(run_length=run_length,
formatted_inputs=format_inputs,
return_code=False,
show_code=self.show_code)
# run the network
res = utils.run_model(self.run_func,
times=ts,
report=report,
report_percent=report_percent)
# end
self.t_start, self.t_end = start, end
for obj in self.all_nodes.values():
if obj.mon.num_item > 0:
obj.mon.ts = ts
return res
def run(self, duration, report=False, report_percent=0.1):
if isinstance(duration, (int, float)):
duration = [0, duration]
elif isinstance(duration, (tuple, list)):
assert len(duration) == 2
duration = tuple(duration)
else:
raise ValueError
# get the times
times = ops.arange(duration[0], duration[1], backend.get_dt())
# reshape the monitor
for key in self.mon.keys():
self.mon[key] = ops.zeros((len(times), ) +
ops.shape(self.mon[key])[1:])
# run the model
run_model(run_func=self.run_func,
times=times,
report=report,
report_percent=report_percent)
def ts(self):
"""Get the time points of the network.
"""
return ops.arange(self.t_start, self.t_end, backend.get_dt())