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 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 run_neglect(input_freq, delay_duration, net_params=default_params, output_file=None, record_lfp=True, record_voxel=True,
record_neuron_state=False, record_spikes=True, record_pop_firing_rate=True, record_neuron_firing_rate=False,
record_inputs=False, plot_output=False, mem_trial=False):
start_time=time()
# Init simulation parameters
background_input_size=1000
#background_rate=20*Hz
#background_rate=30*Hz
background_rate=25*Hz
visual_input_size=1000
#visual_background_rate=10*Hz
visual_background_rate=5*Hz
#visual_stim_min_rate=15*Hz
#visual_stim_min_rate=10*Hz
visual_stim_min_rate=8*Hz
visual_stim_tau=0.15
go_input_size=1000
go_rate=20*Hz
#go_background_rate=1*Hz
go_background_rate=0*Hz
lip_size=6250
#stim_start_time=1.8*second
#stim_end_time=2*second
stim_start_time=.5*second
stim_end_time=.7*second
#go_start_time=3*second
#go_end_time=3.1*second
#go_start_time=1.7*second
go_start_time=stim_end_time+delay_duration
#go_end_time=1.8*second
go_end_time=go_start_time+.2*second
trial_duration=go_end_time+.5*second
# Create network inputs
background_inputs=[PoissonGroup(background_input_size, rates=background_rate),
PoissonGroup(background_input_size, rates=background_rate)]
def make_mem_rate_function(rate):
return lambda t: ((stim_start_time<t<stim_end_time and np.max([visual_background_rate,rate*exp(-(t-stim_start_time)/visual_stim_tau)])) or visual_background_rate)
def make_delay_rate_function(rate):
return lambda t: ((stim_start_time<t and np.max([visual_stim_min_rate,rate*exp(-(t-stim_start_time)/visual_stim_tau)])) or visual_background_rate)
def make_go_rate_function():
return lambda t: ((go_start_time<t<go_end_time and go_rate) or go_background_rate)
lrate=input_freq[0]*Hz
rrate=input_freq[1]*Hz
if mem_trial:
visual_cortex_inputs=[PoissonGroup(visual_input_size, rates=make_mem_rate_function(lrate)),
PoissonGroup(visual_input_size, rates=make_mem_rate_function(rrate))]
else:
visual_cortex_inputs=[PoissonGroup(visual_input_size, rates=make_delay_rate_function(lrate)),
PoissonGroup(visual_input_size, rates=make_delay_rate_function(rrate))]
go_input=PoissonGroup(go_input_size, rates=make_go_rate_function())
# Create WTA network
brain_network=BrainNetworkGroup(lip_size, params=net_params, background_inputs=background_inputs,
visual_cortex_input=visual_cortex_inputs, go_input=go_input)
# LFP source
left_lip_lfp_source=LFPSource(brain_network.left_lip.e_group)
right_lip_lfp_source=LFPSource(brain_network.right_lip.e_group)
# Create voxel
left_lip_voxel=Voxel(network=brain_network.left_lip.neuron_group)
right_lip_voxel=Voxel(network=brain_network.right_lip.neuron_group)
# Create network monitor
brain_monitor=BrainMonitor(background_inputs, visual_cortex_inputs, go_input, brain_network, left_lip_lfp_source,
right_lip_lfp_source, left_lip_voxel, right_lip_voxel, record_lfp=record_lfp, record_voxel=record_voxel,
record_neuron_state=record_neuron_state, record_spikes=record_spikes, record_pop_firing_rate=record_pop_firing_rate,
record_neuron_firing_rates=record_neuron_firing_rate, record_inputs=record_inputs)
# Create Brian network and reset clock
net=Network(background_inputs, visual_cortex_inputs, go_input, brain_network, left_lip_lfp_source, right_lip_lfp_source,
left_lip_voxel, right_lip_voxel, brain_network.connections, brain_monitor.monitors)
reinit_default_clock()
print "Initialization time:", time() - start_time
# Run simulation
start_time = time()
net.run(trial_duration, report='text')
print "Simulation time:", time() - start_time
# Compute BOLD signal
if record_voxel:
start_time=time()
brain_monitor.left_voxel_exc_monitor=get_bold_signal(brain_monitor.left_voxel_monitor['G_total_exc'].values[0],
left_lip_voxel.params, [500, 1500], trial_duration)
brain_monitor.left_voxel_monitor=get_bold_signal(brain_monitor.left_voxel_monitor['G_total'].values[0],
left_lip_voxel.params, [500, 1500], trial_duration)
brain_monitor.right_voxel_exc_monitor=get_bold_signal(brain_monitor.right_voxel_monitor['G_total_exc'].values[0],
right_lip_voxel.params, [500, 1500], trial_duration)
brain_monitor.right_voxel_monitor=get_bold_signal(brain_monitor.right_voxel_monitor['G_total'].values[0],
right_lip_voxel.params, [500, 1500], trial_duration)
print 'Time to compute BOLD:', time() - start_time
# Plot outputs
if plot_output:
brain_monitor.plot(trial_duration)
if output_file is not None:
write_output(brain_network, background_input_size, background_rate, visual_input_size, input_freq,
trial_duration, stim_start_time, stim_end_time, go_start_time, go_end_time, record_pop_firing_rate,
record_neuron_state, record_spikes, record_voxel, record_lfp, record_inputs, output_file, left_lip_voxel,
right_lip_voxel, brain_monitor)
return brain_monitor
def run_wta(wta_params,
input_freq,
sim_params,
pyr_params=pyr_params(),
inh_params=inh_params(),
plasticity_params=plasticity_params(),
output_file=None,
save_summary_only=False,
record_lfp=True,
record_voxel=True,
record_neuron_state=False,
record_spikes=True,
record_firing_rate=True,
record_inputs=False,
record_connections=None,
plot_output=False,
report='text'):
"""
Run WTA network
wta_params = network parameters
input_freq = mean firing rate of each input group
output_file = output file to write to
save_summary_only = whether or not to save all data or just summary data to file
record_lfp = record LFP data if true
record_voxel = record voxel data if true
record_neuron_state = record neuron state data if true
record_spikes = record spike data if true
record_firing_rate = record network firing rates if true
record_inputs = record input firing rates if true
plot_output = plot outputs if true
"""
start_time = time()
simulation_clock = Clock(dt=sim_params.dt)
input_update_clock = Clock(dt=1 / (wta_params.refresh_rate / Hz) * second)
background_input = PoissonGroup(wta_params.background_input_size,
rates=wta_params.background_freq,
clock=simulation_clock)
task_inputs = []
for i in range(wta_params.num_groups):
task_inputs.append(
PoissonGroup(wta_params.task_input_size,
rates=wta_params.task_input_resting_rate,
clock=simulation_clock))
# Create WTA network
wta_network = WTANetworkGroup(params=wta_params,
background_input=background_input,
task_inputs=task_inputs,
pyr_params=pyr_params,
inh_params=inh_params,
plasticity_params=plasticity_params,
clock=simulation_clock)
@network_operation(when='start', clock=input_update_clock)
def set_task_inputs():
for idx in range(len(task_inputs)):
rate = wta_params.task_input_resting_rate
if sim_params.stim_start_time <= simulation_clock.t < sim_params.stim_end_time:
rate = input_freq[idx] * Hz + np.random.randn(
) * wta_params.input_var
if rate < wta_params.task_input_resting_rate:
rate = wta_params.task_input_resting_rate
task_inputs[idx]._S[0, :] = rate
@network_operation(clock=simulation_clock)
def inject_current():
if simulation_clock.t > sim_params.dcs_start_time:
wta_network.group_e.I_dcs = sim_params.p_dcs
wta_network.group_i.I_dcs = sim_params.i_dcs
# LFP source
lfp_source = LFPSource(wta_network.group_e, clock=simulation_clock)
# Create voxel
voxel = Voxel(simulation_clock, network=wta_network)
# Create network monitor
wta_monitor = WTAMonitor(wta_network,
lfp_source,
voxel,
sim_params,
record_lfp=record_lfp,
record_voxel=record_voxel,
record_neuron_state=record_neuron_state,
record_spikes=record_spikes,
record_firing_rate=record_firing_rate,
record_inputs=record_inputs,
record_connections=record_connections,
save_summary_only=save_summary_only,
clock=simulation_clock)
@network_operation(when='start', clock=simulation_clock)
def inject_muscimol():
if sim_params.muscimol_amount > 0:
wta_network.groups_e[
sim_params.
injection_site].g_muscimol = sim_params.muscimol_amount
# Create Brian network and reset clock
net = Network(background_input, task_inputs, set_task_inputs, wta_network,
lfp_source, voxel, wta_network.connections.values(),
wta_monitor.monitors.values(), inject_muscimol,
inject_current)
if sim_params.plasticity:
net.add(wta_network.stdp.values())
print "Initialization time: %.2fs" % (time() - start_time)
# writer=LaTeXDocumentWriter()
# labels={}
# labels[voxel]=('v',str(voxel))
# labels[background_input]=('bi',str(background_input))
# labels[lfp_source]=('lfp',str(lfp_source))
# labels[wta_network]=('n',str(wta_network))
# labels[wta_network.group_e]=('e',str(wta_network.group_e))
# labels[wta_network.group_i]=('i',str(wta_network.group_i))
# for i,e_group in enumerate(wta_network.groups_e):
# labels[e_group]=('e%d' % i,'%s %d' % (str(e_group),i))
# for i,task_input in enumerate(task_inputs):
# labels[task_input]=('t%d' % i,'%s %d' % (str(task_input),i))
# for name,conn in wta_network.connections.iteritems():
# labels[conn]=(name,str(conn))
# for name,monitor in wta_monitor.monitors.iteritems():
# labels[monitor]=(name,str(monitor))
# writer.document_network(net=net, labels=labels)
# Run simulation
start_time = time()
net.run(sim_params.trial_duration, report=report)
print "Simulation time: %.2fs" % (time() - start_time)
# Compute BOLD signal
if record_voxel:
start_time = time()
wta_monitor.monitors['voxel_exc'] = get_bold_signal(
wta_monitor.monitors['voxel']['G_total_exc'].values[0],
voxel.params, [500, 2500], sim_params.trial_duration)
wta_monitor.monitors['voxel'] = get_bold_signal(
wta_monitor.monitors['voxel']['G_total'].values[0], voxel.params,
[500, 2500], sim_params.trial_duration)
print "BOLD generation time: %.2fs" % (time() - start_time)
# Write output to file
if output_file is not None:
start_time = time()
wta_monitor.write_output(input_freq, output_file)
print 'Wrote output to %s' % output_file
print "Write output time: %.2fs" % (time() - start_time)
# Plot outputs
if plot_output:
wta_monitor.plot()
return wta_monitor
def run_wta(
wta_params,
input_freq,
sim_params,
pyr_params=pyr_params(),
inh_params=inh_params(),
plasticity_params=plasticity_params(),
output_file=None,
save_summary_only=False,
record_lfp=True,
record_voxel=True,
record_neuron_state=False,
record_spikes=True,
record_firing_rate=True,
record_inputs=False,
record_connections=None,
plot_output=False,
report="text",
):
"""
Run WTA network
wta_params = network parameters
input_freq = mean firing rate of each input group
output_file = output file to write to
save_summary_only = whether or not to save all data or just summary data to file
record_lfp = record LFP data if true
record_voxel = record voxel data if true
record_neuron_state = record neuron state data if true
record_spikes = record spike data if true
record_firing_rate = record network firing rates if true
record_inputs = record input firing rates if true
plot_output = plot outputs if true
"""
start_time = time()
simulation_clock = Clock(dt=sim_params.dt)
input_update_clock = Clock(dt=1 / (wta_params.refresh_rate / Hz) * second)
background_input = PoissonGroup(
wta_params.background_input_size, rates=wta_params.background_freq, clock=simulation_clock
)
task_inputs = []
for i in range(wta_params.num_groups):
task_inputs.append(
PoissonGroup(wta_params.task_input_size, rates=wta_params.task_input_resting_rate, clock=simulation_clock)
)
# Create WTA network
wta_network = WTANetworkGroup(
params=wta_params,
background_input=background_input,
task_inputs=task_inputs,
pyr_params=pyr_params,
inh_params=inh_params,
plasticity_params=plasticity_params,
clock=simulation_clock,
)
@network_operation(when="start", clock=input_update_clock)
def set_task_inputs():
for idx in range(len(task_inputs)):
rate = wta_params.task_input_resting_rate
if sim_params.stim_start_time <= simulation_clock.t < sim_params.stim_end_time:
rate = input_freq[idx] * Hz + np.random.randn() * wta_params.input_var
if rate < wta_params.task_input_resting_rate:
rate = wta_params.task_input_resting_rate
task_inputs[idx]._S[0, :] = rate
@network_operation(clock=simulation_clock)
def inject_current():
if simulation_clock.t > sim_params.dcs_start_time:
wta_network.group_e.I_dcs = sim_params.p_dcs
wta_network.group_i.I_dcs = sim_params.i_dcs
# LFP source
lfp_source = LFPSource(wta_network.group_e, clock=simulation_clock)
# Create voxel
voxel = Voxel(simulation_clock, network=wta_network)
# Create network monitor
wta_monitor = WTAMonitor(
wta_network,
lfp_source,
voxel,
sim_params,
record_lfp=record_lfp,
record_voxel=record_voxel,
record_neuron_state=record_neuron_state,
record_spikes=record_spikes,
record_firing_rate=record_firing_rate,
record_inputs=record_inputs,
record_connections=record_connections,
save_summary_only=save_summary_only,
clock=simulation_clock,
)
@network_operation(when="start", clock=simulation_clock)
def inject_muscimol():
if sim_params.muscimol_amount > 0:
wta_network.groups_e[sim_params.injection_site].g_muscimol = sim_params.muscimol_amount
# Create Brian network and reset clock
net = Network(
background_input,
task_inputs,
set_task_inputs,
wta_network,
lfp_source,
voxel,
wta_network.connections.values(),
wta_monitor.monitors.values(),
inject_muscimol,
inject_current,
)
if sim_params.plasticity:
net.add(wta_network.stdp.values())
print "Initialization time: %.2fs" % (time() - start_time)
# writer=LaTeXDocumentWriter()
# labels={}
# labels[voxel]=('v',str(voxel))
# labels[background_input]=('bi',str(background_input))
# labels[lfp_source]=('lfp',str(lfp_source))
# labels[wta_network]=('n',str(wta_network))
# labels[wta_network.group_e]=('e',str(wta_network.group_e))
# labels[wta_network.group_i]=('i',str(wta_network.group_i))
# for i,e_group in enumerate(wta_network.groups_e):
# labels[e_group]=('e%d' % i,'%s %d' % (str(e_group),i))
# for i,task_input in enumerate(task_inputs):
# labels[task_input]=('t%d' % i,'%s %d' % (str(task_input),i))
# for name,conn in wta_network.connections.iteritems():
# labels[conn]=(name,str(conn))
# for name,monitor in wta_monitor.monitors.iteritems():
# labels[monitor]=(name,str(monitor))
# writer.document_network(net=net, labels=labels)
# Run simulation
start_time = time()
net.run(sim_params.trial_duration, report=report)
print "Simulation time: %.2fs" % (time() - start_time)
# Compute BOLD signal
if record_voxel:
start_time = time()
wta_monitor.monitors["voxel_exc"] = get_bold_signal(
wta_monitor.monitors["voxel"]["G_total_exc"].values[0], voxel.params, [500, 2500], sim_params.trial_duration
)
wta_monitor.monitors["voxel"] = get_bold_signal(
wta_monitor.monitors["voxel"]["G_total"].values[0], voxel.params, [500, 2500], sim_params.trial_duration
)
print "BOLD generation time: %.2fs" % (time() - start_time)
# Write output to file
if output_file is not None:
start_time = time()
wta_monitor.write_output(input_freq, output_file)
print "Wrote output to %s" % output_file
print "Write output time: %.2fs" % (time() - start_time)
# Plot outputs
if plot_output:
wta_monitor.plot()
return wta_monitor
