def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_c=-50.0, a=1., b=.1, c=.07, tau=10., tau_w=10., method='exp_auto', name=None): super(AdQuaIF, self).__init__(size=size, method=method, name=name) # parameters self.V_rest = V_rest self.V_reset = V_reset self.V_th = V_th self.V_c = V_c self.c = c self.a = a self.b = b self.tau = tau self.tau_w = tau_w # variables self.w = bm.Variable(bm.zeros(self.num)) self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool))
def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_T=-59.9, delta_T=3.48, a=1., b=1., tau=10., tau_w=30., R=1., method='exp_auto', name=None): super(AdExIF, self).__init__(size=size, name=name) # parameters self.V_rest = V_rest self.V_reset = V_reset self.V_th = V_th self.V_T = V_T self.delta_T = delta_T self.a = a self.b = b self.tau = tau self.tau_w = tau_w self.R = R # variables self.w = bm.Variable(bm.zeros(self.num)) self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) self.V = bm.Variable(bm.zeros(self.num)) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) # functions self.integral = odeint(method=method, f=JointEq([self.dV, self.dw]))
def __init__(self, num, tau=1., tau_v=50., k=1., a=0.3, A=0.2, J0=1., z_min=-bm.pi, z_max=bm.pi, m=0.3): super(CANN1D, self).__init__(size=num) # parameters self.tau = tau # The synaptic time constant self.tau_v = tau_v self.k = k # Degree of the rescaled inhibition self.a = a # Half-width of the range of excitatory connections self.A = A # Magnitude of the external input self.J0 = J0 # maximum connection value self.m = m # feature space self.z_min = z_min self.z_max = z_max self.z_range = z_max - z_min self.x = bm.linspace(z_min, z_max, num) # The encoded feature values self.rho = num / self.z_range # The neural density self.dx = self.z_range / num # The stimulus density # The connection matrix self.conn_mat = self.make_conn() # variables self.r = bm.Variable(bm.zeros(num)) self.u = bm.Variable(bm.zeros(num)) self.v = bm.Variable(bm.zeros(num)) self.input = bm.Variable(bm.zeros(num))
def __init__(self, size, ENa=50., gNa=120., EK=-77., gK=36., EL=-54.387, gL=0.03, V_th=20., C=1.0, name=None): super(HH, self).__init__(size=size, name=name) # parameters self.ENa = ENa self.EK = EK self.EL = EL self.C = C self.gNa = gNa self.gK = gK self.gL = gL self.V_th = V_th # variables self.V = bm.Variable(bm.ones(self.num) * -65.) self.m = bm.Variable(0.5 * bm.ones(self.num)) self.h = bm.Variable(0.6 * bm.ones(self.num)) self.n = bm.Variable(0.32 * bm.ones(self.num)) self.spike = bm.Variable(bm.zeros(size, dtype=bool)) self.input = bm.Variable(bm.zeros(size)) # integral functions self.int_h = bp.ode.ExpEulerAuto(self.dh) self.int_n = bp.ode.ExpEulerAuto(self.dn) self.int_m = bp.ode.ExpEulerAuto(self.dm) self.int_V = bp.ode.ExpEulerAuto(self.dV)
def __init__( self, size, tau_neu=10., tau_syn=0.5, tau_ref=2., V_reset=-65., V_th=-50., Cm=0.25, ): super(LIF, self).__init__(size=size) # parameters self.tau_neu = tau_neu # membrane time constant [ms] self.tau_syn = tau_syn # Post-synaptic current time constant [ms] self.tau_ref = tau_ref # absolute refractory period [ms] self.Cm = Cm # membrane capacity [nF] self.V_reset = V_reset # reset potential [mV] self.V_th = V_th # fixed firing threshold [mV] self.Iext = 0. # constant external current [nA] # variables self.V = bm.Variable(-65. + 5.0 * bm.random.randn(self.num)) # [mV] self.I = bm.Variable(bm.zeros(self.num)) # synaptic currents [nA] self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) # function self.integral = bp.odeint(bp.JointEq([self.dV, self.dI]), method='exp_auto')
def __init__(self, pre, post, conn, delay=0., g_max=1., tau_decay=10.0, tau_rise=1., method='exp_auto', name=None): super(DualExpCUBA, self).__init__(pre=pre, post=post, conn=conn, method=method, name=name) self.check_pre_attrs('spike') self.check_post_attrs('input') # parameters self.tau_rise = tau_rise self.tau_decay = tau_decay self.delay = delay self.g_max = g_max # connections self.pre_ids, self.post_ids = self.conn.require('pre_ids', 'post_ids') # variables self.g = bm.Variable(bm.zeros(len(self.pre_ids))) self.h = bm.Variable(bm.zeros(len(self.pre_ids))) self.pre_spike = bp.ConstantDelay(self.pre.num, delay, dtype=pre.spike.dtype)
def __init__(self, size, times, indices, need_sort=True, name=None): super(SpikeTimeInput, self).__init__(size=size, name=name) # parameters if len(indices) != len(times): raise ModelBuildError(f'The length of "indices" and "times" must be the same. ' f'However, we got {len(indices)} != {len(times)}.') self.num_times = len(times) # data about times and indices self.i = bm.Variable(bm.zeros(1, dtype=bm.int_)) self.times = bm.Variable(bm.asarray(times, dtype=bm.float_)) self.indices = bm.Variable(bm.asarray(indices, dtype=bm.int_)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) if need_sort: sort_idx = bm.argsort(times) self.indices.value = self.indices[sort_idx] self.times.value = self.times[sort_idx] # functions def cond_fun(t): return bm.logical_and(self.i[0] < self.num_times, t >= self.times[self.i[0]]) def body_fun(t): self.spike[self.indices[self.i[0]]] = True self.i[0] += 1 self._run = bm.make_while(cond_fun, body_fun, dyn_vars=self.vars())
def __init__(self, size): super().__init__(size) self.V = bm.Variable(bm.zeros(self.num) - 70.) self.u = bm.Variable(bm.zeros(self.num)) self.input = bm.Variable(bm.zeros(self.num)) self.integral = bp.odeint(self.derivative, method='rk2')
def __init__(self, size): super().__init__(size) self.V = bm.Variable(bm.zeros(self.num) - 70.) self.u = bm.Variable(bm.zeros(self.num)) self.input = bm.Variable(bm.zeros(self.num)) self.int_V = bp.odeint(self.dV, method='rk2') self.int_u = bp.odeint(self.du, method='rk2')
def __init__(self, size, method='exp_euler_auto', name=None): super(Neuron, self).__init__(size=size, name=name) # variables self.V = bm.Variable(bm.zeros(self.num)) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) # integral self.integral = bp.odeint(method=method, f=self.derivative)
def __init__(self, size, freq_mean, freq_var, t_interval, **kwargs): super(PoissonStim, self).__init__(size=size, **kwargs) self.freq_mean = freq_mean self.freq_var = freq_var self.t_interval = t_interval self.dt = bm.get_dt() / 1000. self.freq = bm.Variable(bm.zeros(1)) self.freq_t_last_change = bm.Variable(bm.ones(1) * -1e7) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.rng = bm.random.RandomState()
def __init__(self, num_input, num_hidden, num_output, num_batch, dt=None, e_ratio=0.8, sigma_rec=0., seed=None, w_ir=bp.init.KaimingUniform(scale=1.), w_rr=bp.init.KaimingUniform(scale=1.), w_ro=bp.init.KaimingUniform(scale=1.)): super(RNN, self).__init__() # parameters self.tau = 100 self.num_batch = num_batch self.num_input = num_input self.num_hidden = num_hidden self.num_output = num_output self.e_size = int(num_hidden * e_ratio) self.i_size = num_hidden - self.e_size if dt is None: self.alpha = 1 else: self.alpha = dt / self.tau self.sigma_rec = (2 * self.alpha)**0.5 * sigma_rec # Recurrent noise self.rng = bm.random.RandomState(seed=seed) # hidden mask mask = np.tile([1] * self.e_size + [-1] * self.i_size, (num_hidden, 1)) np.fill_diagonal(mask, 0) self.mask = bm.asarray(mask, dtype=bm.float_) # input weight self.w_ir = self.get_param(w_ir, (num_input, num_hidden)) # recurrent weight bound = 1 / num_hidden**0.5 self.w_rr = self.get_param(w_rr, (num_hidden, num_hidden)) self.w_rr[:, :self.e_size] /= (self.e_size / self.i_size) self.b_rr = bm.TrainVar(self.rng.uniform(-bound, bound, num_hidden)) # readout weight bound = 1 / self.e_size**0.5 self.w_ro = self.get_param(w_ro, (self.e_size, num_output)) self.b_ro = bm.TrainVar(self.rng.uniform(-bound, bound, num_output)) # variables self.h = bm.Variable(bm.zeros((num_batch, num_hidden))) self.o = bm.Variable(bm.zeros((num_batch, num_output)))
def __init__(self, size, delay, dtype=None, dt=None, **kwargs): # dt self.dt = bm.get_dt() if dt is None else dt # data size if isinstance(size, int): size = (size, ) if not isinstance(size, (tuple, list)): raise ModelBuildError( f'"size" must a tuple/list of int, but we got {type(size)}: {size}' ) self.size = tuple(size) # delay time length self.delay = delay # data and operations if isinstance(delay, (int, float)): # uniform delay self.uniform_delay = True self.num_step = int(pm.ceil(delay / self.dt)) + 1 self.out_idx = bm.Variable(bm.array([0], dtype=bm.uint32)) self.in_idx = bm.Variable( bm.array([self.num_step - 1], dtype=bm.uint32)) self.data = bm.Variable( bm.zeros((self.num_step, ) + self.size, dtype=dtype)) else: # non-uniform delay self.uniform_delay = False if not len(self.size) == 1: raise NotImplementedError( f'Currently, BrainPy only supports 1D heterogeneous ' f'delays, while we got the heterogeneous delay with ' f'{len(self.size)}-dimensions.') self.num = size2len(size) if bm.ndim(delay) != 1: raise ModelBuildError(f'Only support a 1D non-uniform delay. ' f'But we got {delay.ndim}D: {delay}') if delay.shape[0] != self.size[0]: raise ModelBuildError( f"The first shape of the delay time size must " f"be the same with the delay data size. But " f"we got {delay.shape[0]} != {self.size[0]}") delay = bm.around(delay / self.dt) self.diag = bm.array(bm.arange(self.num), dtype=bm.int_) self.num_step = bm.array(delay, dtype=bm.uint32) + 1 self.in_idx = bm.Variable(self.num_step - 1) self.out_idx = bm.Variable(bm.zeros(self.num, dtype=bm.uint32)) self.data = bm.Variable( bm.zeros((self.num_step.max(), ) + size, dtype=dtype)) super(ConstantDelay, self).__init__(**kwargs)
def __init__(self, size, name=None, T=36., method='rk4'): super(ReducedTRNModel, self).__init__(size=size, name=name) self.IT_th = -3. self.b = 0.5 self.g_T = 2.0 self.g_L = 0.02 self.E_L = -70. self.g_KL = 0.005 self.E_KL = -95. self.NaK_th = -55. # temperature self.T = T # parameters of INa, IK self.g_Na = 100. self.E_Na = 50. self.g_K = 10. self.phi_m = self.phi_h = self.phi_n = 3**((self.T - 36) / 10) # parameters of IT self.E_T = 120. self.phi_p = 5**((self.T - 24) / 10) self.phi_q = 3**((self.T - 24) / 10) self.p_half, self.p_k = -52., 7.4 self.q_half, self.q_k = -80., -5. # parameters of V self.C, self.Vth, self.area = 1., 20., 1.43e-4 self.V_factor = 1e-3 / self.area # parameters self.b = 0.14 self.rho_p = 0. # variables self.V = bm.Variable(bm.zeros(self.num)) self.y = bm.Variable(bm.zeros(self.num)) self.z = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.input = bm.Variable(bm.zeros(self.num)) # functions self.int_V = bp.odeint(self.fV, method=method) self.int_y = bp.odeint(self.fy, method=method) self.int_z = bp.odeint(self.fz, method=method) if not isinstance(self.int_V, bp.ode.ExpEulerAuto): self.integral = bp.odeint(self.derivative, method=method)
def __init__(self, size, a=1., b=3., c=1., d=5., r=0.01, s=4., V_rest=-1.6, V_th=1.0, method='exp_auto', name=None): # initialization super(HindmarshRose, self).__init__(size=size, method=method, name=name) # parameters self.a = a self.b = b self.c = c self.d = d self.r = r self.s = s self.V_th = V_th self.V_rest = V_rest # variables self.z = bm.Variable(bm.zeros(self.num)) self.y = bm.Variable(bm.ones(self.num) * -10.)
def __init__(self, v0, delay_len, before_t0=0., t0=0., dt=None): # size self.size = math.shape(v0) # delay_len self.delay_len = delay_len self.dt = math.get_dt() if dt is None else dt self.num_delay = int(math.ceil(delay_len / self.dt)) # other variables self._delay_in = self.num_delay - 1 self._delay_out = 0 self.current_time = t0 # before_t0 self.before_t0 = before_t0 # delay data self.data = math.zeros((self.num_delay + 1, ) + self.size) if callable(before_t0): for i in range(self.num_delay): self.data[i] = before_t0(t0 + (i - self.num_delay) * self.dt) else: self.data[:-1] = before_t0 self.data[-1] = v0
def __init__(self, size, freq, **kwargs): super(PoissonNoise, self).__init__(size=size, **kwargs) self.freq = bm.Variable(bm.array([freq])) self.dt = bm.get_dt() / 1000. self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.rng = bm.random.RandomState()
def ramp_input(c_start, c_end, duration, t_start=0, t_end=None, dt=None): """Get the gradually changed input current. Parameters ---------- c_start : float The minimum (or maximum) current size. c_end : float The maximum (or minimum) current size. duration : int, float The total duration. t_start : float The ramped current start time-point. t_end : float The ramped current end time-point. Default is the None. dt : float, int, optional The numerical precision. Returns ------- current_and_duration : tuple (The formatted current, total duration) """ dt = math.get_dt() if dt is None else dt t_end = duration if t_end is None else t_end current = math.zeros(int(np.ceil(duration / dt)), dtype=math.float_) p1 = int(np.ceil(t_start / dt)) p2 = int(np.ceil(t_end / dt)) current[p1:p2] = math.array(math.linspace(c_start, c_end, p2 - p1), dtype=math.float_) return current
def __init__(self, pre, post, conn, g_max=1., delay=0., tau=8.0, method='exp_auto', name=None): super(ExpCUBA, self).__init__(pre=pre, post=post, conn=conn, name=name) self.check_pre_attrs('spike') self.check_post_attrs('input', 'V') # parameters self.tau = tau self.delay = delay self.g_max = g_max # connection assert self.conn is not None self.pre2post = self.conn.require('pre2post') # variables self.g = bm.Variable(bm.zeros(self.post.num)) self.pre_spike = ConstantDelay(self.pre.num, delay=delay, dtype=pre.spike.dtype) # function self.integral = odeint(lambda g, t: -g / self.tau, method=method)
def __init__(self, size, method, d=1., F=96.489, C_rest=0.05, tau=5., C_0=2., T=36., R=8.31441, name=None): super(CaDyn, self).__init__(size, method, name=name) self.R = R # gas constant, J*mol-1*K-1 self.T = T self.d = d self.F = F self.tau = tau self.C_rest = C_rest self.C_0 = C_0 # Concentration of the Calcium self.C = bm.Variable(bm.ones(self.num, dtype=bm.float_) * self.C_rest) # The dynamical reversal potential self.E = bm.Variable(bm.ones(self.num, dtype=bm.float_) * 120.) # Used to receive all Calcium currents self.I_Ca = bm.Variable(bm.zeros(self.num, dtype=bm.float_))
def __init__(self, pre, post, conn, g_max=1., delay=0., tau=8.0, method='exp_auto', name=None): super(ExpCUBA, self).__init__(pre=pre, post=post, conn=conn, method=method, name=name) self.check_pre_attrs('spike') self.check_post_attrs('input') # parameters self.tau = tau self.delay = delay self.g_max = g_max # connections self.pre2post = self.conn.require('pre2post') # variables self.g = bm.Variable(bm.zeros(self.post.num)) self.pre_spike = bp.ConstantDelay(self.pre.num, delay, dtype=pre.spike.dtype)
def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_T=-59.9, delta_T=3.48, R=1., tau=10., tau_ref=1.7, method='exp_auto', name=None): # initialize super(ExpIF, self).__init__(size=size, method=method, name=name) # parameters self.V_rest = V_rest self.V_reset = V_reset self.V_th = V_th self.V_T = V_T self.delta_T = delta_T self.R = R self.tau = tau self.tau_ref = tau_ref # variables self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool))
def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_c=-50.0, c=.07, R=1., tau=10., tau_ref=0., method='exp_auto', name=None): # initialization super(QuaIF, self).__init__(size=size, method=method, name=name) # parameters self.V_rest = V_rest self.V_reset = V_reset self.V_th = V_th self.V_c = V_c self.c = c self.R = R self.tau = tau self.tau_ref = tau_ref # variables self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool))
def __init__(self, pre, post, conn, g_max=1., delay=0., tau=8.0, E=0., method='exp_auto'): super(ExpCOBA, self).__init__(pre=pre, post=post, conn=conn) self.check_pre_attrs('spike') self.check_post_attrs('input', 'V') # parameters self.E = E self.tau = tau self.delay = delay self.g_max = g_max self.pre2post = self.conn.require('pre2post') # variables self.g = bm.Variable(bm.zeros(self.post.num)) # function self.integral = bp.odeint(lambda g, t: -g / self.tau, method=method)
def __init__(self, host, method, g_max=10., E=-90., phi=1., name=None): super(Ih, self).__init__(host, method, name=name) self.phi = phi self.g_max = g_max self.E = E self.p = bm.Variable(bm.zeros(host.shape, dtype=bm.float_))
def __init__(self, host, method, E=10., g_max=1., phi=1., name=None): super(ICaN, self).__init__(host, method, name=name) self.E = E self.g_max = g_max self.phi = phi assert hasattr(self.host, 'ca') and isinstance(self.host.ca, CaDyn) self.p = bm.Variable(bm.zeros(self.host.num, dtype=bm.float_))
def __init__(self, size, V_L=-70., V_reset=-55., V_th=-50., Cm=0.5, gL=0.025, t_refractory=2., **kwargs): super(LIF, self).__init__(size=size, **kwargs) self.V_L = V_L self.V_reset = V_reset self.V_th = V_th self.Cm = Cm self.gL = gL self.t_refractory = t_refractory self.V = bm.Variable(bm.ones(self.num) * V_L) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) self.integral = bp.odeint(self.derivative)
def __init__(self, host, method, T=36., T_base_p=5., T_base_q=3., g_max=1.75, V_sh=-3., name=None): super(ICaT_RE, self).__init__(host, method, name=name) self.T = T self.T_base_p = T_base_p self.T_base_q = T_base_q self.g_max = g_max self.V_sh = V_sh self.p = bm.Variable(bm.zeros(host.num, dtype=bm.float_)) self.q = bm.Variable(bm.zeros(host.num, dtype=bm.float_))
def __init__(self, size, freqs, seed=None, name=None): super(PoissonInput, self).__init__(size=size, name=name) self.freqs = freqs self.dt = bm.get_dt() / 1000. self.size = (size,) if isinstance(size, int) else tuple(size) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) self.rng = bm.random.RandomState(seed=seed)
def __init__(self, num, T=36., T_base_p=3.55, T_base_q=3., g_max=1., V_sh=0.): super(ICaL, self).__init__() # parameters self.T = T self.T_base_p = T_base_p self.T_base_q = T_base_q self.g_max = g_max self.V_sh = V_sh # variables self.p = bm.Variable(bm.zeros(num, dtype=bm.float_)) self.q = bm.Variable(bm.zeros(num, dtype=bm.float_))