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