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