def __init__(self, subj_id, wta_params=default_params(), pyr_params=pyr_params(), inh_params=inh_params(), plasticity_params=plasticity_params(), sim_params=simulation_params()): self.subj_id = subj_id self.wta_params = wta_params self.pyr_params = pyr_params self.inh_params = inh_params self.plasticity_params = plasticity_params self.sim_params = sim_params self.simulation_clock = Clock(dt=self.sim_params.dt) self.input_update_clock = Clock(dt=1 / (self.wta_params.refresh_rate / Hz) * second) self.background_input = PoissonGroup(self.wta_params.background_input_size, rates=self.wta_params.background_freq, clock=self.simulation_clock) self.task_inputs = [] for i in range(self.wta_params.num_groups): self.task_inputs.append(PoissonGroup(self.wta_params.task_input_size, rates=self.wta_params.task_input_resting_rate, clock=self.simulation_clock)) # Create WTA network self.wta_network = WTANetworkGroup(params=self.wta_params, background_input=self.background_input, task_inputs=self.task_inputs, pyr_params=self.pyr_params, inh_params=self.inh_params, plasticity_params=self.plasticity_params, clock=self.simulation_clock) # Create network monitor self.wta_monitor = WTAMonitor(self.wta_network, None, None, self.sim_params, record_lfp=False, record_voxel=False, record_neuron_state=False, record_spikes=False, record_firing_rate=True, record_inputs=True, record_connections=None, save_summary_only=False, clock=self.simulation_clock) # Create Brian network and reset clock self.net = Network(self.background_input, self.task_inputs, self.wta_network, self.wta_network.connections.values(), self.wta_monitor.monitors.values())
def run_pop_code(pop_class, N, network_params, stimuli, trial_duration, report=None): simulation_clock=Clock(dt=1*ms) pop=pop_class(N,simulation_clock,network_params) pop_monitor=MultiStateMonitor(pop, vars=['x','r','e'], record=True, clock=simulation_clock) @network_operation(when='start', clock=simulation_clock) def get_pop_input(): pop.x=0.0 for stimulus in stimuli: if stimulus.start_time<simulation_clock.t<stimulus.end_time: pop.x+=pop.get_population_function(stimulus.x,stimulus.var) net=Network(pop, pop_monitor, get_pop_input) #reinit_default_clock() net.run(trial_duration, report=report) g_total=np.sum(np.clip(pop_monitor['e'].values,0,1) * pop_monitor['x'].values, axis=0)+0.1 voxel_monitor=get_bold_signal(g_total, voxel.default_params, range(int(stimuli[0].start_time/simulation_clock.dt)), trial_duration) # There is only one peak with rapid design if trial_duration>6*second: y_max=np.max(voxel_monitor['y'][0][60000:]) else: y_max=np.max(voxel_monitor['y'][0]) return pop_monitor, voxel_monitor, y_max
def initialize_neurongroup(self): # Add 'refractory' parameter on the CPU only if not self.use_gpu: if self.max_refractory is not None: refractory = 'refractory' self.model.add_param('refractory', second) else: refractory = self.refractory else: if self.max_refractory is not None: refractory = 0 * ms else: refractory = self.refractory # Must recompile the Equations : the functions are not transfered after pickling/unpickling self.model.compile_functions() self.group = NeuronGroup(self.neurons, model=self.model, reset=self.reset, threshold=self.threshold, refractory=refractory, max_refractory=self.max_refractory, method=self.method, clock=Clock(dt=self.dt)) if self.initial_values is not None: for param, value in self.initial_values.iteritems(): self.group.state(param)[:] = value
def __init__(self, filterbank, targetvar, *args, **kwds): self.targetvar = targetvar self.filterbank = filterbank filterbank.buffer_init() # update level keyword kwds['level'] = kwds.get('level', 0) + 1 # Sanitize the clock - does it have the right dt value? if 'clock' in kwds: if int(1 / kwds['clock'].dt) != int(filterbank.samplerate): raise ValueError('Clock should have 1/dt=samplerate') else: kwds['clock'] = Clock(dt=1 / filterbank.samplerate) buffersize = kwds.pop('buffersize', 32) if not isinstance(buffersize, int): buffersize = int(buffersize * self.samplerate) self.buffersize = buffersize self.buffer_pointer = buffersize self.buffer_start = -buffersize NeuronGroup.__init__(self, filterbank.nchannels, *args, **kwds) @network_operation(when='start', clock=self.clock) def apply_filterbank_output(): if self.buffer_pointer >= self.buffersize: self.buffer_pointer = 0 self.buffer_start += self.buffersize self.buffer = self.filterbank.buffer_fetch( self.buffer_start, self.buffer_start + self.buffersize) setattr(self, targetvar, self.buffer[self.buffer_pointer, :]) self.buffer_pointer += 1 self.contained_objects.append(apply_filterbank_output)
def get_bold_signal(g_total, voxel_params, baseline_range, trial_duration): simulation_clock = Clock(dt=1 * ms) voxel = Voxel(simulation_clock, params=voxel_params) voxel.G_base = g_total[baseline_range[0]:baseline_range[1]].mean() voxel_monitor = MultiStateMonitor( voxel, vars=['G_total', 's', 'f_in', 'v', 'f_out', 'q', 'y'], record=True, clock=simulation_clock) @network_operation(when='start', clock=simulation_clock) def get_input(): idx = int(simulation_clock.t / simulation_clock.dt) if idx < baseline_range[0]: voxel.G_total = voxel.G_base elif idx < len(g_total): voxel.G_total = g_total[idx] else: voxel.G_total = voxel.G_base net = Network(voxel, get_input, voxel_monitor) #reinit_default_clock() bold_trial_duration = 10 * second if trial_duration + 6 * second > bold_trial_duration: bold_trial_duration = trial_duration + 6 * second net.run(bold_trial_duration) return voxel_monitor
def run_restricted_pop_code(pop_class, N, network_params, stimuli, trial_duration, report=None): simulation_clock=Clock(dt=1*ms) pop=pop_class(N, simulation_clock, network_params) #pop_monitor=MultiStateMonitor(pop, vars=['x','r','e','total_e','total_r'], record=True) pop_monitor=MultiStateMonitor(pop, vars=['x','r','e'], record=True, clock=simulation_clock) @network_operation(when='start', clock=simulation_clock) def get_pop_input(): pop.x=0.0 for stimulus in stimuli: if stimulus.start_time<simulation_clock.t<stimulus.end_time: pop.x+=pop.get_population_function(stimulus.x,stimulus.var) net=Network(pop, pop_monitor, get_pop_input) #reinit_default_clock() net.run(trial_duration, report=report) g_total=np.sum(np.clip(pop_monitor['e'].values,0,1) * pop_monitor['x'].values, axis=0)+0.1 voxel_monitor=get_bold_signal(g_total, voxel.default_params, range(int(stimuli[0].start_time/simulation_clock.dt)), trial_duration) return voxel_monitor
def test_stim_pyramidal_impact(): simulation_clock = Clock(dt=.5 * ms) trial_duration = 1 * second dcs_start_time = .5 * second stim_levels = [-8, -6, -4, -2, -1, -.5, -.25, 0, .25, .5, 1, 2, 4, 6, 8] voltages = np.zeros(len(stim_levels)) for idx, stim_level in enumerate(stim_levels): print('testing stim_level %.3fpA' % stim_level) eqs = exp_IF(default_params.C, default_params.gL, default_params.EL, default_params.VT, default_params.DeltaT) # AMPA conductance - recurrent input current eqs += exp_synapse('g_ampa_r', default_params.tau_ampa, siemens) eqs += Current('I_ampa_r=g_ampa_r*(E-vm): amp', E=default_params.E_ampa) # AMPA conductance - background input current eqs += exp_synapse('g_ampa_b', default_params.tau_ampa, siemens) eqs += Current('I_ampa_b=g_ampa_b*(E-vm): amp', E=default_params.E_ampa) # AMPA conductance - task input current eqs += exp_synapse('g_ampa_x', default_params.tau_ampa, siemens) eqs += Current('I_ampa_x=g_ampa_x*(E-vm): amp', E=default_params.E_ampa) # Voltage-dependent NMDA conductance eqs += biexp_synapse('g_nmda', default_params.tau1_nmda, default_params.tau2_nmda, siemens) eqs += Equations('g_V = 1/(1+(Mg/3.57)*exp(-0.062 *vm/mV)) : 1 ', Mg=default_params.Mg) eqs += Current('I_nmda=g_V*g_nmda*(E-vm): amp', E=default_params.E_nmda) # GABA-A conductance eqs += exp_synapse('g_gaba_a', default_params.tau_gaba_a, siemens) eqs += Current('I_gaba_a=g_gaba_a*(E-vm): amp', E=default_params.E_gaba_a) eqs += InjectedCurrent('I_dcs: amp') group = NeuronGroup(1, model=eqs, threshold=-20 * mV, refractory=pyr_params.refractory, reset=default_params.Vr, compile=True, freeze=True, clock=simulation_clock) group.C = pyr_params.C group.gL = pyr_params.gL @network_operation(clock=simulation_clock) def inject_current(c): if simulation_clock.t > dcs_start_time: group.I_dcs = stim_level * pA monitor = StateMonitor(group, 'vm', simulation_clock, record=True) net = Network(group, monitor, inject_current) net.run(trial_duration, report='text') voltages[idx] = monitor.values[0, -1] * 1000 voltages = voltages - voltages[7] plt.figure() plt.plot(stim_levels, voltages) plt.xlabel('Stimulation level (pA)') plt.ylabel('Voltage Change (mV)') plt.show()
def __init__(self, network, lfp_source, voxel, sim_params, record_lfp=True, record_voxel=True, record_neuron_state=False, record_spikes=True, record_firing_rate=True, record_inputs=False, record_connections=None, save_summary_only=False, clock=defaultclock): self.network_params=network.params self.pyr_params=network.pyr_params self.inh_params=network.inh_params self.sim_params=sim_params self.plasticity_params=network.plasticity_params self.voxel_params=None if voxel is not None: self.voxel_params=voxel.params self.monitors={} self.save_summary_only=save_summary_only self.clock=clock self.record_lfp=record_lfp self.record_voxel=record_voxel self.record_neuron_state=record_neuron_state self.record_spikes=record_spikes self.record_firing_rate=record_firing_rate self.record_inputs=record_inputs self.record_connections=record_connections self.save_summary_only=save_summary_only # LFP monitor if self.record_lfp: self.monitors['lfp'] = StateMonitor(lfp_source, 'LFP', record=0, clock=clock) # Voxel monitor if self.record_voxel: self.monitors['voxel'] = MultiStateMonitor(voxel, vars=['G_total','G_total_exc','y'], record=True, clock=clock) # Network monitor if self.record_neuron_state: self.record_idx=[] for i in range(self.network_params.num_groups): e_idx=i*int(.8*self.network_params.network_group_size/self.network_params.num_groups) self.record_idx.append(e_idx) i_idx=int(.8*self.network_params.network_group_size) self.record_idx.append(i_idx) self.monitors['network'] = MultiStateMonitor(network, vars=['vm','g_ampa_r','g_ampa_x','g_ampa_b', 'g_gaba_a', 'g_nmda','I_ampa_r','I_ampa_x', 'I_ampa_b','I_gaba_a','I_nmda'], record=self.record_idx, clock=clock) # Population rate monitors if self.record_firing_rate: for i,group_e in enumerate(network.groups_e): self.monitors['excitatory_rate_%d' % i]=PopulationRateMonitor(group_e) self.monitors['inhibitory_rate']=PopulationRateMonitor(network.group_i) # Input rate monitors if record_inputs: self.monitors['background_rate']=PopulationRateMonitor(network.background_input) for i,task_input in enumerate(network.task_inputs): self.monitors['task_rate_%d' % i]=PopulationRateMonitor(task_input) # Spike monitors if self.record_spikes: for i,group_e in enumerate(network.groups_e): self.monitors['excitatory_spike_%d' % i]=SpikeMonitor(group_e) self.monitors['inhibitory_spike']=SpikeMonitor(network.group_i) # Connection monitors if self.record_connections is not None: for connection in record_connections: self.monitors['connection_%s' % connection]=ConnectionMonitor(network.connections[connection], store=True, clock=Clock(dt=.5*second))
from brian.experimental.synapses import * from brian import log_level_debug log_level_debug() set_global_preferences(useweave=True,usecodegen=True,usecodegenweave=True,usenewpropagate=True,usecstdp=True) from matplotlib.pyplot import plot, show, subplot params = {} params["t_Nr"] = 2*ms params["t_Nf"] = 80*ms params["t_AMPA"] = 5*ms simclock = Clock(dt=0.01*ms) input=NeuronGroup(2,model='dv/dt=1/(10*ms):1', threshold=1, reset=0,clock=simclock) neurons = NeuronGroup(1, model="""dv/dt=(NMDAo+AMPAo-v)/(10*ms) : 1 NMDAo : 1 AMPAo : 1""", freeze = True,clock=simclock) ampadyn = ''' dAMPAoS/dt = -AMPAoS/t_AMPA : 1 AMPAi = AMPAoS AMPAo = AMPAoS / (t_AMPA /msecond) : 1 ''' nmdadyn = ''' dNMDAoS/dt = (1/t_Nr)*(Nnor*NMDAi-NMDAoS) : 1 dNMDAi/dt = -(1/t_Nf)*NMDAi : 1