def plot_pop_raster(net, plot_inh=False): """plot rasterplot of whole E/I populations""" pyplot.figure() bb.raster_plot(net.mon_spike_e) if plot_inh: pyplot.figure() bb.raster_plot(net.mon_spike_i)
def main(): tmax = 50e-3 # second cn.set_fs(40e3) # Hz # anf_trains are normally generated by something like # cochlea.run_zilany2009() anf_trains = pd.DataFrame([ {'spikes': np.array([10e-3, 30e-3]), 'duration': tmax}, {'spikes': np.array([20e-3, 40e-3]), 'duration': tmax}, ]) # Generate ANF and GBC groups anfs = cn.make_anf_group(anf_trains) gbcs = cn.make_gbc_group(10) # Connect ANFs and GBCs synapses = brian.Connection( anfs, gbcs, 'ge_syn', ) synapses.connect_random( anfs, gbcs, p=0.5, fixed=True, weight=1e-6*siemens ) # Monitors for the GBCs spikes = brian.SpikeMonitor(gbcs) voltages = brian.StateMonitor(gbcs, 'vm', record=True) # Run the simulation cn.run( duration=tmax, objects=[anfs, gbcs, synapses, spikes, voltages] ) # Present the results print(spikes.spikes) fig, ax = plt.subplots(2,1) plt.sca(ax[0]) brian.raster_plot(spikes) plt.sca(ax[1]) voltages.plot() plt.show()
def save_and_plot_results(): global fig_num print '...saving results' if not test_mode: save_theta() if not test_mode: save_connections() else: np.save(top_level_path + 'activity/conv_patch_connectivity_activity/results_' + str(num_examples) + '_' + ending, result_monitor) np.save(top_level_path + 'activity/conv_patch_connectivity_activity/input_numbers_' + str(num_examples) + '_' + ending, input_numbers) if do_plot: if rate_monitors: b.figure(fig_num) fig_num += 1 for i, name in enumerate(rate_monitors): b.subplot(len(rate_monitors), 1, i + 1) b.plot(rate_monitors[name].times / b.second, rate_monitors[name].rate, '.') b.title('Rates of population ' + name) if spike_monitors: b.figure(fig_num) fig_num += 1 for i, name in enumerate(spike_monitors): b.subplot(len(spike_monitors), 1, i + 1) b.raster_plot(spike_monitors[name]) b.title('Spikes of population ' + name) if spike_counters: b.figure(fig_num) fig_num += 1 for i, name in enumerate(spike_counters): b.subplot(len(spike_counters), 1, i + 1) b.plot(np.asarray(spike_counters['Ae'].count[:])) b.title('Spike count of population ' + name) plot_2d_input_weights() plot_patch_weights() b.ioff() b.show()
def _print_graphs(self, traj): """Makes some plots and stores them into subfolders""" print_folder = self._make_folder(traj) # If we use BRIAN's own raster_plot functionality we # need to sue the SpikeMonitor directly raster_plot(self.spike_monitor, newfigure=True, xlabel='t', ylabel='Exc. Neurons', title='Spike Raster Plot') filename = os.path.join(print_folder, 'spike.png') print 'Current plot: %s ' % filename plt.savefig(filename) plt.close() fig = plt.figure() self._plot_result(traj, 'monitors.V') filename = os.path.join(print_folder, 'V.png') print 'Current plot: %s ' % filename fig.savefig(filename) plt.close() plt.figure() self._plot_result(traj, 'monitors.I_syn_e') filename = os.path.join(print_folder, 'I_syn_e.png') print 'Current plot: %s ' % filename plt.savefig(filename) plt.close() plt.figure() self._plot_result(traj, 'monitors.I_syn_i') filename = os.path.join(print_folder, 'I_syn_i.png') print 'Current plot: %s ' % filename plt.savefig(filename) plt.close() if not traj.analysis.show_plots: plt.close('all') else: plt.show()
def main(): fs = 100e3 cf = 1e3 tmax = 50e-3 sound = wv.ramped_tone( fs=fs, freq=cf, duration=tmax, pad=30e-3, dbspl=50, ) anf_trains = cochlea.run_zilany2014( sound=sound, fs=fs, cf=cf, anf_num=(300, 0, 0), seed=0, species='cat', ) anfs = cochlea.make_brian_group(anf_trains) print(anfs) brainstem = make_brainstem_group(100) print(brainstem) monitor = brian.SpikeMonitor(brainstem) net = brian.Network([brainstem, monitor]) net.run(tmax*second) brian.raster_plot(monitor) brian.show()
def _print_graphs(self, traj): """Makes some plots and stores them into subfolders""" print_folder = self._make_folder(traj) # If we use BRIAN's own raster_plot functionality we # need to sue the SpikeMonitor directly raster_plot(self.spike_monitor, newfigure=True, xlabel='t', ylabel='Exc. Neurons', title='Spike Raster Plot') filename=os.path.join(print_folder,'spike.png') print 'Current plot: %s ' % filename plt.savefig(filename) plt.close() fig=plt.figure() self._plot_result(traj, 'monitors.V') filename=os.path.join(print_folder,'V.png') print 'Current plot: %s ' % filename fig.savefig(filename) plt.close() plt.figure() self._plot_result(traj, 'monitors.I_syn_e') filename=os.path.join(print_folder,'I_syn_e.png') print 'Current plot: %s ' % filename plt.savefig(filename) plt.close() plt.figure() self._plot_result(traj, 'monitors.I_syn_i') filename=os.path.join(print_folder,'I_syn_i.png') print 'Current plot: %s ' % filename plt.savefig(filename) plt.close() if not traj.analysis.show_plots: plt.close('all') else: plt.show()
def main(): fs = 100e3 cf = 1e3 tmax = 50e-3 sound = wv.ramped_tone( fs=fs, freq=cf, duration=tmax, pad=30e-3, dbspl=50, ) anf_trains = cochlea.run_zilany2014( sound=sound, fs=fs, cf=cf, anf_num=(300, 0, 0), seed=0, species='cat', ) anfs = cochlea.make_brian_group(anf_trains) print(anfs) brainstem = make_brainstem_group(100) print(brainstem) monitor = brian.SpikeMonitor(brainstem) net = brian.Network([brainstem, monitor]) net.run(tmax * second) brian.raster_plot(monitor) brian.show()
def plot_rast_V_I_contraster(net, nrn=-2, xlim = [16500,17500]): """ For plotting Fig 2 plots a ratser of a reduced PS, conductances, currents, voltage of a neuron in a single figure puts an extra raster of a continuous sequence replay """ from figure_subplots import draw_evoked_rasta2 tres = .1 # time resolution for conductance figure = pyplot.figure(figsize=(18., 12.)) gs = gridspec.GridSpec(25, 12) gs.update(left=.04, wspace=.0, hspace=.0) ylab_xposit = xlim[0] - 80 ################################################################ # raster for continious ASS at the bottom of the figure x0 = 20500 x1 = 21500 xticks=numpy.arange(x0, x1+1, 200) xticks_lab = numpy.arange(0, x1-x0+1, 200) sub_rast2 = pyplot.subplot(gs[19:25, 1:12]) fname = 'contin_ass_pf0.06pr0.06.npz' draw_evoked_rasta2(fname, '', x0=x0, x1=x1) yticks=[0, 100, 200, 300, 400, 500] yticks=[0, 2500, 5000] sub_rast2.set_yticks(yticks) sub_rast2.set_yticklabels(yticks, size=20) sub_rast2.xaxis.set_tick_params(width=1, length=5) sub_rast2.yaxis.set_tick_params(width=1, length=5) #sub_rast.set_ylabel('Neurons',size=18) sub_rast2.text(x0-80, 3750, 'Neuron #', rotation = 'vertical', size=20) sub_rast2.set_xticks(xticks) sub_rast2.set_xticklabels(xticks_lab, size=20) pyplot.xlabel('Time [ms]', size=20) sub_rast2.text(xticks[0]-130, 5000., 'D', size=28, color='black') ################################################################ xticks=numpy.arange(xlim[0], xlim[1]+1, 200) xticks_lab = numpy.arange(0, xlim[1]-xlim[0]+1, 200) cxlim = [xlim[0]/tres, xlim[1]/tres] #lim for the vectors(with tres in mind) ################################################################ sub_rast = pyplot.subplot(gs[12:18, 1:12]) m = bb.Monitor() m.source = [] frac = 1. m.spikes = calc_spikes.get_spike_times_ps(net, 0, frac) bb.raster_plot(m, color=(0, 0, 0))#, #showgrouplines=True, #spacebetweengroups=0.1, grouplinecol=(0.5, 0.5, 0.5)) # spikes of measured neuron in red o., # now it works automatically just with neurons from the last group nrn_spikes_all = net.mon_spike_e[net.nrn_meas_e[nrn]] nrn_spikes = nrn_spikes_all[numpy.logical_and( nrn_spikes_all >= xlim[0]/1000., nrn_spikes_all <= xlim[1]/1000.)] raster_sp_x = nrn_spikes*1000. raster_sp_y = (net.nrn_meas_e[nrn])*numpy.ones(len(nrn_spikes)) pyplot.plot(raster_sp_x, raster_sp_y, 'o', color='red') pyplot.plot(raster_sp_x, raster_sp_y, '.', color='red') sub_rast.set_xlim(xlim) sub_rast.set_xticks(xticks) sub_rast.set_xticklabels([]) sub_rast.set_xlabel('') # put some lines between groups for i in range(net.n_ass): sub_rast.plot(numpy.arange(xlim[0],xlim[1]), (i+1)*frac*net.s_ass*numpy.ones(1000),'gray') # put an arrow for the neuron we record from #pyplot.text(xlim[0]+500-18, -60, '$\Uparrow$', size=25) yticks=[0, 100, 200, 300, 400, 500] yticks=[0, 2500, 5000] sub_rast.set_ylabel('', size=20) sub_rast.set_yticks(yticks) sub_rast.set_yticklabels(yticks, size=20) sub_rast.xaxis.set_tick_params(width=1, length=5) sub_rast.yaxis.set_tick_params(width=1, length=5) sub_rast.text(ylab_xposit, 3750, 'Neuron #', rotation = 'vertical', size=20) #sub_rast.set_xticklabels(xticks_lab, size=20) #pyplot.xlabel('Time [ms]', size=20) sub_rast.text(xticks[0]-130, 5000., 'C', size=28, color='black') ################################################################ #sub_curr = pyplot.subplot(gs[9:13,0:12]) sub_curr = pyplot.subplot(gs[0:5,1:12]) yticks=[-200,0,200,400] curr_e= net.mon_ecurr_e[net.nrn_meas_e[nrn]]/pA+200 curr_i= net.mon_icurr_e[net.nrn_meas_e[nrn]]/pA volt_e= net.mon_volt_e[net.nrn_meas_e[nrn]]/mV # measured voltage here curr_leak = 10.*nS*(-60.-volt_e)*mV/pA curr_maxe=(curr_e[cxlim[0]:cxlim[1]]).max() curr_maxi=(curr_i[cxlim[0]:cxlim[1]]).max() curr_mine=(curr_e[cxlim[0]:cxlim[1]]).min() curr_mini=(curr_i[cxlim[0]:cxlim[1]]).min() pyplot.plot(net.mon_ecurr_e.times/ms, curr_e,'r') pyplot.plot(net.mon_ecurr_e.times/ms, curr_i,'b') pyplot.plot(net.mon_ecurr_e.times/ms, curr_e+curr_i+curr_leak,'black') ylim=[1.2*min(curr_mine,curr_mini),1.2*max(curr_maxe,curr_maxi)] remove_spines(sub_curr,xlim=xlim,ylim=ylim,xticks=[],yticks=yticks, #ylabel='I [pA]',legend= ['$I_{exc}$','$I_{inh}$']) ylabel='I [pA]',legend= []) sub_curr.set_ylabel('',size=20) sub_curr.text(ylab_xposit, 370, 'Current [pA]', rotation = 'vertical', size=20) sub_curr.set_yticks(yticks) sub_curr.set_yticklabels(yticks,size=20) sub_curr.yaxis.set_tick_params(width=1, length=5) #sub_curr.text(xticks[-1]-00,-200.,'$I_{inh}$',color='red',size=18) #sub_curr.text(xticks[-1]-00,50.,'$I_{tot}$',color='black',size=18) #sub_curr.text(xticks[-1]-00,250.,'$I_{exc}$',color='green',size=18) sub_curr.text(xticks[-2]-5, -320., 'Inhibition', size=20, color='b', zorder=3) sub_curr.text(xticks[-2]-5, 80., 'Total', size=20, zorder=3) sub_curr.text(xticks[-2]-5, 300., 'Excitation', size=20, color='r', zorder=3) sub_curr.text(xticks[0]-130, 500., 'A', size=28, color='black') ################################################################ #raster_sp_x = nrn_spikes*1000 #raster_sp_y = (491+nrn)*numpy.ones(len(nrn_spikes)) #sub_volt = pyplot.subplot(gs[16:20,0:12]) sub_volt = pyplot.subplot(gs[6:11,1:12]) for i,v in enumerate(volt_e): if v<-59 and volt_e[i-1]>-55: #pyplot.vlines((i-1)*tres,-50,-40) volt_e[i-1] = -40 #volt_e[i] = -40 #volt_e[i+1] = -40 #print i pyplot.plot(net.mon_volt_e.times/ms, volt_e,'black') volt_sp_x = nrn_spikes*1000 volt_sp_y = -40*numpy.ones(len(volt_sp_x)) pyplot.plot(volt_sp_x,volt_sp_y,'o',color='red') #for i,v in enumerate(volt_e): #if volt_e[i-1]>-45: #pyplot.plot((i-1)*tres,-40,'o',color='red') ylim=[-62,-39] yticks=[-60,-50,-40] #remove_spines(sub_volt,xlim=xlim,ylim=ylim, #xticks=xticks,yticks=yticks, #ylabel='V [mV]',legend= [],keepx=True) remove_spines(sub_volt,xlim=xlim,ylim=ylim, xticks=[],yticks=yticks, ylabel='V [mV]',legend= []) #sub_volt.set_xticklabels(xticks_lab, size=18) #pyplot.xlabel('Time [ms]',size=18) sub_volt.set_ylabel('',size=20) sub_volt.text(ylab_xposit,-40,'Voltage [mV]',rotation = 'vertical',size=20) sub_volt.set_yticks(yticks) sub_volt.set_yticklabels(yticks,size=20) sub_volt.yaxis.set_tick_params(width=1,length=5) sub_volt.plot(numpy.arange(xlim[0],xlim[1]), -50.*numpy.ones(1000),'-.',color = 'gray') sub_volt.text(xticks[0]-130,-40.,'B',size=28,color='black') #sub_volt.text(xticks[-1]-00,-55.,'$V_{m}$',color='black',size=18) # draw vertical lines between spikes in raster and voltage trace linii_nekvi=[] curr_sp_y = 400. for i in range(len(volt_sp_x)): #linii_nekvi.append(get_straightline(figure,sub_rast,sub_volt, # raster_sp_x[i],raster_sp_y[i],volt_sp_x[i],volt_sp_y[i])) linii_nekvi.append(get_straightline(figure,sub_rast,sub_curr, raster_sp_x[i],raster_sp_y[i],volt_sp_x[i],curr_sp_y)) ''' transFigure = figure.transFigure.inverted() c1x = raster_sp_x[0] c1y = raster_sp_y[0] c2x = volt_sp_x[0] c2y = volt_sp_y[0] coord1 = transFigure.transform(sub_rast.transData.transform([c1x,c1y])) coord2 = transFigure.transform(sub_volt.transData.transform([c2x,c2y])) line = matplotlib.lines.Line2D((coord1[0],coord2[0]),(coord1[1],coord2[1]), transform=figure.transFigure,color='gray',alpha=.9) print c1x,c1y,c2x,c2y print coord1, coord2 ''' figure.lines = linii_nekvi loc='tfigs/rcv6/' prefix = 'rccv_' fname = 'prf' + str(net.pr_ee) + str(net.pf_ee) + '_' + \ str(-nrn) + '_int' + str(xlim[0]) figure.savefig(loc+prefix+fname+'.eps', format='eps') figure.savefig(loc+prefix+fname+'.png', format='png') figure.savefig(loc+prefix+fname+'.pdf', format='pdf') #pyplot.close() pyplot.show()
def __init__(self, n_input=784, conv_size=16, conv_stride=4, conv_features=50, connectivity='all', weight_dependence=False, post_pre=True, weight_sharing=False, lattice_structure='4', random_lattice_prob=0.0, random_inhibition_prob=0.0): ''' Constructor for the spiking convolutional neural network model. n_input: (flattened) dimensionality of the input data conv_size: side length of convolution windows used conv_stride: stride (horizontal and vertical) of convolution windows used conv_features: number of convolution features (or patches) used connectivity: connection style between patches; one of 'none', 'pairs', all'; more to be added weight_dependence: whether to use weight STDP with weight dependence post_pre: whether to use STDP with both post- and pre-synpatic traces weight_sharing: whether to impose that all neurons within a convolution patch share a common set of weights lattice_structure: lattice connectivity pattern between patches; one of 'none', '4', '8', and 'all' random_lattice_prob: probability of adding random additional lattice connections between patches random_inhibition_prob: probability of adding random additional inhibition edges from the inhibitory to excitatory population ''' self.n_input, self.conv_size, self.conv_stride, self.conv_features, self.connectivity, self.weight_dependence, \ self.post_pre, self.weight_sharing, self.lattice_structure, self.random_lattice_prob, self.random_inhibition_prob = \ n_input, conv_size, conv_stride, conv_features, connectivity, weight_dependence, post_pre, weight_sharing, lattice_structure, \ random_lattice_prob, random_inhibition_prob # number of inputs to the network self.n_input_sqrt = int(math.sqrt(self.n_input)) self.n_excitatory_patch = ( (self.n_input_sqrt - self.conv_size) / self.conv_stride + 1)**2 self.n_excitatory = self.n_excitatory_patch * self.conv_features self.n_excitatory_patch_sqrt = int(math.sqrt(self.n_excitatory_patch)) self.n_inhibitory_patch = self.n_excitatory_patch self.n_inhibitory = self.n_excitatory self.conv_features_sqrt = int(math.ceil(math.sqrt(self.conv_features))) # time (in seconds) per data example presentation and rest period in between self.single_example_time = 0.35 * b.second self.resting_time = 0.15 * b.second # set update intervals self.update_interval = 100 self.weight_update_interval = 10 self.print_progress_interval = 10 # rest potential parameters, reset potential parameters, threshold potential parameters, and refractory periods v_rest_e, v_rest_i = -65. * b.mV, -60. * b.mV v_reset_e, v_reset_i = -65. * b.mV, -45. * b.mV v_thresh_e, v_thresh_i = -52. * b.mV, -40. * b.mV refrac_e, refrac_i = 5. * b.ms, 2. * b.ms # time constants, learning rates, max weights, weight dependence, etc. tc_pre_ee, tc_post_ee = 20 * b.ms, 20 * b.ms nu_ee_pre, nu_ee_post = 0.0001, 0.01 exp_ee_post = exp_ee_pre = 0.2 w_mu_pre, w_mu_post = 0.2, 0.2 # parameters for neuron equations tc_theta = 1e7 * b.ms theta_plus = 0.05 * b.mV scr_e = 'v = v_reset_e; theta += theta_plus; timer = 0*ms' offset = 20.0 * b.mV v_thresh_e = '(v>(theta - offset + ' + str( v_thresh_e) + ')) * (timer>refrac_e)' # equations for neurons neuron_eqs_e = ''' dv / dt = ((v_rest_e - v) + (I_synE + I_synI) / nS) / (100 * ms) : volt I_synE = ge * nS * - v : amp I_synI = gi * nS * (-100. * mV - v) : amp dge / dt = -ge / (1.0*ms) : 1 dgi / dt = -gi / (2.0*ms) : 1 dtheta / dt = -theta / (tc_theta) : volt dtimer / dt = 100.0 : ms ''' neuron_eqs_i = ''' dv/dt = ((v_rest_i - v) + (I_synE + I_synI) / nS) / (10*ms) : volt I_synE = ge * nS * -v : amp I_synI = gi * nS * (-85.*mV-v) : amp dge/dt = -ge/(1.0*ms) : 1 dgi/dt = -gi/(2.0*ms) : 1 ''' # STDP synaptic traces eqs_stdp_ee = ''' dpre / dt = -pre / tc_pre_ee : 1.0 dpost / dt = -post / tc_post_ee : 1.0 ''' # dictionaries for weights and delays self.weight, self.delay = {}, {} # setting weight, delay, and intensity parameters self.weight['ee_input'] = (conv_size**2) * 0.175 self.delay['ee_input'] = (0 * b.ms, 10 * b.ms) self.delay['ei_input'] = (0 * b.ms, 5 * b.ms) self.input_intensity = self.start_input_intensity = 2.0 self.wmax_ee = 1.0 # populations, connections, saved connections, etc. self.input_population_names = ['X'] self.population_names = ['A'] self.input_connection_names = ['XA'] self.save_connections = ['XeAe', 'AeAe'] self.input_connection_names = ['ee_input'] self.recurrent_connection_names = ['ei', 'ie', 'ee'] # setting STDP update rule if weight_dependence: if post_pre: eqs_stdp_pre_ee = 'pre = 1.; w -= nu_ee_pre * post * w ** exp_ee_pre' eqs_stdp_post_ee = 'w += nu_ee_post * pre * (wmax_ee - w) ** exp_ee_post; post = 1.' else: eqs_stdp_pre_ee = 'pre = 1.' eqs_stdp_post_ee = 'w += nu_ee_post * pre * (wmax_ee - w) ** exp_ee_post; post = 1.' else: if post_pre: eqs_stdp_pre_ee = 'pre = 1.; w -= nu_ee_pre * post' eqs_stdp_post_ee = 'w += nu_ee_post * pre; post = 1.' else: eqs_stdp_pre_ee = 'pre = 1.' eqs_stdp_post_ee = 'w += nu_ee_post * pre; post = 1.' print '\n' # for filesaving purposes stdp_input = '' if self.weight_dependence: stdp_input += 'weight_dependence_' else: stdp_input += 'no_weight_dependence_' if self.post_pre: stdp_input += 'post_pre' else: stdp_input += 'no_post_pre' if self.weight_sharing: use_weight_sharing = 'weight_sharing' else: use_weight_sharing = 'no_weight_sharing' # set ending of filename saves self.ending = self.connectivity + '_' + str(self.conv_size) + '_' + str(self.conv_stride) + '_' + str(self.conv_features) + \ '_' + str(self.n_excitatory_patch) + '_' + stdp_input + '_' + \ use_weight_sharing + '_' + str(self.lattice_structure) + '_' + str(self.random_lattice_prob) + \ '_' + str(self.random_inhibition_prob) self.fig_num = 1 # creating dictionaries for various objects self.neuron_groups, self.input_groups, self.connections, self.input_connections, self.stdp_methods, self.rate_monitors, \ self.spike_monitors, self.spike_counters, self.output_numbers = {}, {}, {}, {}, {}, {}, {}, {}, {} # creating convolution locations inside the input image self.convolution_locations = {} for n in xrange(self.n_excitatory_patch): self.convolution_locations[n] = [ ((n % self.n_excitatory_patch_sqrt) * self.conv_stride + (n // self.n_excitatory_patch_sqrt) \ * self.n_input_sqrt * self.conv_stride) + (x * self.n_input_sqrt) + y \ for y in xrange(self.conv_size) for x in xrange(self.conv_size) ] # instantiating neuron spike / votes monitor self.result_monitor = np.zeros( (self.update_interval, self.conv_features, self.n_excitatory_patch)) # creating overarching neuron populations self.neuron_groups['e'] = b.NeuronGroup(self.n_excitatory, neuron_eqs_e, threshold=v_thresh_e, \ refractory=refrac_e, reset=scr_e, compile=True, freeze=True) self.neuron_groups['i'] = b.NeuronGroup(self.n_inhibitory, neuron_eqs_i, threshold=v_thresh_i, \ refractory=refrac_i, reset=v_reset_i, compile=True, freeze=True) # create neuron subpopulations for name in self.population_names: print '...creating neuron group:', name # get a subgroup of size 'n_e' from all exc self.neuron_groups[name + 'e'] = self.neuron_groups['e'].subgroup( self.conv_features * self.n_excitatory_patch) # get a subgroup of size 'n_i' from the inhibitory layer self.neuron_groups[name + 'i'] = self.neuron_groups['i'].subgroup( self.conv_features * self.n_excitatory_patch) # start the membrane potentials of these groups 40mV below their resting potentials self.neuron_groups[name + 'e'].v = v_rest_e - 40. * b.mV self.neuron_groups[name + 'i'].v = v_rest_i - 40. * b.mV print '...creating recurrent connections' for name in self.population_names: # set the adaptive additive threshold parameter at 20mV self.neuron_groups['e'].theta = np.ones( (self.n_excitatory)) * 20.0 * b.mV for connection_type in self.recurrent_connection_names: if connection_type == 'ei': # create connection name (composed of population and connection types) connection_name = name + connection_type[ 0] + name + connection_type[1] # create a connection from the first group in conn_name with the second group self.connections[connection_name] = b.Connection(self.neuron_groups[connection_name[0:2]], \ self.neuron_groups[connection_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection for feature in xrange(self.conv_features): for n in xrange(self.n_excitatory_patch): self.connections[conn_name][feature * self.n_excitatory_patch + n, \ feature * self.n_excitatory_patch + n] = 10.4 elif connection_type == 'ie': # create connection name (composed of population and connection types) connection_name = name + connection_type[ 0] + name + connection_type[1] # create a connection from the first group in conn_name with the second group self.connections[connection_name] = b.Connection(self.neuron_groups[connection_name[0:2]], \ self.neuron_groups[connection_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection for feature in xrange(self.conv_features): for other_feature in xrange(self.conv_features): if feature != other_feature: for n in xrange(self.n_excitatory_patch): self.connections[connection_name][feature * self.n_excitatory_patch + n, \ other_feature * self.n_excitatory_patch + n] = 17.4 # adding random inhibitory connections as specified if self.random_inhibition_prob != 0.0: for feature in xrange(self.conv_features): for other_feature in xrange(self.conv_features): for n_this in xrange(self.n_excitatory_patch): for n_other in xrange( self.n_excitatory_patch): if n_this != n_other: if b.random( ) < self.random_inhibition_prob: self.connections[connection_name][feature * self.n_excitatory_patch + n_this, \ other_feature * self.n_excitatory_patch + n_other] = 17.4 elif connection_type == 'ee': # create connection name (composed of population and connection types) connection_name = name + connection_type[ 0] + name + connection_type[1] # create a connection from the first group in conn_name with the second group self.connections[connection_name] = b.Connection(self.neuron_groups[connection_name[0:2]], \ self.neuron_groups[connection_name[2:4]], structure='sparse', state='g' + connection_type[0]) # instantiate the created connection if self.connectivity == 'all': for feature in xrange(self.conv_features): for other_feature in xrange(self.conv_features): if feature != other_feature: for this_n in xrange( self.n_excitatory_patch): for other_n in xrange( self.n_excitatory_patch): if is_lattice_connection( self. n_excitatory_patch_sqrt, this_n, other_n): self.connections[connection_name][feature * self.n_excitatory_patch + this_n, \ other_feature * self.n_excitatory_patch + other_n] = \ (b.random() + 0.01) * 0.3 elif self.connectivity == 'pairs': for feature in xrange(self.conv_features): if feature % 2 == 0: for this_n in xrange(self.n_excitatory_patch): for other_n in xrange( self.n_excitatory_patch): if is_lattice_connection( self.n_excitatory_patch_sqrt, this_n, other_n): self.connections[connection_name][feature * self.n_excitatory_patch + this_n, \ (feature + 1) * self.n_excitatory_patch + other_n] = (b.random() + 0.01) * 0.3 elif feature % 2 == 1: for this_n in xrange(self.n_excitatory_patch): for other_n in xrange( self.n_excitatory_patch): if is_lattice_connection( self.n_excitatory_patch_patch, this_n, other_n): self.connections[connection_name][feature * self.n_excitatory_patch + this_n, \ (feature - 1) * self.n_excitatory_patch + other_n] = (b.random() + 0.01) * 0.3 elif connectivity == 'linear': for feature in xrange(self.conv_features): if feature != self.conv_features - 1: for this_n in xrange(self.n_excitatory_patch): for other_n in xrange( self.n_excitatory_patch): if is_lattice_connection( self.n_excitatory_patch_sqrt, this_n, other_n): self.connections[connection_name][feature * self.n_excitatory_patch + this_n, \ (feature + 1) * self.n_excitatory_patch + other_n] = \ (b.random() + 0.01) * 0.3 if feature != 0: for this_n in xrange(self.n_excitatory_patch): for other_n in xrange( self.n_excitatory_patch): if is_lattice_connection( self.n_excitatory_patch_sqrt, this_n, other_n): self.connections[connection_name][feature * self.n_excitatory_patch + this_n, \ (feature - 1) * self.n_excitatory_patch + other_n] = \ (b.random() + 0.01) * 0.3 elif self.connectivity == 'none': pass # if STDP from excitatory -> excitatory is on and this connection is excitatory -> excitatory if 'ee' in self.recurrent_conn_names: self.stdp_methods[name + 'e' + name + 'e'] = b.STDP(self.connections[name + 'e' + name + 'e'], \ eqs=eqs_stdp_ee, pre=eqs_stdp_pre_ee, \ post=eqs_stdp_post_ee, wmin=0., wmax=self.wmax_ee) print '...creating monitors for:', name # spike rate monitors for excitatory and inhibitory neuron populations self.rate_monitors[name + 'e'] = b.PopulationRateMonitor(self.neuron_groups[name + 'e'], \ bin=(self.single_example_time + self.resting_time) / b.second) self.rate_monitors[name + 'i'] = b.PopulationRateMonitor(self.neuron_groups[name + 'i'], \ bin=(self.single_example_time + self.resting_time) / b.second) self.spike_counters[name + 'e'] = b.SpikeCounter( self.neuron_groups[name + 'e']) # record neuron population spikes self.spike_monitors[name + 'e'] = b.SpikeMonitor( self.neuron_groups[name + 'e']) self.spike_monitors[name + 'i'] = b.SpikeMonitor( self.neuron_groups[name + 'i']) if do_plot: b.figure(self.fig_num) fig_num += 1 b.ion() b.subplot(211) b.raster_plot(self.spike_monitors['Ae'], refresh=1000 * b.ms, showlast=1000 * b.ms) b.subplot(212) b.raster_plot(self.spike_monitors['Ai'], refresh=1000 * b.ms, showlast=1000 * b.ms) # specifying locations of lattice connections self.lattice_locations = {} if self.connectivity == 'all': for this_n in xrange(self.conv_features * self.n_excitatory_patch): self.lattice_locations[this_n] = [ other_n for other_n in xrange(self.conv_features * self.n_excitatory_patch) \ if is_lattice_connection(self.n_excitatory_patch_sqrt, \ this_n % self.n_excitatory_patch, other_n % self.n_excitatory_patch) ] elif self.connectivity == 'pairs': for this_n in xrange(self.conv_features * self.n_excitatory_patch): self.lattice_locations[this_n] = [] for other_n in xrange(self.conv_features * self.n_excitatory_patch): if this_n // self.n_excitatory_patch % 2 == 0: if is_lattice_connection(self.n_excitatory_patch_sqrt, this_n % self.n_excitatory_patch, \ other_n % self.n_excitatory_patch) and \ other_n // self.n_excitatory_patch == this_n // self.n_excitatory_patch + 1: self.lattice_locations[this_n].append(other_n) elif this_n // self.n_excitatory_patch % 2 == 1: if is_lattice_connection(self.n_excitatory_patch_sqrt, this_n % self.n_excitatory_patch, \ other_n % self.n_excitatory_patch) and \ other_n // self.n_excitatory_patch == this_n // self.n_excitatory_patch - 1: self.lattice_locations[this_n].append(other_n) elif self.connectivity == 'linear': for this_n in xrange(self.conv_features * self.n_excitatory_patch): self.lattice_locations[this_n] = [] for other_n in xrange(conv_features * self.n_excitatory_patch): if this_n // self.n_excitatory_patch != self.conv_features - 1: if is_lattice_connection(self.n_excitatory_patch_sqrt, this_n % self.n_excitatory_patch, \ other_n % self.n_excitatory_patch) and \ other_n // self.n_excitatory_patch == this_n // self.n_excitatory_patch + 1: self.lattice_locations[this_n].append(other_n) elif this_n // self.n_excitatory_patch != 0: if is_lattice_connection(self.n_excitatory_patch_sqrt, this_n % self.n_excitatory_patch, \ other_n % self.n_excitatory_patch) and \ other_n // self.n_excitatory_patch == this_n // self.n_excitatory_patch - 1: self.lattice_locations[this_n].append(other_n) # setting up parameters for weight normalization between patches num_lattice_connections = sum( [len(value) for value in lattice_locations.values()]) self.weight['ee_recurr'] = (num_lattice_connections / self.conv_features) * 0.15 # creating Poission spike train from input image (784 vector, 28x28 image) for name in self.input_population_names: self.input_groups[name + 'e'] = b.PoissonGroup(self.n_input, 0) self.rate_monitors[name + 'e'] = b.PopulationRateMonitor(self.input_groups[name + 'e'], \ bin=(self.single_example_time + self.resting_time) / b.second) # creating connections from input Poisson spike train to convolution patch populations for name in self.input_connection_names: print '\n...creating connections between', name[0], 'and', name[1] # for each of the input connection types (in this case, excitatory -> excitatory) for connection_type in self.input_conn_names: # saved connection name connection_name = name[0] + connection_type[0] + name[ 1] + connection_type[1] # create connections from the windows of the input group to the neuron population self.input_connections[connection_name] = b.Connection(self.input_groups['Xe'], \ self.neuron_groups[name[1] + connection_type[1]], structure='sparse', \ state='g' + connection_type[0], delay=True, max_delay=self.delay[connection_type][1]) for feature in xrange(self.conv_features): for n in xrange(self.n_excitatory_patch): for idx in xrange(self.conv_size**2): self.input_connections[connection_name][self.convolution_locations[n][idx], \ feature * self.n_excitatory_patch + n] = (b.random() + 0.01) * 0.3 # if excitatory -> excitatory STDP is specified, add it here (input to excitatory populations) print '...creating STDP for connection', name # STDP connection name connection_name = name[0] + connection_type[0] + name[ 1] + connection_type[1] # create the STDP object self.stdp_methods[connection_name] = b.STDP(self.input_connections[connection_name], \ eqs=eqs_stdp_ee, pre=eqs_stdp_pre_ee, post=eqs_stdp_post_ee, wmin=0., wmax=self.wmax_ee) print '\n'
def build_network(): global fig_num neuron_groups['e'] = b.NeuronGroup(n_e_total, neuron_eqs_e, threshold=v_thresh_e, refractory=refrac_e, reset=scr_e, compile=True, freeze=True) neuron_groups['i'] = b.NeuronGroup(n_e_total, neuron_eqs_i, threshold=v_thresh_i, refractory=refrac_i, reset=v_reset_i, compile=True, freeze=True) for name in ['A']: print '...Creating neuron group:', name # get a subgroup of size 'n_e' from all exc neuron_groups[name + 'e'] = neuron_groups['e'].subgroup(conv_features * n_e) # get a subgroup of size 'n_i' from the inhibitory layer neuron_groups[name + 'i'] = neuron_groups['i'].subgroup(conv_features * n_e) # start the membrane potentials of these groups 40mV below their resting potentials neuron_groups[name + 'e'].v = v_rest_e - 40. * b.mV neuron_groups[name + 'i'].v = v_rest_i - 40. * b.mV print '...Creating recurrent connections' for name in ['A']: neuron_groups['e'].theta = np.load( os.path.join(best_weights_dir, '_'.join(['theta_A', ending + '_best.npy']))) for conn_type in ['ei', 'ie']: if conn_type == 'ei': # create connection name (composed of population and connection types) conn_name = name + conn_type[0] + name + conn_type[1] # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection(neuron_groups[conn_name[0:2]], \ neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection for feature in xrange(conv_features): for n in xrange(n_e): connections[conn_name][feature * n_e + n, feature * n_e + n] = 10.4 elif conn_type == 'ie' and not remove_inhibition: # create connection name (composed of population and connection types) conn_name = name + conn_type[0] + name + conn_type[1] # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection(neuron_groups[conn_name[0:2]], \ neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # define the actual synaptic connections and strengths for feature in xrange(conv_features): if inhib_scheme in ['far', 'strengthen']: for other_feature in set(range(conv_features)) - set( neighbor_mapping[feature]): if inhib_scheme == 'far': for n in xrange(n_e): connections[conn_name][feature * n_e + n, other_feature * n_e + n] = 17.4 elif inhib_scheme == 'strengthen': if n_e == 1: x, y = feature // np.sqrt( n_e_total), feature % np.sqrt( n_e_total) x_, y_ = other_feature // np.sqrt( n_e_total), other_feature % np.sqrt( n_e_total) else: x, y = feature // np.sqrt( conv_features), feature % np.sqrt( conv_features) x_, y_ = other_feature // np.sqrt( conv_features ), other_feature % np.sqrt(conv_features) for n in xrange(n_e): connections[conn_name][feature * n_e + n, other_feature * n_e + n] = \ min(17.4, inhib_const * np.sqrt(euclidean([x, y], [x_, y_]))) elif inhib_scheme == 'increasing': for other_feature in xrange(conv_features): if n_e == 1: x, y = feature // np.sqrt( n_e_total), feature % np.sqrt(n_e_total) x_, y_ = other_feature // np.sqrt( n_e_total), other_feature % np.sqrt( n_e_total) else: x, y = feature // np.sqrt( conv_features), feature % np.sqrt( conv_features) x_, y_ = other_feature // np.sqrt( conv_features), other_feature % np.sqrt( conv_features) if feature != other_feature: for n in xrange(n_e): connections[conn_name][feature * n_e + n, other_feature * n_e + n] = \ min(17.4, inhib_const * np.sqrt(euclidean([x, y], [x_, y_]))) else: raise Exception( 'Expecting one of "far", "increasing", or "strengthen" for argument "inhib_scheme".' ) # spike rate monitors for excitatory and inhibitory neuron populations rate_monitors[name + 'e'] = b.PopulationRateMonitor( neuron_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second) rate_monitors[name + 'i'] = b.PopulationRateMonitor( neuron_groups[name + 'i'], bin=(single_example_time + resting_time) / b.second) spike_counters[name + 'e'] = b.SpikeCounter(neuron_groups[name + 'e']) # record neuron population spikes if specified if record_spikes: spike_monitors[name + 'e'] = b.SpikeMonitor(neuron_groups[name + 'e']) spike_monitors[name + 'i'] = b.SpikeMonitor(neuron_groups[name + 'i']) if record_spikes and do_plot: if reset_state_vars: time_window = single_example_time * 1000 else: time_window = (single_example_time + resting_time) * 1000 b.figure(fig_num, figsize=(8, 6)) b.ion() b.subplot(211) b.raster_plot(spike_monitors['Ae'], refresh=time_window * b.ms, showlast=time_window * b.ms, title='Excitatory spikes per neuron') b.subplot(212) b.raster_plot(spike_monitors['Ai'], refresh=time_window * b.ms, showlast=time_window * b.ms, title='Inhibitory spikes per neuron') b.tight_layout() fig_num += 1 # creating Poission spike train from input image (784 vector, 28x28 image) for name in ['X']: input_groups[name + 'e'] = b.PoissonGroup(n_input, 0) rate_monitors[name + 'e'] = b.PopulationRateMonitor( input_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second) # creating connections from input Poisson spike train to convolution patch populations for name in ['XA']: print '\n...Creating connections between', name[0], 'and', name[1] # for each of the input connection types (in this case, excitatory -> excitatory) for conn_type in ['ee_input']: # saved connection name conn_name = name[0] + conn_type[0] + name[1] + conn_type[1] # get weight matrix depending on training or test phase weight_matrix = np.load( os.path.join(best_weights_dir, '_'.join([conn_name, ending + '_best.npy']))) # create connections from the windows of the input group to the neuron population input_connections[conn_name] = b.Connection(input_groups['Xe'], neuron_groups[name[1] + \ conn_type[1]], structure='sparse', state='g' + conn_type[0], delay=True, max_delay=delay[conn_type][1]) for feature in xrange(conv_features): for n in xrange(n_e): for idx in xrange(conv_size**2): input_connections[conn_name][convolution_locations[n][idx], feature * n_e + n] = \ weight_matrix[convolution_locations[n][idx], feature * n_e + n] if do_plot: plot_2d_input_weights() fig_num += 1
rate_monitors[name + 'i'] = b.PopulationRateMonitor( neuron_groups[name + 'i'], bin=(single_example_time + resting_time) / b.second) spike_counters[name + 'e'] = b.SpikeCounter(neuron_groups[name + 'e']) if record_spikes: spike_monitors[name + 'e'] = b.SpikeMonitor(neuron_groups[name + 'e']) spike_monitors[name + 'i'] = b.SpikeMonitor(neuron_groups[name + 'i']) if record_spikes: b.figure(fig_num) fig_num += 1 b.ion() b.subplot(211) b.raster_plot(spike_monitors['Ae'], refresh=1000 * b.ms, showlast=1000 * b.ms) b.subplot(212) b.raster_plot(spike_monitors['Ai'], refresh=1000 * b.ms, showlast=1000 * b.ms) #------------------------------------------------------------------------------ # create input population and connections from input populations #------------------------------------------------------------------------------ pop_values = [0, 0, 0] for i, name in enumerate(input_population_names): input_groups[name + 'e'] = b.PoissonGroup(n_input, 0) rate_monitors[name + 'e'] = b.PopulationRateMonitor( input_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second)
def plot_rast_V_I_disc(net, nrn=-2, xlim0=[19375,19625], xlim1 = [25625,26375], xlim2=[38625,36375], disc_only=False): """ For plotting Fig 2 - plots currents, voltage of a neuron in a single figure - plots a ratser of a PS with a discontinious x axis for showing off the dummpy plasticity xlimX : gives the limits of the x axes for the different plots X=0 : limits of pre-pff-boost X=1 : limits of discrete sequence sfter boost X=1 : limits of continuous sequence after boost puts an extra raster of a continuous sequence replay """ from figure_subplots import draw_evoked_rasta2 tres = .1 # time resolution for conductance subpzorder = 2 figure = pyplot.figure(figsize=(18., 12.)) grid_y = 26 if disc_only: grid_y = 18 gs = gridspec.GridSpec(grid_y, 13) gs.update(left=.04, wspace=.15, hspace=.0) ylab_xposit = xlim0[0] - 80 # label size labsize = 20 ################################################################ dx_tick = 50 xticks0 = numpy.arange(xlim0[0], xlim0[1]+1, dx_tick) xticks0_lab = numpy.arange(0, xlim0[1]-xlim0[0]+1, dx_tick) # first tick in second plot in plotting time shift_xtick = dx_tick - (xlim0[1]-xlim0[0]) % dx_tick # last tick first_xtick= ((xlim0[1]-xlim0[0]+dx_tick)//dx_tick)*dx_tick last_xtick = first_xtick + xlim1[1]-xlim1[0] + 1 xticks1 = numpy.arange(xlim1[0] + shift_xtick, xlim1[1]+1, dx_tick) xticks1_lab = numpy.arange(first_xtick, last_xtick, dx_tick) #xticks=numpy.arange(xlim[0], xlim[1]+1, 200) #xticks_lab = numpy.arange(0, xlim[1]-xlim[0]+1, 200) ################################################################ sub_rast0 = pyplot.subplot(gs[12:18, 1:4], zorder = subpzorder ) m = bb.Monitor() m.source = [] frac = .1 m.spikes = calc_spikes.get_spike_times_ps(net, 0, frac) bb.raster_plot(m, color=(0, 0, 0)) #sub_rast0.plot(numpy.array(m.spikes)[:,0],numpy.array(m.spikes)[:,1], '.') # spikes of measured neuron in red o., # now it works only with neurons from the last group nrn_spikes_all = net.mon_spike_e[net.nrn_meas_e[nrn]] nrn_spikes0 = nrn_spikes_all[numpy.logical_and( nrn_spikes_all >= xlim0[0]/1000., nrn_spikes_all <= xlim0[1]/1000.)] nrn_spikes1 = nrn_spikes_all[numpy.logical_and( nrn_spikes_all >= xlim1[0]/1000., nrn_spikes_all <= xlim1[1]/1000.)] raster_sp_x0 = nrn_spikes0*1000. raster_sp_y0 = (net.nrn_meas_e[nrn])*numpy.ones(len(nrn_spikes0))*frac pyplot.plot(raster_sp_x0, raster_sp_y0, 'o', color='red', zorder=3) pyplot.plot(raster_sp_x0, raster_sp_y0, '.', color='red', zorder=3) sub_rast0.set_xlim(xlim0) #sub_rast0.set_xticks([]) #sub_rast0.set_xticklabels([]) sub_rast0.set_xlabel('') # put some lines between groups for i in range(net.n_ass): sub_rast0.plot(numpy.arange(xlim0[0], xlim0[1]), (i+1)*frac*net.s_ass*numpy.ones(xlim0[1]-xlim0[0]), 'gray', zorder=1) yticks=[0, 2500, 5000] yticks=[0, 250, 500] sub_rast0.set_ylabel('', size=20) sub_rast0.set_yticks(yticks) sub_rast0.set_yticklabels(yticks, size=labsize) sub_rast0.xaxis.set_tick_params(width=1, length=5) sub_rast0.yaxis.set_tick_params(width=1, length=5) sub_rast0.set_xlim(xlim0) sub_rast0.set_xticks(xticks0) sub_rast0.set_xticks([]) sub_rast0.set_xticklabels(xticks0_lab, size=20) sub_rast0.set_xticklabels([], size=20) sub_rast0.text(xticks0[0]-130, yticks[-1], 'C', size=28, color='black') sub_rast0.text(ylab_xposit, 375, 'Neuron #', rotation = 'vertical', size=20) pyplot.text(xlim0[0]+125-12, -60, '$\Uparrow$', size=25) sub_rast0.yaxis.tick_right() sub_rast0.spines['right'].set_visible(False) ### sub_rast = pyplot.subplot(gs[12:18, 4:13], zorder = subpzorder) m = bb.Monitor() m.source = [] m.spikes = calc_spikes.get_spike_times_ps(net, 0, frac) bb.raster_plot(m, color=(0, 0, 0)) #pyplot.plot(numpy.array(m.spikes)[:,0],numpy.array(m.spikes)[:,1], '.') raster_sp_x1 = nrn_spikes1*1000. raster_sp_y1 = (net.nrn_meas_e[nrn])*numpy.ones(len(nrn_spikes1))*frac pyplot.plot(raster_sp_x1, raster_sp_y1, 'o', color='red') pyplot.plot(raster_sp_x1, raster_sp_y1, '.', color='red') # put some lines between groups for i in range(net.n_ass): sub_rast.plot(numpy.arange(xlim1[0], xlim1[1]), (i+1)*frac*net.s_ass*numpy.ones(xlim1[1]-xlim1[0]), 'gray') sub_rast.set_xlim(xlim1) sub_rast.set_xticks(xticks1) sub_rast.set_xticks([]) sub_rast.set_xlabel('') sub_rast.spines['left'].set_visible(False) sub_rast.set_ylabel('', size=20) sub_rast.set_yticks([]) sub_rast.xaxis.set_tick_params(width=1, length=5) sub_rast.yaxis.set_tick_params(width=1, length=5) sub_rast.set_xticklabels([], size=20) pyplot.text(xlim1[0]+375-12,-60, '$\Uparrow$', size=25) #sub_rast.set_xticklabels(xticks1_lab, size=20) #pyplot.xlabel('Time [ms]', size=20) # size of the diagonal lines in axes coordinates dx0 = .012 dy0 = .04 # the second subplot has different size than the prev dx1 = dx0*3./8 dy1 = dy0*1. kwargs = dict(transform=sub_rast0.transAxes, color='k', clip_on=False) sub_rast0.yaxis.tick_left() # top-right diagonal sub_rast0.plot((1-dx0, 1+dx0), (1-dy0, 1+dy0), **kwargs) # bottom-right diagonal sub_rast0.plot((1-dx0, 1+dx0), (-dy0, +dy0), **kwargs) kwargs.update(transform=sub_rast.transAxes) # switch to the bottom axes # top-left diagonal sub_rast.plot((-dx1, +dx1), (1-dy1, 1+dy1), **kwargs) # bottom-left diagonal sub_rast.plot((-dx1, dx1), (-dy1, +dy1), **kwargs) ################################################################ sub_curr0 = pyplot.subplot(gs[0:5, 1:4], zorder = subpzorder) sub_curr0.patch.set_facecolor('None') #lim for the vectors(with tres in mind) cx0lim = [xlim0[0]/tres, xlim0[1]/tres] cx1lim = [xlim1[0]/tres, xlim1[1]/tres] yticks=[-200, 0, 200, 400] curr_e= net.mon_ecurr_e[net.nrn_meas_e[nrn]]/pA+200 curr_i= net.mon_icurr_e[net.nrn_meas_e[nrn]]/pA volt_e= net.mon_volt_e[net.nrn_meas_e[nrn]]/mV # measured voltage here curr_leak = 10.*nS*(-60.-volt_e)*mV/pA curr_maxe = max((curr_e[cx0lim[0]:cx0lim[1]]).max(), (curr_e[cx1lim[0]:cx1lim[1]]).max()) curr_maxi = max((curr_i[cx0lim[0]:cx0lim[1]]).max(), (curr_i[cx1lim[0]:cx1lim[1]]).max()) curr_mine = min((curr_e[cx0lim[0]:cx0lim[1]]).min(), (curr_e[cx1lim[0]:cx1lim[1]]).min()) curr_mini = min((curr_i[cx0lim[0]:cx0lim[1]]).min(), (curr_i[cx1lim[0]:cx1lim[1]]).min()) sub_curr0.plot(net.mon_ecurr_e.times/ms, curr_e, 'r', zorder=3) sub_curr0.plot(net.mon_ecurr_e.times/ms, curr_i, 'b', zorder=1) sub_curr0.plot(net.mon_ecurr_e.times/ms, curr_e+curr_i+curr_leak, 'black', zorder=2) ylim=[1.02*min(curr_mine, curr_mini), 1.1*max(curr_maxe, curr_maxi)] remove_spines(sub_curr0, xlim=xlim0, ylim=ylim, xticks=[], yticks=yticks, ylabel='I [pA]', legend= []) sub_curr0.set_ylabel('', size=20) sub_curr0.text(ylab_xposit, 330, 'Current [pA]', rotation = 'vertical', size=20) sub_curr0.text(xticks0[0]-130, 500., 'A', size=28, color='black') sub_curr0.set_yticks(yticks) sub_curr0.set_yticklabels(yticks, size=20) sub_curr0.yaxis.set_tick_params(width=1, length=5) sub_curr = pyplot.subplot(gs[0:5, 4:13], zorder = subpzorder) sub_curr.patch.set_facecolor('None') pyplot.plot(net.mon_ecurr_e.times/ms, curr_e, 'r') pyplot.plot(net.mon_ecurr_e.times/ms, curr_i, 'b') pyplot.plot(net.mon_ecurr_e.times/ms, curr_e+curr_i+curr_leak, 'black') ylim=[1.2*min(curr_mine, curr_mini), 1.2*max(curr_maxe, curr_maxi)] remove_spines(sub_curr, xlim=xlim1, ylim=ylim, xticks=[], yticks=[], ylabel='', legend= []) sub_curr.set_ylabel('', size=20) sub_curr.yaxis.set_tick_params(width=1, length=5) sub_curr.text(xlim1[1]-87, -320., 'Inhibition', size=20, color='b', zorder=3) sub_curr.text(xlim1[1]-45, 80., 'Total', size=20, zorder=3) sub_curr.text(xlim1[1]-92, 300., 'Excitation', size=20, color='r', zorder=3) ''' ''' sub_curr0.spines['right'].set_visible(False) sub_curr.spines['left'].set_visible(False) sub_curr0.yaxis.tick_left() ''' kwargs.update(transform=sub_curr0.transAxes) # switch to the bottom axes sub_rast0.yaxis.tick_left() # top-right diagonal sub_rast0.plot((1-dx0, 1+dx0), (1-dy0, 1+dy0), **kwargs) # bottom-right diagonal sub_rast0.plot((1-dx0, 1+dx0), (-dy0, +dy0), **kwargs) kwargs.update(transform=sub_curr.transAxes) # switch to the bottom axes # top-left diagonal sub_rast.plot((-dx1, +dx1), (1-dy1, 1+dy1), **kwargs) # bottom-left diagonal sub_rast.plot((-dx1, dx1), (-dy1, +dy1), **kwargs) ''' ################################################################ #raster_sp_x = nrn_spikes*1000 #raster_sp_y = (491+nrn)*numpy.ones(len(nrn_spikes)) #sub_volt = pyplot.subplot(gs[16:20,0:12]) sub_volt0 = pyplot.subplot(gs[6:11,1:4], zorder = subpzorder) sub_volt0.patch.set_facecolor('None') ylim=[-61,-39] yticks=[-60,-50,-40] for i,v in enumerate(volt_e): if v<-59 and volt_e[i-1]>-55: volt_e[i-1] = -40 volt_sp_x0 = nrn_spikes0*1000 volt_sp_y0 = -40*numpy.ones(len(volt_sp_x0)) pyplot.plot(net.mon_volt_e.times/ms, volt_e,'black') pyplot.plot(volt_sp_x0, volt_sp_y0, 'o', color='red') remove_spines(sub_volt0, xlim=xlim0, ylim=ylim, xticks=[], yticks=yticks, ylabel='V [mV]', legend= []) sub_volt0.set_ylabel('', size=20) sub_volt0.text(ylab_xposit, -41, 'Voltage [mV]', rotation='vertical', size=20) sub_volt0.set_yticks(yticks) sub_volt0.set_yticklabels(yticks, size=20) sub_volt0.yaxis.set_tick_params(width=1, length=5) sub_volt0.plot(numpy.arange(xlim0[0],xlim0[1]), -50.*numpy.ones(xlim0[1]-xlim0[0]), '-.', color='gray') sub_volt0.text(xticks0[0]-130, -40., 'B', size=28, color='black') sub_volt = pyplot.subplot(gs[6:11,4:13], zorder = subpzorder) sub_volt.patch.set_facecolor('None') volt_sp_x1 = nrn_spikes1*1000 volt_sp_y1 = -40*numpy.ones(len(volt_sp_x1)) pyplot.plot(net.mon_volt_e.times/ms, volt_e,'black') pyplot.plot(volt_sp_x1, volt_sp_y1, 'o', color='red') remove_spines(sub_volt, xlim=xlim1, ylim=ylim, xticks=[], yticks=yticks, ylabel='', legend= []) sub_volt.set_yticks([]) sub_volt.plot(numpy.arange(xlim1[0],xlim1[1]), -50.*numpy.ones(xlim1[1]-xlim1[0]), '-.', color='gray') sub_volt0.spines['right'].set_visible(False) sub_volt.spines['left'].set_visible(False) # draw vertical lines between spikes in raster and voltage trace linii_nekvi=[] curr_sp_y = 400. for i in range(len(volt_sp_x0)): linii_nekvi.append(get_straightline(figure, sub_rast0, sub_curr0, raster_sp_x0[i], raster_sp_y0[i], volt_sp_x0[i], curr_sp_y)) for i in range(len(volt_sp_x1)): linii_nekvi.append(get_straightline(figure, sub_rast, sub_curr, raster_sp_x1[i], raster_sp_y1[i], volt_sp_x1[i], curr_sp_y)) if disc_only: bar_x = xlim1[-1] - 100 bar_y = -60 x_len = 100 sub_volt.text(bar_x+.15*x_len, bar_y+2, str(x_len)+' ms', size=20) transFigure = figure.transFigure.inverted() coord1 = transFigure.transform( sub_volt.transData.transform([bar_x+0, bar_y])) coord2 = transFigure.transform( sub_volt.transData.transform([bar_x+0+x_len, bar_y])) line_bar = matplotlib.lines.Line2D((coord1[0], coord2[0]), (coord1[1], coord2[1]), transform=figure.transFigure, color='black', linewidth=3.) linii_nekvi.append(line_bar) figure.lines = linii_nekvi from random import randint loc='tfigs/rcv8/' prefix = 'rccv_' fname = 'prf' + str(net.pr_ee) + str(net.pf_ee_new) + '_' + \ str(-nrn) + '_int' + str(xlim1[0]) + '_' + str(randint(0, 99999)) figure.savefig(loc+prefix+fname+'rand_.eps', format='eps') figure.savefig(loc+prefix+fname+'rand_.png', format='png') figure.savefig(loc+prefix+fname+'rand_.pdf', format='pdf') pyplot.show() return 0 ################################################################ # raster for continious ASS at the bottom of the figure fname = 'contASS_pr0.1pfboost0.04frac0.1.npz' #fname = 'contin_modified.npz' xlim0 = [19375, 19625] xlim2 = [28625, 29375] #xticks=numpy.arange(x0, x1+1, 200) #xticks_lab = numpy.arange(0, x1-x0+1, 200) xticks=[] # first tick in second plot in plotting time shift_xtick = dx_tick - (xlim0[1]-xlim0[0]) % dx_tick # last tick first_xtick= ((xlim0[1]-xlim0[0]+dx_tick)//dx_tick)*dx_tick last_xtick = first_xtick + xlim2[1]-xlim2[0] + 1 xticks2 = numpy.arange(xlim2[0] + shift_xtick, xlim2[1]+1, dx_tick) sub_rast20 = pyplot.subplot(gs[20:26, 1:4], zorder = subpzorder) draw_evoked_rasta2(fname, '', x0=xlim0[0], x1=xlim0[1]) yticks=[0, 100, 200, 300, 400, 500] yticks=[0, 250, 500] #yticks=[0, 2500, 5000] sub_rast20.set_xticks(xticks0) sub_rast20.set_xticks([]) sub_rast20.set_xticklabels([]) sub_rast20.set_yticks(yticks) sub_rast20.set_yticklabels(yticks, size=20) sub_rast20.text(xlim0[0]-80, 375, 'Neuron #', rotation = 'vertical', size=20) sub_rast20.text(xlim0[0]-130, yticks[-1], 'D', size=28, color='black') sub_rast20.spines['right'].set_visible(False) sub_rast20.xaxis.set_tick_params(width=1, length=5) sub_rast20.yaxis.set_tick_params(width=1, length=5) pyplot.text(xlim0[0]+125-12,-60, '$\Uparrow$', size=25) kwargs = dict(transform=sub_rast20.transAxes, color='k', clip_on=False) sub_rast20.yaxis.tick_left() # top-right diagonal sub_rast20.plot((1-dx0, 1+dx0), (1-dy0, 1+dy0), **kwargs) # bottom-right diagonal sub_rast20.plot((1-dx0, 1+dx0), (-dy0, +dy0), **kwargs) ##### sub_rast2 = pyplot.subplot(gs[20:26, 4:13], zorder = subpzorder) draw_evoked_rasta2(fname, '', x0=xlim2[0], x1=xlim2[1]) sub_rast2.xaxis.set_tick_params(width=1, length=5) sub_rast2.yaxis.set_tick_params(width=1, length=5) #sub_rast.set_ylabel('Neurons',size=18) sub_rast2.set_xticks(xticks2) sub_rast2.set_xticks([]) sub_rast2.set_xticklabels([]) #pyplot.xlabel('Time [ms]', size=20) sub_rast2.spines['left'].set_visible(False) kwargs.update(transform=sub_rast2.transAxes) # switch to the bottom axes # top-left diagonal sub_rast2.plot((-dx1, +dx1), (1-dy1, 1+dy1), **kwargs) # bottom-left diagonal sub_rast2.plot((-dx1, dx1), (-dy1, +dy1), **kwargs) pyplot.text(xlim2[0]+375-12,-60, '$\Uparrow$', size=25) ''' bar_x = xlim2[-1] - 100 bar_y = -100 x_len = 100 pyplot.text(bar_x+.15*x_len, bar_y+20, str(x_len)+' ms', size=20) transFigure = figure.transFigure.inverted() coord1 = transFigure.transform( sub_rast2.transData.transform([bar_x+0, bar_y])) coord2 = transFigure.transform( sub_rast2.transData.transform([bar_x+0+x_len, bar_y])) ''' bar_x = xlim1[-1] - 100 bar_y = -60 x_len = 100 sub_volt.text(bar_x+.15*x_len, bar_y+2, str(x_len)+' ms', size=20) transFigure = figure.transFigure.inverted() coord1 = transFigure.transform( sub_volt.transData.transform([bar_x+0, bar_y])) coord2 = transFigure.transform( sub_volt.transData.transform([bar_x+0+x_len, bar_y])) line_bar = matplotlib.lines.Line2D((coord1[0], coord2[0]), (coord1[1], coord2[1]), transform=figure.transFigure, color='black', linewidth=3.) linii_nekvi.append(line_bar) figure.lines = linii_nekvi #1/0 #pyplot.show() #return 0 from random import randint loc='tfigs/rcv7/' prefix = 'rccv_' fname = 'prf' + str(net.pr_ee) + str(net.pf_ee) + '_' + \ str(-nrn) + '_int' + str(xlim1[0]) + '_' + str(randint(0, 99999)) figure.savefig(loc+prefix+fname+'.eps', format='eps') figure.savefig(loc+prefix+fname+'.png', format='png') figure.savefig(loc+prefix+fname+'.pdf', format='pdf')
def test_neglect(net_params, input_level, delay_duration, output_base, record_lfp=True, record_voxel=True, record_neuron_state=True, record_spikes=True, record_pop_firing_rate=True, record_neuron_firing_rate=False, record_inputs=False, plot_output=False): instructed_mem_output=None if not output_base is None: instructed_mem_output='%s.instructed.memory.h5' % output_base instructed_mem_monitor=run_neglect([input_level,0], delay_duration, net_params=net_params, output_file=instructed_mem_output, 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_rate=record_neuron_firing_rate, record_inputs=record_inputs, mem_trial=True) instructed_delay_output=None if not output_base is None: instructed_delay_output='%s.instructed.delay.h5' % output_base instructed_delay_monitor=run_neglect([input_level,0], delay_duration, net_params=net_params, output_file=instructed_delay_output, 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_rate=record_neuron_firing_rate, record_inputs=record_inputs, mem_trial=True) free_choice_output=None if not output_base is None: free_choice_output='%s.free_choice.h5' % output_base free_choice_monitor=run_neglect([input_level,input_level], delay_duration, net_params=net_params, output_file=free_choice_output, 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_rate=record_neuron_firing_rate, record_inputs=record_inputs, mem_trial=True) if plot_output: if record_pop_firing_rate: figure() ax=subplot(221) ax.plot(instructed_monitor.population_rate_monitors['left_ec'].times/ms, instructed_monitor.population_rate_monitors['left_ec'].smooth_rate(width=5*ms)/hertz, label='left LIP EC') ax.plot(instructed_monitor.population_rate_monitors['left_ei'].times/ms, instructed_monitor.population_rate_monitors['left_ei'].smooth_rate(width=5*ms)/hertz, label='left LIP EI') ax.plot(instructed_monitor.population_rate_monitors['left_ic'].times/ms, instructed_monitor.population_rate_monitors['left_ic'].smooth_rate(width=5*ms)/hertz, label='left LIP IC') ax.plot(instructed_monitor.population_rate_monitors['left_ii'].times/ms, instructed_monitor.population_rate_monitors['left_ii'].smooth_rate(width=5*ms)/hertz, label='left LIP II') legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') title('Instructed') ax=subplot(222) ax.plot(instructed_monitor.population_rate_monitors['right_ec'].times/ms, instructed_monitor.population_rate_monitors['right_ec'].smooth_rate(width=5*ms)/hertz, label='right LIP EC') ax.plot(instructed_monitor.population_rate_monitors['right_ei'].times/ms, instructed_monitor.population_rate_monitors['right_ei'].smooth_rate(width=5*ms)/hertz, label='right LIP EI') ax.plot(instructed_monitor.population_rate_monitors['right_ic'].times/ms, instructed_monitor.population_rate_monitors['right_ic'].smooth_rate(width=5*ms)/hertz, label='right LIP IC') ax.plot(instructed_monitor.population_rate_monitors['right_ii'].times/ms, instructed_monitor.population_rate_monitors['right_ii'].smooth_rate(width=5*ms)/hertz, label='right LIP II') legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') title('Instructed') ax=subplot(223) ax.plot(free_choice_monitor.population_rate_monitors['left_ec'].times/ms, free_choice_monitor.population_rate_monitors['left_ec'].smooth_rate(width=5*ms)/hertz, label='left LIP EC') ax.plot(free_choice_monitor.population_rate_monitors['left_ei'].times/ms, free_choice_monitor.population_rate_monitors['left_ei'].smooth_rate(width=5*ms)/hertz, label='left LIP EI') ax.plot(free_choice_monitor.population_rate_monitors['left_ic'].times/ms, free_choice_monitor.population_rate_monitors['left_ic'].smooth_rate(width=5*ms)/hertz, label='left LIP IC') ax.plot(free_choice_monitor.population_rate_monitors['left_ii'].times/ms, free_choice_monitor.population_rate_monitors['left_ii'].smooth_rate(width=5*ms)/hertz, label='left LIP II') legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') title('Free choice') ax=subplot(224) ax.plot(free_choice_monitor.population_rate_monitors['right_ec'].times/ms, free_choice_monitor.population_rate_monitors['right_ec'].smooth_rate(width=5*ms)/hertz, label='right LIP EC') ax.plot(free_choice_monitor.population_rate_monitors['right_ei'].times/ms, free_choice_monitor.population_rate_monitors['right_ei'].smooth_rate(width=5*ms)/hertz, label='right LIP EI') ax.plot(free_choice_monitor.population_rate_monitors['right_ic'].times/ms, free_choice_monitor.population_rate_monitors['right_ic'].smooth_rate(width=5*ms)/hertz, label='right LIP IC') ax.plot(free_choice_monitor.population_rate_monitors['right_ii'].times/ms, free_choice_monitor.population_rate_monitors['right_ii'].smooth_rate(width=5*ms)/hertz, label='right LIP II') legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') title('Free Choice') if record_voxel: figure() ax=subplot(111) ax.plot(instructed_monitor.left_voxel_monitor['y'].times / ms, instructed_monitor.left_voxel_monitor['y'][0], label='instructed left LIP') ax.plot(instructed_monitor.right_voxel_monitor['G_total'].times / ms, instructed_monitor.right_voxel_monitor['y'][0], label='instructed right LIP') ax.plot(free_choice_monitor.left_voxel_monitor['G_total'].times / ms, free_choice_monitor.left_voxel_monitor['y'][0], label='free choice left LIP') ax.plot(free_choice_monitor.right_voxel_monitor['G_total'].times / ms, free_choice_monitor.right_voxel_monitor['y'][0], label='free choice right LIP') legend() xlabel('Time (ms)') ylabel('BOLD') # Spike raster plots if record_spikes: figure() title('Free Choice') subplot(811) raster_plot(*free_choice_monitor.spike_monitors['left_ec'],newfigure=False) ylabel('Left EC') subplot(812) raster_plot(*free_choice_monitor.spike_monitors['left_ei'],newfigure=False) ylabel('Left EI') subplot(813) raster_plot(*free_choice_monitor.spike_monitors['left_ic'],newfigure=False) ylabel('Left IC') subplot(814) raster_plot(*free_choice_monitor.spike_monitors['left_ii'],newfigure=False) ylabel('Left II') subplot(815) raster_plot(*free_choice_monitor.spike_monitors['right_ec'],newfigure=False) ylabel('Right EC') subplot(816) raster_plot(*free_choice_monitor.spike_monitors['right_ei'],newfigure=False) ylabel('Right EI') subplot(817) raster_plot(*free_choice_monitor.spike_monitors['right_ic'],newfigure=False) ylabel('Right IC') subplot(818) raster_plot(*free_choice_monitor.spike_monitors['right_ii'],newfigure=False) ylabel('Right II') figure() title('Instructed') subplot(811) raster_plot(*instructed_monitor.spike_monitors['left_ec'],newfigure=False) ylabel('Left EC') subplot(812) raster_plot(*instructed_monitor.spike_monitors['left_ei'],newfigure=False) ylabel('Left EI') subplot(813) raster_plot(*instructed_monitor.spike_monitors['left_ic'],newfigure=False) ylabel('Left IC') subplot(814) raster_plot(*instructed_monitor.spike_monitors['left_ii'],newfigure=False) ylabel('Left II') subplot(815) raster_plot(*instructed_monitor.spike_monitors['right_ec'],newfigure=False) ylabel('Right EC') subplot(816) raster_plot(*instructed_monitor.spike_monitors['right_ei'],newfigure=False) ylabel('Right EI') subplot(817) raster_plot(*instructed_monitor.spike_monitors['right_ic'],newfigure=False) ylabel('Right IC') subplot(818) raster_plot(*instructed_monitor.spike_monitors['right_ii'],newfigure=False) ylabel('Right II')
print 'create monitors for', name rate_monitors[name+'e'] = b.PopulationRateMonitor(neuron_groups[name+'e'], bin = (single_example_time+resting_time)/b.second) rate_monitors[name+'i'] = b.PopulationRateMonitor(neuron_groups[name+'i'], bin = (single_example_time+resting_time)/b.second) spike_counters[name+'e'] = b.SpikeCounter(neuron_groups[name+'e']) if record_spikes: spike_monitors[name+'e'] = b.SpikeMonitor(neuron_groups[name+'e']) spike_monitors[name+'i'] = b.SpikeMonitor(neuron_groups[name+'i']) if record_spikes: b.figure(fig_num) fig_num += 1 b.ion() b.subplot(211) b.raster_plot(spike_monitors['Ae'], refresh=1000*b.ms, showlast=1000*b.ms) b.subplot(212) b.raster_plot(spike_monitors['Ai'], refresh=1000*b.ms, showlast=1000*b.ms) #------------------------------------------------------------------------------ # create input population and connections from input populations #------------------------------------------------------------------------------ pop_values = [0,0,0] for i,name in enumerate(input_population_names): input_groups[name+'e'] = b.PoissonGroup(n_input, 0) rate_monitors[name+'e'] = b.PopulationRateMonitor(input_groups[name+'e'], bin = (single_example_time+resting_time)/b.second) for name in input_connection_names: print 'create connections between', name[0], 'and', name[1] for connType in input_conn_names:
def run(self): #------------------------------------------------------------------------------ # run the simulation and set inputs #------------------------------------------------------------------------------ previousSpikeCount = np.zeros((self.nE, self.numAllPops)) currentSpikeCount = np.zeros((self.nE, self.numAllPops)) if self.saveSpikeCountsPerExample: self.spikeCounts=np.zeros((self.numExamples, self.nE, self.numAllPops)) if self.realTimePlotting and self.recordSpikes: b.ion() fig = b.figure(1) b.raster_plot(self.spikeMonitors['Ae']) if self.ending=='': initJ = 0 else: initJ = int(self.ending) for j in xrange(int(self.numExamples)): if self.restingTime or j==0: for i,name in enumerate(self.inputPopulationNames): rates = np.ones(self.nE) * 0 self.inputGroups[name+'e'].rate = rates self.net.run(self.restingTime) if j%self.normalization_interval == 0: self.normalizeWeights() print 'set new rates of the inputs' self.setNewInput(self,j) print 'run number:', j+1, 'of', int(self.numExamples) self.net.run(self.singleExampleTime) for i,name in enumerate(self.populationNames): name += 'e' currentSpikeCount[:,i] = np.asarray(self.spikeCounters[name].count[:]) - previousSpikeCount[:,i] previousSpikeCount[:,i] = np.copy(self.spikeCounters[name].count[:]) self.resultMonitor[j,i] = self.computePopVector(currentSpikeCount[:,i]) print name, 'pop. activity: ', self.resultMonitor[j,i], ', spikecount:', sum(currentSpikeCount[:,i]) if self.saveSpikeCountsPerExample: self.spikeCounts[j,:,i] = currentSpikeCount[:,i] for i,name in enumerate(self.inputPopulationNames): print name, 'pop. activity: ', (self.popValues[j,i]) name += 'e' currentSpikeCount[:,i+self.numPops] = np.asarray(self.spikeCounters[name].count[:]) - previousSpikeCount[:,i+self.numPops] previousSpikeCount[:,i+self.numPops] = np.copy(self.spikeCounters[name].count[:]) self.resultMonitor[j,i+self.numPops] = self.computePopVector(currentSpikeCount[:,i+self.numPops]) if self.saveSpikeCountsPerExample: self.spikeCounts[j,:,i+self.numPops] = currentSpikeCount[:,i+self.numPops] if not self.testMode: if self.numExamples <= 1000: if (j+1)%100==0 and not j==0: self.saveConnections(str(j+initJ+1)) else: if (j+1)%5000==0 and not j==0: self.saveConnections(str(j+initJ+1)) if self.realTimePlotting and self.recordSpikes: b.raster_plot(self.spikeMonitors['Ae'], showlast=1000*b.ms) fig.canvas.draw() #------------------------------------------------------------------------------ # save results #------------------------------------------------------------------------------ print 'save results' if self.testMode: np.savetxt(self.dataPath + 'activity/resultPopVecs' + str(self.numExamples) + '.txt', self.resultMonitor) np.savetxt(self.dataPath + 'activity/popVecs' + str(self.numExamples) + '.txt', self.popValues) for name in self.spikeCounters: np.savetxt(self.dataPath + 'activity/spikeCount' + name + '.txt', self.spikeCounters[name].count[:]/(self.singleExampleTime*int(self.numExamples))) if self.saveSpikeCountsPerExample: np.save(self.dataPath + 'activity/spikeCountPerExample', self.spikeCounts) else: self.saveConnections(str(self.numExamples+initJ)) self.normalizeWeights() self.saveConnections()
def plot(self, trial_duration): # Spike raster plots if self.spike_monitors is not None: figure() subplot(811) raster_plot(self.spike_monitors['left_ec'],newfigure=False) xlim(0,trial_duration/ms) ylim(0,self.brain_network.left_lip.e_contra_size) ylabel('left EC') subplot(812) raster_plot(self.spike_monitors['left_ei'],newfigure=False) xlim(0,trial_duration/ms) ylim(0,self.brain_network.left_lip.e_ipsi_size) ylabel('left EI') subplot(813) raster_plot(self.spike_monitors['left_ic'],newfigure=False) xlim(0,trial_duration/ms) ylim(0,self.brain_network.left_lip.i_contra_size) ylabel('left IC') subplot(814) raster_plot(self.spike_monitors['left_ii'],newfigure=False) xlim(0,trial_duration/ms) ylim(0,self.brain_network.left_lip.i_ipsi_size) ylabel('left II') subplot(815) raster_plot(self.spike_monitors['right_ec'],newfigure=False) xlim(0,trial_duration/ms) ylim(0,self.brain_network.right_lip.e_contra_size) ylabel('right EC') subplot(816) raster_plot(self.spike_monitors['right_ei'],newfigure=False) xlim(0,trial_duration/ms) ylim(0,self.brain_network.right_lip.e_ipsi_size) ylabel('right EI') subplot(817) raster_plot(self.spike_monitors['right_ic'],newfigure=False) xlim(0,trial_duration/ms) ylim(0,self.brain_network.right_lip.i_contra_size) ylabel('right IC') subplot(818) raster_plot(self.spike_monitors['right_ii'],newfigure=False) xlim(0,trial_duration/ms) ylim(0,self.brain_network.right_lip.i_ipsi_size) ylabel('right II') # Network firing rate plots if self.population_rate_monitors is not None: smooth_width=10*ms left_ec_vis_rate=self.population_rate_monitors['left_ec_vis'].smooth_rate(width=smooth_width)/hertz left_ec_mem_rate=self.population_rate_monitors['left_ec_mem'].smooth_rate(width=smooth_width)/hertz left_ec_rate=self.population_rate_monitors['left_ec'].smooth_rate(width=smooth_width)/hertz left_ei_vis_rate=self.population_rate_monitors['left_ei_vis'].smooth_rate(width=smooth_width)/hertz left_ei_mem_rate=self.population_rate_monitors['left_ei_mem'].smooth_rate(width=smooth_width)/hertz left_ei_rate=self.population_rate_monitors['left_ei'].smooth_rate(width=smooth_width)/hertz left_ic_rate=self.population_rate_monitors['left_ic'].smooth_rate(width=smooth_width)/hertz left_ii_rate=self.population_rate_monitors['left_ii'].smooth_rate(width=smooth_width)/hertz right_ec_vis_rate=self.population_rate_monitors['right_ec_vis'].smooth_rate(width=smooth_width)/hertz right_ec_mem_rate=self.population_rate_monitors['right_ec_mem'].smooth_rate(width=smooth_width)/hertz right_ec_rate=self.population_rate_monitors['right_ec'].smooth_rate(width=smooth_width)/hertz right_ei_vis_rate=self.population_rate_monitors['right_ei_vis'].smooth_rate(width=smooth_width)/hertz right_ei_mem_rate=self.population_rate_monitors['right_ei_mem'].smooth_rate(width=smooth_width)/hertz right_ei_rate=self.population_rate_monitors['right_ei'].smooth_rate(width=smooth_width)/hertz right_ic_rate=self.population_rate_monitors['right_ic'].smooth_rate(width=smooth_width)/hertz right_ii_rate=self.population_rate_monitors['right_ii'].smooth_rate(width=smooth_width)/hertz max_rate=np.max([np.max(left_ec_vis_rate), np.max(left_ec_mem_rate), np.max(left_ec_rate), np.max(left_ei_vis_rate), np.max(left_ei_mem_rate), np.max(left_ic_rate), np.max(left_ii_rate), np.max(right_ec_vis_rate), np.max(right_ec_mem_rate), np.max(right_ec_rate), np.max(right_ei_vis_rate), np.max(right_ei_mem_rate), np.max(right_ei_rate), np.max(right_ic_rate), np.max(right_ii_rate)]) times_ms=self.population_rate_monitors['left_ec_vis'].times/ms figure() ax=subplot(211) ax.plot(times_ms, left_ec_vis_rate, label='left LIP EC vis') ax.plot(times_ms, left_ec_mem_rate, label='left LIP EC mem') #ax.plot(times_ms, left_ec_rate, label='left LIP EC') ax.plot(times_ms, left_ei_vis_rate, label='left LIP EI vis') ax.plot(times_ms, left_ei_mem_rate, label='left LIP EI mem') #ax.plot(times_ms, left_ei_rate, label='left LIP EI') ax.plot(times_ms, left_ic_rate, label='left LIP IC') ax.plot(times_ms, left_ii_rate, label='left LIP II') ylim(0,max_rate) legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') ax=subplot(212) ax.plot(times_ms, right_ec_vis_rate, label='right LIP EC vis') ax.plot(times_ms, right_ec_mem_rate, label='right LIP EC mem') #ax.plot(times_ms, right_ec_rate, label='right LIP EC') ax.plot(times_ms, right_ei_vis_rate, label='right LIP EI vis') ax.plot(times_ms, right_ei_mem_rate, label='right LIP EI mem') #ax.plot(times_ms, right_ei_rate, label='right LIP EI') ax.plot(times_ms, right_ic_rate, label='right LIP IC') ax.plot(times_ms, right_ii_rate, label='right LIP II') ylim(0,max_rate) legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') figure() ax=subplot(211) ax.plot(times_ms, left_ec_rate, label='left LIP EC') ax.plot(times_ms, left_ei_rate, label='left LIP EI') ylim(0,max_rate) legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') ax=subplot(212) ax.plot(times_ms, right_ec_rate, label='right LIP EC') ax.plot(times_ms, right_ei_rate, label='right LIP EI') ylim(0,max_rate) legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') # Input firing rate plots if self.left_background_rate_monitor is not None and self.right_background_rate_monitor is not None and\ self.left_visual_cortex_monitor is not None and self.right_visual_cortex_monitor is not None and \ self.go_input_monitor is not None: figure() max_rate=np.max([np.max(self.left_background_rate_monitor.smooth_rate(width=5*ms)/hertz), np.max(self.right_background_rate_monitor.smooth_rate(width=5*ms)/hertz), np.max(self.left_visual_cortex_monitor.smooth_rate(width=5*ms)/hertz), np.max(self.right_visual_cortex_monitor.smooth_rate(width=5*ms)/hertz), np.max(self.go_input_monitor.smooth_rate(width=5*ms)/hertz)]) ax=subplot(111) ax.plot(self.left_background_rate_monitor.times/ms, self.left_background_rate_monitor.smooth_rate(width=5*ms)/hertz, label='left background') ax.plot(self.right_background_rate_monitor.times/ms, self.right_background_rate_monitor.smooth_rate(width=5*ms)/hertz, label='right background') ax.plot(self.left_visual_cortex_monitor.times/ms, self.left_visual_cortex_monitor.smooth_rate(width=5*ms)/hertz, label='left VC') ax.plot(self.right_visual_cortex_monitor.times/ms, self.right_visual_cortex_monitor.smooth_rate(width=5*ms)/hertz, label='right VC') ax.plot(self.go_input_monitor.times/ms, self.go_input_monitor.smooth_rate(width=5*ms)/hertz, label='Go') legend() ylim(0,max_rate) # Network state plots if self.left_network_monitor is not None and self.right_network_monitor is not None: max_conductances=[] for idx in self.left_record_idx: max_conductances.append(np.max(self.left_network_monitor['g_ampa_r'][idx]/nS)) max_conductances.append(np.max(self.left_network_monitor['g_ampa_x'][idx]/nS)) max_conductances.append(np.max(self.left_network_monitor['g_ampa_b'][idx]/nS)) max_conductances.append(np.max(self.left_network_monitor['g_ampa_g'][idx]/nS)) max_conductances.append(np.max(self.left_network_monitor['g_nmda'][idx]/nS)) max_conductances.append(np.max(self.left_network_monitor['g_gaba_a'][idx]/nS)) max_conductances.append(np.max(self.left_network_monitor['g_gaba_b'][idx]/nS)) for idx in self.right_record_idx: max_conductances.append(np.max(self.right_network_monitor['g_ampa_r'][idx]/nS)) max_conductances.append(np.max(self.right_network_monitor['g_ampa_x'][idx]/nS)) max_conductances.append(np.max(self.right_network_monitor['g_ampa_b'][idx]/nS)) max_conductances.append(np.max(self.right_network_monitor['g_ampa_g'][idx]/nS)) max_conductances.append(np.max(self.right_network_monitor['g_nmda'][idx]/nS)) max_conductances.append(np.max(self.right_network_monitor['g_gaba_a'][idx]/nS)) max_conductances.append(np.max(self.right_network_monitor['g_gaba_b'][idx]/nS)) max_conductance=np.max(max_conductances) figure() labels=['e_contra_vis','e_contra_mem','e_ipsi_vis','e_ipsi_mem','i_contra','i_ipsi'] for i,idx in enumerate(self.left_record_idx): ax=subplot(len(self.left_record_idx),1,i+1) ax.plot(self.left_network_monitor['g_ampa_r'].times/ms, self.left_network_monitor['g_ampa_r'][idx]/nS, label='AMPA recurrent') ax.plot(self.left_network_monitor['g_ampa_x'].times/ms, self.left_network_monitor['g_ampa_x'][idx]/nS, label='AMPA task') ax.plot(self.left_network_monitor['g_ampa_b'].times/ms, self.left_network_monitor['g_ampa_b'][idx]/nS, label='AMPA backgrnd') ax.plot(self.left_network_monitor['g_ampa_g'].times/ms, self.left_network_monitor['g_ampa_g'][idx]/nS, label='AMPA go') ax.plot(self.left_network_monitor['g_nmda'].times/ms, self.left_network_monitor['g_nmda'][idx]/nS, label='NMDA') ax.plot(self.left_network_monitor['g_gaba_a'].times/ms, self.left_network_monitor['g_gaba_a'][idx]/nS, label='GABA_A') ax.plot(self.left_network_monitor['g_gaba_b'].times/ms, self.left_network_monitor['g_gaba_b'][idx]/nS, label='GABA_B') ylim(0,max_conductance) ylabel(labels[i]) if not i: title('Left LIP - Conductance (nS)') legend() xlabel('Time (ms)') figure() for i,idx in enumerate(self.right_record_idx): ax=subplot(len(self.right_record_idx),1,i+1) ax.plot(self.right_network_monitor['g_ampa_r'].times/ms, self.right_network_monitor['g_ampa_r'][idx]/nS, label='AMPA recurrent') ax.plot(self.right_network_monitor['g_ampa_x'].times/ms, self.right_network_monitor['g_ampa_x'][idx]/nS, label='AMPA task') ax.plot(self.right_network_monitor['g_ampa_b'].times/ms, self.right_network_monitor['g_ampa_b'][idx]/nS, label='AMPA backgrnd') ax.plot(self.right_network_monitor['g_ampa_g'].times/ms, self.right_network_monitor['g_ampa_g'][idx]/nS, label='AMPA go') ax.plot(self.right_network_monitor['g_nmda'].times/ms, self.right_network_monitor['g_nmda'][idx]/nS, label='NMDA') ax.plot(self.right_network_monitor['g_gaba_a'].times/ms, self.right_network_monitor['g_gaba_a'][idx]/nS, label='GABA_A') ax.plot(self.right_network_monitor['g_gaba_b'].times/ms, self.right_network_monitor['g_gaba_b'][idx]/nS, label='GABA_B') ylim(0,max_conductance) ylabel(labels[i]) if not i: title('Right LIP - Conductance (nS)') legend() xlabel('Time (ms)') min_currents=[] max_currents=[] for idx in self.left_record_idx: max_currents.append(np.max(self.left_network_monitor['I_ampa_r'][idx]/nA)) max_currents.append(np.max(self.left_network_monitor['I_ampa_x'][idx]/nA)) max_currents.append(np.max(self.left_network_monitor['I_ampa_b'][idx]/nA)) max_currents.append(np.max(self.left_network_monitor['I_ampa_g'][idx]/nA)) max_currents.append(np.max(self.left_network_monitor['I_nmda'][idx]/nA)) max_currents.append(np.max(self.left_network_monitor['I_gaba_a'][idx]/nA)) max_currents.append(np.max(self.left_network_monitor['I_gaba_b'][idx]/nA)) min_currents.append(np.min(self.left_network_monitor['I_ampa_r'][idx]/nA)) min_currents.append(np.min(self.left_network_monitor['I_ampa_x'][idx]/nA)) min_currents.append(np.min(self.left_network_monitor['I_ampa_b'][idx]/nA)) min_currents.append(np.min(self.left_network_monitor['I_ampa_g'][idx]/nA)) min_currents.append(np.min(self.left_network_monitor['I_nmda'][idx]/nA)) min_currents.append(np.min(self.left_network_monitor['I_gaba_a'][idx]/nA)) min_currents.append(np.min(self.left_network_monitor['I_gaba_b'][idx]/nA)) for idx in self.right_record_idx: max_currents.append(np.max(self.right_network_monitor['I_ampa_r'][idx]/nA)) max_currents.append(np.max(self.right_network_monitor['I_ampa_x'][idx]/nA)) max_currents.append(np.max(self.right_network_monitor['I_ampa_b'][idx]/nA)) max_currents.append(np.max(self.right_network_monitor['I_ampa_g'][idx]/nA)) max_currents.append(np.max(self.right_network_monitor['I_nmda'][idx]/nA)) max_currents.append(np.max(self.right_network_monitor['I_gaba_a'][idx]/nA)) max_currents.append(np.max(self.right_network_monitor['I_gaba_b'][idx]/nA)) min_currents.append(np.min(self.right_network_monitor['I_ampa_r'][idx]/nA)) min_currents.append(np.min(self.right_network_monitor['I_ampa_x'][idx]/nA)) min_currents.append(np.min(self.right_network_monitor['I_ampa_b'][idx]/nA)) min_currents.append(np.min(self.right_network_monitor['I_ampa_g'][idx]/nA)) min_currents.append(np.min(self.right_network_monitor['I_nmda'][idx]/nA)) min_currents.append(np.min(self.right_network_monitor['I_gaba_a'][idx]/nA)) min_currents.append(np.min(self.right_network_monitor['I_gaba_b'][idx]/nA)) max_current=np.max(max_currents) min_current=np.min(min_currents) figure() for i,neuron_idx in enumerate(self.left_record_idx): ax=subplot(len(self.left_record_idx),1,i+1) ax.plot(self.left_network_monitor['I_ampa_r'].times/ms, self.left_network_monitor['I_ampa_r'][neuron_idx]/nA, label='AMPA-recurrent') ax.plot(self.left_network_monitor['I_ampa_x'].times/ms, self.left_network_monitor['I_ampa_x'][neuron_idx]/nA, label='AMPA-task') ax.plot(self.left_network_monitor['I_ampa_b'].times/ms, self.left_network_monitor['I_ampa_b'][neuron_idx]/nA, label='AMPA-backgrnd') ax.plot(self.left_network_monitor['I_ampa_b'].times/ms, self.left_network_monitor['I_ampa_g'][neuron_idx]/nA, label='AMPA-go') ax.plot(self.left_network_monitor['I_nmda'].times/ms, self.left_network_monitor['I_nmda'][neuron_idx]/nA, label='NMDA') ax.plot(self.left_network_monitor['I_gaba_a'].times/ms, self.left_network_monitor['I_gaba_a'][neuron_idx]/nA, label='GABA_A') ax.plot(self.left_network_monitor['I_gaba_b'].times/ms, self.left_network_monitor['I_gaba_b'][neuron_idx]/nA, label='GABA_B') ylim(min_current,max_current) ylabel(labels[i]) if not i: title('Left LIP - Current (nA)') legend() xlabel('Time (ms)') figure() for i,neuron_idx in enumerate(self.right_record_idx): ax=subplot(len(self.right_record_idx),1,i+1) ax.plot(self.right_network_monitor['I_ampa_r'].times/ms, self.right_network_monitor['I_ampa_r'][neuron_idx]/nA, label='AMPA-recurrent') ax.plot(self.right_network_monitor['I_ampa_x'].times/ms, self.right_network_monitor['I_ampa_x'][neuron_idx]/nA, label='AMPA-task') ax.plot(self.right_network_monitor['I_ampa_b'].times/ms, self.right_network_monitor['I_ampa_b'][neuron_idx]/nA, label='AMPA-backgrnd') ax.plot(self.right_network_monitor['I_ampa_b'].times/ms, self.right_network_monitor['I_ampa_g'][neuron_idx]/nA, label='AMPA-go') ax.plot(self.right_network_monitor['I_nmda'].times/ms, self.right_network_monitor['I_nmda'][neuron_idx]/nA, label='NMDA') ax.plot(self.right_network_monitor['I_gaba_a'].times/ms, self.right_network_monitor['I_gaba_a'][neuron_idx]/nA, label='GABA_A') ax.plot(self.right_network_monitor['I_gaba_b'].times/ms, self.right_network_monitor['I_gaba_b'][neuron_idx]/nA, label='GABA_B') ylim(min_current,max_current) ylabel(labels[i]) if not i: title('Right LIP - Current (nA)') legend() xlabel('Time (ms)') # LFP plot if self.left_lfp_monitor is not None and self.right_lfp_monitor is not None: figure() ax=subplot(111) ax.plot(self.left_lfp_monitor.times / ms, self.left_lfp_monitor[0] / mA, label='left LIP') ax.plot(self.right_lfp_monitor.times / ms, self.right_lfp_monitor[0] / mA, label='right LIP') legend() xlabel('Time (ms)') ylabel('LFP (mA)') # Voxel activity plots if self.left_voxel_monitor is not None and self.right_voxel_monitor is not None: syn_max=np.max([np.max(self.left_voxel_monitor['G_total'][0] / nS), np.max(self.right_voxel_monitor['G_total'][0] / nS)]) y_max=np.max([np.max(self.left_voxel_monitor['y'][0]), np.max(self.right_voxel_monitor['y'][0])]) y_min=np.min([np.min(self.left_voxel_monitor['y'][0]), np.min(self.right_voxel_monitor['y'][0])]) figure() if self.left_voxel_exc_monitor is None and self.right_voxel_exc_monitor is None: ax=subplot(211) else: ax=subplot(221) syn_max=np.max([syn_max, np.max(self.left_voxel_exc_monitor['G_total'][0]), np.max(self.right_voxel_exc_monitor['G_total'][0])]) y_max=np.max([y_max, np.max(self.left_voxel_exc_monitor['y'][0]), np.max(self.right_voxel_exc_monitor['y'][0])]) y_min=np.min([y_min, np.min(self.left_voxel_exc_monitor['y'][0]), np.min(self.right_voxel_exc_monitor['y'][0])]) ax.plot(self.left_voxel_monitor['G_total'].times / ms, self.left_voxel_monitor['G_total'][0] / nS, label='left LIP') ax.plot(self.right_voxel_monitor['G_total'].times / ms, self.right_voxel_monitor['G_total'][0] / nS, label='right LIP') legend() xlabel('Time (ms)') ylabel('Total Synaptic Activity (nS)') ylim(0, syn_max) if self.left_voxel_exc_monitor is None and self.right_voxel_exc_monitor is None: ax=subplot(212) else: ax=subplot(222) ax.plot(self.left_voxel_monitor['y'].times / ms, self.left_voxel_monitor['y'][0], label='left LIP') ax.plot(self.right_voxel_monitor['y'].times / ms, self.right_voxel_monitor['y'][0], label='right LIP') legend() xlabel('Time (ms)') ylabel('BOLD') ylim(y_min, y_max*2.0) if self.left_voxel_exc_monitor is not None and self.right_voxel_exc_monitor is not None: ax=subplot(223) ax.plot(self.left_voxel_exc_monitor['G_total'].times / ms, self.left_voxel_exc_monitor['G_total'][0] / nS, label='left LIP') ax.plot(self.right_voxel_exc_monitor['G_total'].times / ms, self.right_voxel_exc_monitor['G_total'][0] / nS, label='right LIP') legend() xlabel('Time (ms)') ylabel('Total Synaptic Activity (nS)') ylim(0, syn_max) ax=subplot(224) ax.plot(self.left_voxel_exc_monitor['y'].times / ms, self.left_voxel_exc_monitor['y'][0], label='left LIP') ax.plot(self.right_voxel_exc_monitor['y'].times / ms, self.right_voxel_exc_monitor['y'][0], label='right LIP') legend() xlabel('Time (ms)') ylabel('BOLD') ylim(y_min, y_max) show()
neuron_groups[i] = neuron_groups['e'].subgroup(num_neurons[i]) # print 'create monitors for', i rate_monitors[i] = b.PopulationRateMonitor(neuron_groups[i], bin = (single_example_time+resting_time)/b.second) spike_counters[i] = b.SpikeCounter(neuron_groups[i]) if record_spikes: spike_monitors[i] = b.SpikeMonitor(neuron_groups[i]) state_monitors[i] = b.MultiStateMonitor(neuron_groups[i], ['v'], record=[0]) if record_spikes: b.figure() b.ion() b.subplot(211) b.raster_plot(spike_monitors[1], refresh=1000*b.ms, showlast=1000*b.ms) b.subplot(212) b.raster_plot(spike_monitors[1], refresh=1000*b.ms, showlast=1000*b.ms) #------------------------------------------------------------------------------ # create input population #------------------------------------------------------------------------------ pop_values = [0,0,0] for i,name in enumerate(input_population_names): if poisson_inputs: input_groups[name] = b.PoissonGroup(n_input*2, 0) else: input_groups[name] = b.SpikeGeneratorGroup(n_input*2, [])
def run(self): #------------------------------------------------------------------------------ # run the simulation and set inputs #------------------------------------------------------------------------------ previousSpikeCountB = np.zeros(self.nE) previousSpikeCountC = np.zeros(self.nE) self.resultMonitor = np.zeros((self.numExamples,len(self.populationNames))) start = time.time() if self.recordSpikes: b.figure() b.ion() b.subplot(211) b.raster_plot(self.spikeMonitors['He'], refresh=1000*b.ms, showlast=1000*b.ms) b.subplot(212) b.raster_plot(self.spikeMonitors['Hi'], refresh=1000*b.ms, showlast=1000*b.ms) # realTimeMonitor = None # realTimeMonitor = rltmMon.RealtimeConnectionMonitor(self.connections['HeAe'], cmap=cm.get_cmap('gist_rainbow'), # wmin=0, wmax=self.wmaxEE, clock=Clock(1000*b.ms)) for j in xrange(int(self.numExamples)): if self.restingTime or j==0: for i,name in enumerate(self.inputPopulationNames): rates = np.ones(self.nE) * 0 self.inputGroups[name+'e'].rate = rates self.net.run(self.restingTime)#, report='text') if j%self.normalization_interval == 0: self.normalizeWeights() print 'set new rates of the inputs' self.popValues = [0]*len(self.inputPopulationNames) for i,name in enumerate(self.inputPopulationNames): if name == 'X': self.popValues[i] = np.random.rand(); rates = self.createTopoInput(self.nE, self.popValues[i]) self.resultMonitor[j,0] = self.popValues[i] else: if self.testMode: rates = np.ones(self.nE) * 0 elif name == 'Y': self.popValues[i] = (self.popValues[0]*2) % 1. rates = self.createTopoInput(self.nE, self.popValues[i]) elif name == 'Z': self.popValues[i] = (self.popValues[0]**2) % 1. rates = self.createTopoInput(self.nE, self.popValues[i]) if self.testMode: rates += noise self.inputGroups[name+'e'].rate = rates print 'run number:', j+1, 'of', int(self.numExamples) self.net.run(self.singleExampleTime)#, report='text') currentSpikeCountB = np.asarray(self.spikeCounters['Be'].count[:]) - previousSpikeCountB currentSpikeCountC = np.asarray(self.spikeCounters['Ce'].count[:]) - previousSpikeCountC # print currentSpikeCount, np.asarray(spikeCounters['Ce'].count[:]), previousSpikeCount previousSpikeCountB = np.copy(self.spikeCounters['Be'].count[:]) previousSpikeCountC = np.copy(self.spikeCounters['Ce'].count[:]) self.resultMonitor[j,1] = self.computePopVector(currentSpikeCountB) self.resultMonitor[j,2] = self.computePopVector(currentSpikeCountC) difference = np.abs((self.resultMonitor[j,0]**2)%1. - self.resultMonitor[j,2]) if difference > 0.5: difference = 1-difference print 'Pop. activity: ', self.resultMonitor[j,2], ', Desired activity: ', (self.resultMonitor[j,0]**2)%1., ', Difference: ', difference if not self.testMode: if self.numExamples <= 1000: if j%100 == 0: self.saveConnections(str(j)) else: if j%1000 == 0: self.saveConnections(str(j)) end = time.time() print 'time needed to simulate:', end - start #------------------------------------------------------------------------------ # save results #------------------------------------------------------------------------------ print 'save results' if self.testMode: np.savetxt(self.dataPath + 'activity/resultPopVecs' + str(self.numExamples) + '.txt', self.resultMonitor) else: self.saveConnections(str(j)) self.normalizeWeights() self.saveConnections()
win = minspikes//2 #for win in np.linspace(1, minspikes/2, 3): print("\nWindow length: %i" % win) corrs = cor_movavg_all(allslopes, krinpdist, win) best_corr = np.argmin(corrs) for n, c in enumerate(corrs): print("%i\t%.4f" % (n, c)) if doplot: pyplot.ion() # spike trains figure pyplot.figure("Spikes") pyplot.suptitle("Spike trains") pyplot.subplot(2,1,1) pyplot.title("Input") raster_plot(*inpmons) pyplot.axis(xmin=0, xmax=duration/ms) pyplot.subplot(2,1,2) pyplot.title("Neurons") raster_plot(spikemon) pyplot.axis(xmin=0, xmax=duration/ms) # voltages of target neurons if Nnrns < 10: # skip plotting if too many pyplot.figure("Voltages") pyplot.title("Membrane potential traces") for idx in range(Nnrns): pyplot.subplot(Nnrns, 1, idx+1) pyplot.plot(vmon.times, vmon[idx]) pyplot.plot([0*second, duration], [Vth, Vth], 'k--') pyplot.axis(ymax=float(Vth*2))
def run_simulation(realizations=1, trials=1, t=3000 * ms, alpha=1, ree=1, k=50, winlen=50 * ms, verbose=True, t_stim=0): """ Run the whole simulation with the specified parameters. All model parameter are set in the function. Keyword arguments: :param realizations: number of repititions of the whole simulation, number of network instances :param trials: number of trials for network instance :param t: simulation time :param alpha: scaling factor for number of neurons in the network :param ree: clustering coefficient :param k: number of clusters :param t_stim : duration of stimulation of a subset of clusters :param winlen: length of window in ms :param verbose: plotting flag :return: numpy matrices with spike times """ # The equations defining our neuron model eqs_string = """ dV/dt = (mu - V)/tau + x: volt dx/dt = -1.0/tau_2*(x - y/tau_1) : volt/second dy/dt = -y/tau_1 : volt mu : volt tau: second tau_2: second tau_1: second """ # Model parameters n_e = int(4000 * alpha) # number of exc neurons n_i = int(1000 * alpha) # number of inh neurons tau_e = 15 * ms # membrane time constant (for excitatory synapses) tau_i = 10 * ms # membrane time constant (for inhibitory synapses) tau_syn_2_e = 3 * ms # exc synaptic time constant tau2 in paper tau_syn_2_i = 2 * ms # inh synaptic time constant tau2 in paper tau_syn_1 = 1 * ms # exc/inh synaptic time constant tau1 in paper vt = -50 * mV # firing threshold vr = -65 * mV # reset potential dv = vt - vr # delta v refrac = 5 * ms # absolute refractory period # scale the weights to ensure same variance in the inputs wee = 0.024 * dv * np.sqrt(1.0 / alpha) wie = 0.014 * dv * np.sqrt(1.0 / alpha) wii = -0.057 * dv * np.sqrt(1.0 / alpha) wei = -0.045 * dv * np.sqrt(1.0 / alpha) # Connection probability p_ee = 0.2 p_ii = 0.5 p_ie = 0.5 p_ei = 0.5 # determine probs for inside and outside of clusters p_in, p_out = get_cluster_connection_probs(ree, k, p_ee) mu_min_e, mu_max_e = 1.1, 1.2 mu_min_i, mu_max_i = 1.0, 1.05 # increase cluster weights if there are clusters wee_cluster = wee if p_in == p_out else 1.9 * wee # define numpy array for data storing all_data = np.zeros((realizations, trials, n_e + n_i, int(t / winlen) // 2)) for realization in range(realizations): # clear workspace to make sure that is a new realization of the network clear(True, True) reinit() # set up new random bias parameter for every type of neuron mu_e = vr + np.random.uniform(mu_min_e, mu_max_e, n_e) * dv # bias for excitatory neurons mu_i = vr + np.random.uniform(mu_min_i, mu_max_i, n_i) * dv # bias for excitatory neurons # Let's create an equation object from our string and parameters model_eqs = Equations(eqs_string) # Let's create 5000 neurons all_neurons = NeuronGroup( N=n_e + n_i, model=model_eqs, threshold=vt, reset=vr, refractory=refrac, freeze=True, method="Euler", compile=True, ) # Divide the neurons into excitatory and inhibitory ones neurons_e = all_neurons[0:n_e] neurons_i = all_neurons[n_e : n_e + n_i] # set the bias neurons_e.mu = mu_e neurons_i.mu = mu_i neurons_e.tau = tau_e neurons_i.tau = tau_i neurons_e.tau_2 = tau_syn_2_e neurons_i.tau_2 = tau_syn_2_i all_neurons.tau_1 = tau_syn_1 # set up connections connections = Connection(all_neurons, all_neurons, "y") # do the cluster connection like cross validation: cluster neuron := test idx; other neurons := train idx kf = KFold(n=n_e, n_folds=k) for idx_out, idx_in in kf: # idx_out holds all other neurons; idx_in holds all cluster neurons # connect current cluster to itself connections.connect_random( all_neurons[idx_in[0] : idx_in[-1]], all_neurons[idx_in[0] : idx_in[-1]], sparseness=p_in, weight=wee_cluster, ) # connect current cluster to other neurons connections.connect_random( all_neurons[idx_in[0] : idx_in[-1]], all_neurons[idx_out[0] : idx_out[-1]], sparseness=p_out, weight=wee ) # connect all excitatory to all inhibitory, irrespective of clustering connections.connect_random(all_neurons[0:n_e], all_neurons[n_e : (n_e + n_i)], sparseness=p_ie, weight=wie) # connect all inhibitory to all excitatory connections.connect_random(all_neurons[n_e : (n_e + n_i)], all_neurons[0:n_e], sparseness=p_ei, weight=wei) # connect all inhibitory to all inhibitory connections.connect_random( all_neurons[n_e : (n_e + n_i)], all_neurons[n_e : (n_e + n_i)], sparseness=p_ii, weight=wii ) # set up spike monitors spike_mon_e = SpikeMonitor(neurons_e) spike_mon_i = SpikeMonitor(neurons_i) # set up network with monitors network = Network(all_neurons, connections, spike_mon_e, spike_mon_i) # run this network for some number of trials, every time with for trial in range(trials): # different initial values all_neurons.V = vr + (vt - vr) * np.random.rand(len(all_neurons)) * 1.4 # Calibration phase # run for the first half of the time to let the neurons adapt network.run(t / 2) # reset monitors to start recording phase spike_mon_i.reinit() spike_mon_e.reinit() # stimulation if duration is given # define index variable for the stimulation possibility (is 0 for stimulation time=0) t_stim_idx = int(t_stim / (winlen / ms)) if not (t_stim == 0): # Stimulation phase, increase input to subset of clusters all_neurons[:400].mu += 0.07 * dv network.run(t_stim * ms, report="text") # set back to normal all_neurons[:400].mu -= 0.07 * dv # save data all_data[realization, trial, :n_e, :t_stim_idx] = spikes_counter(spike_mon_e, winlen) all_data[realization, trial, n_e:, :t_stim_idx] = spikes_counter(spike_mon_i, winlen) # reset monitors spike_mon_e.reinit() spike_mon_i.reinit() # run the remaining time of the simulation network.run((t / 2) - t_stim * ms, report="text") # save results all_data[realization, trial, :n_e, t_stim_idx:] = spikes_counter(spike_mon_e, winlen) all_data[realization, trial, n_e:, t_stim_idx:] = spikes_counter(spike_mon_i, winlen) if verbose: plt.ion() plt.figure() raster_plot(spike_mon_e) plt.title("Excitatory neurons") spike_mon_e.reinit() spike_mon_i.reinit() return all_data
input_mon = SpikeMonitor(inp_group) spike_mon = SpikeMonitor(lif_group) network = Network(lif_group, inp_group, inp_conn, lif_conn, trace_mon, spike_mon, input_mon) print("Running for %f seconds ..." % (duration)) network.run(duration) print("Simulation run finished.") if spike_mon.nspikes == 0: print("No spikes were fired by the network. Aborting!") sys.exit() print("Performing Gaussian convolution ...") t, conv_spikes = sl.tools.spikeconvolve(spike_mon, 5*msecond) figure("Spike trains") splt = subplot(311) title("External inputs") raster_plot(input_mon) axis(xmin=0, xmax=duration/msecond) subplot(312) title("Network spikes") raster_plot(spike_mon) axis(xmin=0, xmax=duration/msecond) subplot(313) plot(t, conv_spikes) axis(xmin=0, xmax=float(duration)) scatter(t[np.argmax(conv_spikes)], max(conv_spikes), s=10) #show(block=False) print("Network synchrony peaked at t = %f s" % (t[np.argmax(conv_spikes)])) # let's run NPSS on all neurons and see what we get print("Calculating NPSS ...") npss = []
def run(self): #------------------------------------------------------------------------------ # run the simulation and set inputs #------------------------------------------------------------------------------ start = time.time() previousSpikeCount = np.zeros((self.nE,len(self.populationNames))) currentSpikeCount = np.zeros((self.nE,len(self.populationNames))) if self.recordSpikes: b.figure() b.ion() b.subplot(411) b.raster_plot(self.spikeMonitors['Ae'], refresh=1000*b.ms, showlast=1000*b.ms) b.subplot(412) b.raster_plot(self.spikeMonitors['Be'], refresh=1000*b.ms, showlast=1000*b.ms) b.subplot(413) b.raster_plot(self.spikeMonitors['Ce'], refresh=1000*b.ms, showlast=1000*b.ms) b.subplot(414) b.raster_plot(self.spikeMonitors['He'], refresh=1000*b.ms, showlast=1000*b.ms) # realTimeMonitor = None # realTimeMonitor = rltmMon.RealtimeConnectionMonitor(self.connections['HeAe'], cmap=cm.get_cmap('gist_rainbow'), # wmin=0, wmax=self.wmaxEE, clock=Clock(1000*b.ms)) for j in xrange(int(self.numExamples)): if self.restingTime or j==0: for i,name in enumerate(self.inputPopulationNames): rates = np.ones(self.nE) * 0 self.inputGroups[name+'e'].rate = rates self.net.run(self.restingTime)#, report='text') if j%self.normalization_interval == 0: self.normalizeWeights() print 'set new rates of the inputs' self.setNewInput(self,j) print 'run number:', j+1, 'of', int(self.numExamples) self.net.run(self.singleExampleTime)#, report='text') for i,name in enumerate(self.populationNames): name += 'e' currentSpikeCount[:,i] = np.asarray(self.spikeCounters[name].count[:]) - previousSpikeCount[:,i] # print currentSpikeCount, np.asarray(spikeCounters['Ce'].count[:]), previousSpikeCount previousSpikeCount[:,i] = np.copy(self.spikeCounters[name].count[:]) self.resultMonitor[j,i] = self.computePopVector(currentSpikeCount[:,i]) print name, 'pop. activity: ', self.resultMonitor[j,i], ', spikecount:', sum(currentSpikeCount[:,i]) for i,name in enumerate(self.inputPopulationNames): print name, 'pop. activity: ', (self.popValues[j,i]) if not self.testMode: if self.numExamples <= 1000: if j%100==0 and not j==0: self.saveConnections(str(j)) else: if j%10000==0 and not j==0: self.saveConnections(str(j)) end = time.time() print 'time needed to simulate:', end - start #------------------------------------------------------------------------------ # save results #------------------------------------------------------------------------------ print 'save results' if self.testMode: np.savetxt(self.dataPath + 'activity/resultPopVecs' + str(self.numExamples) + '.txt', self.resultMonitor) np.savetxt(self.dataPath + 'activity/spikeCount' + str(self.gaussian_peak_low) + '.txt', self.spikeCounters['Ae'].count[:]/(self.singleExampleTime*int(self.numExamples))) np.savetxt(self.dataPath + 'activity/inputSpikeCount' + str(self.gaussian_peak_low) + '.txt', self.spikeCounters['Xe'].count[:]/(self.singleExampleTime*int(self.numExamples))) np.savetxt(self.dataPath + 'activity/popVecs' + str(self.numExamples) + '.txt', self.popValues) else: self.saveConnections(str(j)) self.normalizeWeights() self.saveConnections()
def build_network(): global fig_num, assignments neuron_groups['e'] = b.NeuronGroup(n_e_total, neuron_eqs_e, threshold=v_thresh_e, refractory=refrac_e, reset=scr_e, compile=True, freeze=True) neuron_groups['i'] = b.NeuronGroup(n_e_total, neuron_eqs_i, threshold=v_thresh_i, refractory=refrac_i, reset=v_reset_i, compile=True, freeze=True) for name in population_names: print '...Creating neuron group:', name # get a subgroup of size 'n_e' from all exc neuron_groups[name + 'e'] = neuron_groups['e'].subgroup(conv_features * n_e) # get a subgroup of size 'n_i' from the inhibitory layer neuron_groups[name + 'i'] = neuron_groups['i'].subgroup(conv_features * n_e) # start the membrane potentials of these groups 40mV below their resting potentials neuron_groups[name + 'e'].v = v_rest_e - 40. * b.mV neuron_groups[name + 'i'].v = v_rest_i - 40. * b.mV print '...Creating recurrent connections' for name in population_names: # if we're in test mode / using some stored weights if test_mode: # load up adaptive threshold parameters if save_best_model: neuron_groups['e'].theta = np.load( os.path.join(best_weights_dir, '_'.join(['theta_A', ending + '_best.npy']))) else: neuron_groups['e'].theta = np.load( os.path.join(end_weights_dir, '_'.join(['theta_A', ending + '_end.npy']))) else: # otherwise, set the adaptive additive threshold parameter at 20mV neuron_groups['e'].theta = np.ones((n_e_total)) * 20.0 * b.mV for conn_type in recurrent_conn_names: if conn_type == 'ei': # create connection name (composed of population and connection types) conn_name = name + conn_type[0] + name + conn_type[1] # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection( neuron_groups[conn_name[0:2]], neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection for feature in xrange(conv_features): for n in xrange(n_e): connections[conn_name][feature * n_e + n, feature * n_e + n] = 10.4 elif conn_type == 'ie': # create connection name (composed of population and connections types) conn_name = name + conn_type[0] + name + conn_type[ 1] + '_' + ending # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection( neuron_groups[conn_name[0:2]], neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection with the 'weightMatrix' loaded from file for feature in xrange(conv_features): for other_feature in xrange(conv_features): if feature != other_feature: for n in xrange(n_e): connections[conn_name][feature * n_e + n, other_feature * n_e + n] = 17.4 print '...Creating monitors for:', name # spike rate monitors for excitatory and inhibitory neuron populations rate_monitors[name + 'e'] = b.PopulationRateMonitor( neuron_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second) rate_monitors[name + 'i'] = b.PopulationRateMonitor( neuron_groups[name + 'i'], bin=(single_example_time + resting_time) / b.second) spike_counters[name + 'e'] = b.SpikeCounter(neuron_groups[name + 'e']) # record neuron population spikes if specified if record_spikes or plot: spike_monitors[name + 'e'] = b.SpikeMonitor(neuron_groups[name + 'e']) spike_monitors[name + 'i'] = b.SpikeMonitor(neuron_groups[name + 'i']) if record_spikes and plot: b.figure(fig_num, figsize=(8, 6)) fig_num += 1 b.ion() b.subplot(211) b.raster_plot(spike_monitors['Ae'], refresh=1000 * b.ms, showlast=1000 * b.ms, title='Excitatory spikes per neuron') b.subplot(212) b.raster_plot(spike_monitors['Ai'], refresh=1000 * b.ms, showlast=1000 * b.ms, title='Inhibitory spikes per neuron') b.tight_layout() # creating Poission spike train from input image (784 vector, 28x28 image) for name in input_population_names: input_groups[name + 'e'] = b.PoissonGroup(n_input, 0) rate_monitors[name + 'e'] = b.PopulationRateMonitor( input_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second) # creating connections from input Poisson spike train to excitatory neuron population(s) for name in input_connection_names: print '\n...Creating connections between', name[0], 'and', name[1] # for each of the input connection types (in this case, excitatory -> excitatory) for conn_type in input_conn_names: # saved connection name conn_name = name[0] + conn_type[0] + name[1] + conn_type[1] # get weight matrix depending on training or test phase if test_mode: if save_best_model: weight_matrix = np.load( os.path.join( best_weights_dir, '_'.join([conn_name, ending + '_best.npy']))) else: weight_matrix = np.load( os.path.join( end_weights_dir, '_'.join([conn_name, ending + '_end.npy']))) # create connections from the windows of the input group to the neuron population input_connections[conn_name] = b.Connection(input_groups['Xe'], neuron_groups[name[1] + conn_type[1]], \ structure='sparse', state='g' + conn_type[0], delay=True, max_delay=delay[conn_type][1]) if test_mode: for feature in xrange(conv_features): for n in xrange(n_e): for idx in xrange(conv_size**2): input_connections[conn_name][convolution_locations[n][idx], feature * n_e + n] = \ weight_matrix[convolution_locations[n][idx], feature * n_e + n] else: for feature in xrange(conv_features): for n in xrange(n_e): for idx in xrange(conv_size**2): input_connections[conn_name][ convolution_locations[n][idx], feature * n_e + n] = (b.random() + 0.01) * 0.3 if test_mode: if plot: plot_weights_and_assignments(assignments) fig_num += 1 # if excitatory -> excitatory STDP is specified, add it here (input to excitatory populations) if not test_mode: print '...Creating STDP for connection', name # STDP connection name conn_name = name[0] + conn_type[0] + name[1] + conn_type[1] # create the STDP object stdp_methods[conn_name] = b.STDP(input_connections[conn_name], eqs=eqs_stdp_ee, \ pre=eqs_stdp_pre_ee, post=eqs_stdp_post_ee, wmin=0., wmax=wmax_ee) print '\n'
def plotResults(self): #------------------------------------------------------------------------------ # plot results #------------------------------------------------------------------------------ if self.rateMonitors: b.figure() for i, name in enumerate(self.rateMonitors): b.subplot(len(self.rateMonitors), 1, i) b.plot(self.rateMonitors[name].times/b.second, self.rateMonitors[name].rate, '.') b.title('rates of population ' + name) if self.spikeMonitors: b.figure() for i, name in enumerate(self.spikeMonitors): b.subplot(len(self.spikeMonitors), 1, i) b.raster_plot(self.spikeMonitors[name]) b.title('spikes of population ' + name) if name=='Ce': timePoints = np.linspace(0+(self.singleExampleTime+self.restingTime)/(2*b.second)*1000, self.runtime/b.second*1000-(self.singleExampleTime+self.restingTime)/(2*b.second)*1000, self.numExamples) b.plot(timePoints, self.resultMonitor[:,0]*self.nE, 'g') b.plot(timePoints, self.resultMonitor[:,1]*self.nE, 'r') if self.stateMonitors: b.figure() for i, name in enumerate(self.stateMonitors): b.plot(self.stateMonitors[name].times/b.second, self.stateMonitors[name]['v'][0], label = name + ' v 0') b.legend() b.title('membrane voltages of population ' + name) b.figure() for i, name in enumerate(self.stateMonitors): b.plot(self.stateMonitors[name].times/b.second, self.stateMonitors[name]['ge'][0], label = name + ' v 0') b.legend() b.title('conductances of population ' + name) plotWeights = [ # 'XeAe', # 'XeAi', # 'AeAe', # 'AeAi', # 'AiAe', # 'AiAi', # 'BeBe', # 'BeBi', # 'BiBe', # 'BiBi', # 'CeCe', # 'CeCi', 'CiCe', # 'CiCi', # 'HeHe', # 'HeHi', # 'HiHe', # 'HiHi', 'AeHe', # 'BeHe', # 'CeHe', 'HeAe', # 'HeBe', # 'HeCe', ] for name in plotWeights: b.figure() # my_cmap = matplotlib.colors.LinearSegmentedColormap.from_list('own2',['#f4f4f4', '#000000']) # my_cmap2 = matplotlib.colors.LinearSegmentedColormap.from_list('own2',['#000000', '#f4f4f4']) if name[1]=='e': nSrc = self.nE else: nSrc = self.nI if name[3]=='e': nTgt = self.nE else: nTgt = self.nI w_post = np.zeros((nSrc, nTgt)) connMatrix = self.connections[name][:] for i in xrange(nSrc): w_post[i, connMatrix.rowj[i]] = connMatrix.rowdata[i] im2 = b.imshow(w_post, interpolation="nearest", vmin = 0, cmap=cm.get_cmap('gist_ncar')) #my_cmap b.colorbar(im2) b.title('weights of connection' + name) if self.plotError: error = np.abs(self.resultMonitor[:,1] - self.resultMonitor[:,0]) correctionIdxs = np.where(error > 0.5)[0] correctedError = [1 - error[i] if (i in correctionIdxs) else error[i] for i in xrange(len(error))] correctedErrorSum = np.average(correctedError) b.figure() b.scatter(self.resultMonitor[:,1], self.resultMonitor[:,0], c=range(len(error)), cmap=cm.get_cmap('gray')) b.title('Error: ' + str(correctedErrorSum)) b.xlabel('Desired activity') b.ylabel('Population activity') b.figure() error = np.abs(self.resultMonitor[:,1] - self.resultMonitor[:,0]) correctionIdxs = np.where(error > 0.5)[0] correctedError = [1 - error[i] if (i in correctionIdxs) else error[i] for i in xrange(len(error))] correctedErrorSum = np.average(correctedError) b.scatter(self.resultMonitor[:,1], self.resultMonitor[:,0], c=self.resultMonitor[:,2], cmap=cm.get_cmap('gray')) b.title('Error: ' + str(correctedErrorSum)) b.xlabel('Desired activity') b.ylabel('Population activity') b.ioff() b.show()
class ConvolutionalSpikingNN(object): ''' Object which represents a convolutional spiking neural network. ''' def __init__(mode, connectivity, weight_dependence, post_pre, conv_size, conv_stride, conv_features, weight_sharing, lattice_structure, random_inhibition_prob, top_percent): ''' Network initialization. ''' # setting input parameters this.mode = mode this.connectivity = connectivity this.weight_dependence = weight_dependence this.post_pre = post_pre this.conv_size = conv_size this.conv_features = conv_features this.weight_sharing = weight_sharing this.lattice_structure = lattice_structure this.random_inhibition_prob = random_inhibition_prob # load training or testing data if mode == 'train': start = time.time() this.data = get_labeled_data(MNIST_data_path + 'training') end = time.time() print 'time needed to load training set:', end - start else: start = time.time() this.data = get_labeled_data(MNIST_data_path + 'testing', bTrain = False) end = time.time() print 'time needed to load test set:', end - start # set parameters for simulation based on train / test mode if test_mode: weight_path = top_level_path + 'weights/conv_patch_connectivity_weights/' this.num_examples = 10000 * 1 this.do_plot_performance = False ee_STDP_on = False else: weight_path = top_level_path + 'random/conv_patch_connectivity_random/' this.num_examples = 60000 * 1 this.do_plot_performance = True ee_STDP_on = True # plotting or not do_plot = True # number of inputs to the network this.n_input = 784 this.n_input_sqrt = int(math.sqrt(n_input)) # number of neurons parameters this.n_e = ((n_input_sqrt - conv_size) / conv_stride + 1) ** 2 this.n_e_total = n_e * conv_features this.n_e_sqrt = int(math.sqrt(n_e)) this.n_i = n_e this.conv_features_sqrt = int(math.sqrt(conv_features)) # time (in seconds) per data example presentation and rest period in between, used to calculate total runtime this.single_example_time = 0.35 * b.second this.resting_time = 0.15 * b.second runtime = num_examples * (single_example_time + resting_time) # set the update interval if test_mode: this.update_interval = num_examples else: this.update_interval = 100 # rest potential parameters, reset potential parameters, threshold potential parameters, and refractory periods v_rest_e, v_rest_i = -65. * b.mV, -60. * b.mV v_reset_e, v_reset_i = -65. * b.mV, -45. * b.mV v_thresh_e, v_thresh_i = -52. * b.mV, -40. * b.mV refrac_e, refrac_i = 5. * b.ms, 2. * b.ms # dictionaries for weights and delays weight, delay = {}, {} # populations, connections, saved connections, etc. input_population_names = [ 'X' ] population_names = [ 'A' ] input_connection_names = [ 'XA' ] save_conns = [ 'XeAe', 'AeAe' ] # weird and bad names for variables, I think input_conn_names = [ 'ee_input' ] recurrent_conn_names = [ 'ei', 'ie', 'ee' ] # setting weight, delay, and intensity parameters weight['ee_input'] = (conv_size ** 2) * 0.175 delay['ee_input'] = (0 * b.ms, 10 * b.ms) delay['ei_input'] = (0 * b.ms, 5 * b.ms) input_intensity = start_input_intensity = 2.0 # time constants, learning rates, max weights, weight dependence, etc. tc_pre_ee, tc_post_ee = 20 * b.ms, 20 * b.ms nu_ee_pre, nu_ee_post = 0.0001, 0.01 wmax_ee = 1.0 exp_ee_post = exp_ee_pre = 0.2 w_mu_pre, w_mu_post = 0.2, 0.2 # setting up differential equations (depending on train / test mode) if test_mode: scr_e = 'v = v_reset_e; timer = 0*ms' else: tc_theta = 1e7 * b.ms theta_plus_e = 0.05 * b.mV scr_e = 'v = v_reset_e; theta += theta_plus_e; timer = 0*ms' offset = 20.0 * b.mV v_thresh_e = '(v>(theta - offset + ' + str(v_thresh_e) + ')) * (timer>refrac_e)' # equations for neurons neuron_eqs_e = ''' dv/dt = ((v_rest_e - v) + (I_synE + I_synI) / nS) / (100 * ms) : volt I_synE = ge * nS * -v : amp I_synI = gi * nS * (-100.*mV-v) : amp dge/dt = -ge/(1.0*ms) : 1 dgi/dt = -gi/(2.0*ms) : 1 ''' if test_mode: neuron_eqs_e += '\n theta :volt' else: neuron_eqs_e += '\n dtheta/dt = -theta / (tc_theta) : volt' neuron_eqs_e += '\n dtimer/dt = 100.0 : ms' neuron_eqs_i = ''' dv/dt = ((v_rest_i - v) + (I_synE + I_synI) / nS) / (10*ms) : volt I_synE = ge * nS * -v : amp I_synI = gi * nS * (-85.*mV-v) : amp dge/dt = -ge/(1.0*ms) : 1 dgi/dt = -gi/(2.0*ms) : 1 ''' # creating dictionaries for various objects this.neuron_groups = {} this.input_groups = {} this.connections = {} this.input_connections = {} this.stdp_methods = {} this.rate_monitors = {} this.spike_monitors = {} this.spike_counters = {} # creating excitatory, inhibitory populations this.neuron_groups['e'] = b.NeuronGroup(n_e_total, neuron_eqs_e, threshold=v_thresh_e, refractory=refrac_e, reset=scr_e, compile=True, freeze=True) this.neuron_groups['i'] = b.NeuronGroup(n_e_total, neuron_eqs_i, threshold=v_thresh_i, refractory=refrac_i, reset=v_reset_i, compile=True, freeze=True) # creating subpopulations of excitatory, inhibitory neurons for name in population_names: print '...creating neuron group:', name # get a subgroup of size 'n_e' from all exc neuron_groups[name + 'e'] = neuron_groups['e'].subgroup(conv_features * n_e) # get a subgroup of size 'n_i' from the inhibitory layer neuron_groups[name + 'i'] = neuron_groups['i'].subgroup(conv_features * n_e) # start the membrane potentials of these groups 40mV below their resting potentials neuron_groups[name + 'e'].v = v_rest_e - 40. * b.mV neuron_groups[name + 'i'].v = v_rest_i - 40. * b.mV print '...creating recurrent connections' for name in population_names: # if we're in test mode / using some stored weights if mode == 'test' or weight_path[-8:] == 'weights/conv_patch_connectivity_weights/': # load up adaptive threshold parameters neuron_groups['e'].theta = np.load(weight_path + 'theta_A' + '_' + ending +'.npy') else: # otherwise, set the adaptive additive threshold parameter at 20mV neuron_groups['e'].theta = np.ones((n_e_total)) * 20.0 * b.mV for conn_type in recurrent_conn_names: if conn_type == 'ei': # create connection name (composed of population and connection types) conn_name = name + conn_type[0] + name + conn_type[1] # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection(neuron_groups[conn_name[0:2]], neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection for feature in xrange(conv_features): for n in xrange(n_e): connections[conn_name][feature * n_e + n, feature * n_e + n] = 10.4 elif conn_type == 'ie': # create connection name (composed of population and connection types) conn_name = name + conn_type[0] + name + conn_type[1] # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection(neuron_groups[conn_name[0:2]], neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection for feature in xrange(conv_features): for other_feature in xrange(conv_features): if feature != other_feature: for n in xrange(n_e): connections[conn_name][feature * n_e + n, other_feature * n_e + n] = 17.4 if random_inhibition_prob != 0.0: for feature in xrange(conv_features): for other_feature in xrange(conv_features): for n_this in xrange(n_e): for n_other in xrange(n_e): if n_this != n_other: if b.random() < random_inhibition_prob: connections[conn_name][feature * n_e + n_this, other_feature * n_e + n_other] = 17.4 elif conn_type == 'ee': # create connection name (composed of population and connection types) conn_name = name + conn_type[0] + name + conn_type[1] # get weights from file if we are in test mode if mode == 'test': weight_matrix = get_matrix_from_file(weight_path + conn_name + '_' + ending + '.npy', conv_features * n_e, conv_features * n_e) # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection(neuron_groups[conn_name[0:2]], neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection if connectivity == 'all': for feature in xrange(conv_features): for other_feature in xrange(conv_features): if feature != other_feature: for this_n in xrange(n_e): for other_n in xrange(n_e): if is_lattice_connection(n_e_sqrt, this_n, other_n): if mode == 'test': connections[conn_name][feature * n_e + this_n, other_feature * n_e + other_n] = weight_matrix[feature * n_e + this_n, other_feature * n_e + other_n] else: connections[conn_name][feature * n_e + this_n, other_feature * n_e + other_n] = (b.random() + 0.01) * 0.3 elif connectivity == 'pairs': for feature in xrange(conv_features): if feature % 2 == 0: for this_n in xrange(n_e): for other_n in xrange(n_e): if is_lattice_connection(n_e_sqrt, this_n, other_n): if mode == 'test': connections[conn_name][feature * n_e + this_n, (feature + 1) * n_e + other_n] = weight_matrix[feature * n_e + this_n, (feature + 1) * n_e + other_n] else: connections[conn_name][feature * n_e + this_n, (feature + 1) * n_e + other_n] = (b.random() + 0.01) * 0.3 elif feature % 2 == 1: for this_n in xrange(n_e): for other_n in xrange(n_e): if is_lattimode == 'test'ce_connection(n_e_sqrt, this_n, other_n): if mode == 'test': connections[conn_name][feature * n_e + this_n, (feature - 1) * n_e + other_n] = weight_matrix[feature * n_e + this_n, (feature - 1) * n_e + other_n] else: connections[conn_name][feature * n_e + this_n, (feature - 1) * n_e + other_n] = (b.random() + 0.01) * 0.3 elif connectivity == 'none': pass # if STDP from excitatory -> excitatory is on and this connection is excitatory -> excitatory if ee_STDP_on and 'ee' in recurrent_conn_names: stdp_methods[name + 'e' + name + 'e'] = b.STDP(connections[name + 'e' + name + 'e'], eqs=eqs_stdp_ee, pre=eqs_stdp_pre_ee, post=eqs_stdp_post_ee, wmin=0., wmax=wmax_ee) print '...creating monitors for:', name # spike rate monitors for excitatory and inhibitory neuron populations rate_monitors[name + 'e'] = b.PopulationRateMonitor(neuron_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second) rate_monitors[name + 'i'] = b.PopulationRateMonitor(neuron_groups[name + 'i'], bin=(single_example_time + resting_time) / b.second) spike_counters[name + 'e'] = b.SpikeCounter(neuron_groups[name + 'e']) # record neuron population spikes if specified spike_monitors[name + 'e'] = b.SpikeMonitor(neuron_groups[name + 'e']) spike_monitors[name + 'i'] = b.SpikeMonitor(neuron_groups[name + 'i']) if do_plot: b.figure(fig_num) fig_num += 1 b.ion() b.subplot(211) b.raster_plot(spike_monitors['Ae'], refresh=1000 * b.ms, showlast=1000 * b.ms) b.subplot(212) b.raster_plot(spike_monitors['Ai'], refresh=1000 * b.ms, showlast=1000 * b.ms) # creating lattice locations for each patch if connectivity == 'all': lattice_locations = {} for this_n in xrange(conv_features * n_e): lattice_locations[this_n] = [ other_n for other_n in xrange(conv_features * n_e) if is_lattice_connection(n_e_sqrt, this_n % n_e, other_n % n_e) ] elif connectivity == 'pairs': lattice_locations = {} for this_n in xrange(conv_features * n_e): lattice_locations[this_n] = [] for other_n in xrange(conv_features * n_e): if this_n // n_e % 2 == 0: if is_lattice_connection(n_e_sqrt, this_n % n_e, other_n % n_e) and other_n // n_e == this_n // n_e + 1: lattice_locations[this_n].append(other_n) elif this_n // n_e % 2 == 1: if is_lattice_connection(n_e_sqrt, this_n % n_e, other_n % n_e) and other_n // n_e == this_n // n_e - 1: lattice_locations[this_n].append(other_n) elif connectivity == 'none': lattice_locations = {} # setting up parameters for weight normalization between patches num_lattice_connections = sum([ len(value) for value in lattice_locations.values() ]) weight['ee_recurr'] = (num_lattice_connections / conv_features) * 0.15 # creating Poission spike train from input image (784 vector, 28x28 image) for name in input_population_names: input_groups[name + 'e'] = b.PoissonGroup(n_input, 0) rate_monitors[name + 'e'] = b.PopulationRateMonitor(input_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second) # creating connections from input Poisson spike train to convolution patch populations for name in input_connection_names: print '\n...creating connections between', name[0], 'and', name[1] # for each of the input connection types (in this case, excitatory -> excitatory) for conn_type in input_conn_names: # saved connection name conn_name = name[0] + conn_type[0] + name[1] + conn_type[1] # get weight matrix depending on training or test phase if mode == 'test': weight_matrix = get_matrix_from_file(weight_path + conn_name + '_' + ending + '.npy', n_input, conv_features * n_e) # create connections from the windows of the input group to the neuron population input_connections[conn_name] = b.Connection(input_groups['Xe'], neuron_groups[name[1] + conn_type[1]], structure='sparse', state='g' + conn_type[0], delay=True, max_delay=delay[conn_type][1]) if mode == 'test': for feature in xrange(conv_features): for n in xrange(n_e): for idx in xrange(conv_size ** 2): input_connections[conn_name][convolution_locations[n][idx], feature * n_e + n] = weight_matrix[convolution_locations[n][idx], feature * n_e + n] else: for feature in xrange(conv_features): for n in xrange(n_e): for idx in xrange(conv_size ** 2): input_connections[conn_name][convolution_locations[n][idx], feature * n_e + n] = (b.random() + 0.01) * 0.3 # if excitatory -> excitatory STDP is specified, add it here (input to excitatory populations) if ee_STDP_on: print '...creating STDP for connection', name # STDP connection name conn_name = name[0] + conn_type[0] + name[1] + conn_type[1] # create the STDP object stdp_methods[conn_name] = b.STDP(input_connections[conn_name], eqs=eqs_stdp_ee, pre=eqs_stdp_pre_ee, post=eqs_stdp_post_ee, wmin=0., wmax=wmax_ee) print '\n'
def plot(self): # Spike raster plots if self.record_spikes: num_plots=self.network_params.num_groups+1 figure() for i in range(self.network_params.num_groups): subplot(num_plots,1,i+1) raster_plot(self.monitors['excitatory_spike_%d' % i],newfigure=False) subplot(num_plots,1,num_plots) raster_plot(self.monitors['inhibitory_spike'],newfigure=False) # Network firing rate plots if self.record_firing_rate: e_rate_0=self.monitors['excitatory_rate_0'].smooth_rate(width=5*ms)/hertz e_rate_1=self.monitors['excitatory_rate_1'].smooth_rate(width=5*ms)/hertz i_rate=self.monitors['inhibitory_rate'].smooth_rate(width=5*ms)/hertz plot_network_firing_rates(np.array([e_rate_0, e_rate_1]), i_rate, self.sim_params, self.network_params) # Input firing rate plots if self.record_inputs: figure() ax=subplot(111) max_rate=0 task_rates=[] for i in range(self.network_params.num_groups): task_monitor=self.monitors['task_rate_%d' % i] task_rate=task_monitor.smooth_rate(width=5*ms,filter='gaussian')/hertz if np.max(task_rate)>max_rate: max_rate=np.max(task_rate) task_rates.append(task_rate) rect=Rectangle((0,0),(self.sim_params.stim_end_time-self.sim_params.stim_start_time)/ms, max_rate+5, alpha=0.25, facecolor='yellow', edgecolor='none') ax.add_patch(rect) # ax.plot(self.monitors['background_rate'].times/ms, # self.monitors['background_rate'].smooth_rate(width=5*ms)/hertz) for i in range(self.network_params.num_groups): ax.plot((np.array(range(len(task_rates[i])))*self.sim_params.dt)/ms-self.sim_params.stim_start_time/ms, task_rates[i]) ylim(0,90) ylabel('Firing rate (Hz)') xlabel('Time (ms)') # Network state plots if self.record_neuron_state: network_monitor=self.monitors['network'] max_conductances=[] for neuron_idx in self.record_idx: max_conductances.append(np.max(network_monitor['g_ampa_r'][neuron_idx]/nS)) max_conductances.append(np.max(network_monitor['g_ampa_x'][neuron_idx]/nS)) max_conductances.append(np.max(network_monitor['g_ampa_b'][neuron_idx]/nS)) max_conductances.append(np.max(network_monitor['g_nmda'][neuron_idx]/nS)) max_conductances.append(np.max(network_monitor['g_gaba_a'][neuron_idx]/nS)) #max_conductances.append(np.max(self.network_monitor['g_gaba_b'][neuron_idx]/nS)) max_conductance=np.max(max_conductances) fig=figure() for i in range(self.network_params.num_groups): neuron_idx=self.record_idx[i] ax=subplot(int('%d1%d' % (self.network_params.num_groups+1,i+1))) title('e%d' % i) ax.plot(network_monitor['g_ampa_r'].times/ms, network_monitor['g_ampa_r'][neuron_idx]/nS, label='AMPA-recurrent') ax.plot(network_monitor['g_ampa_x'].times/ms, network_monitor['g_ampa_x'][neuron_idx]/nS, label='AMPA-task') ax.plot(network_monitor['g_ampa_b'].times/ms, network_monitor['g_ampa_b'][neuron_idx]/nS, label='AMPA-backgrnd') ax.plot(network_monitor['g_nmda'].times/ms, network_monitor['g_nmda'][neuron_idx]/nS, label='NMDA') ax.plot(network_monitor['g_gaba_a'].times/ms, network_monitor['g_gaba_a'][neuron_idx]/nS, label='GABA_A') #ax.plot(network_monitor['g_gaba_b'].times/ms, network_monitor['g_gaba_b'][neuron_idx]/nS, # label='GABA_B') ylim(0,max_conductance) xlabel('Time (ms)') ylabel('Conductance (nS)') legend() neuron_idx=self.record_idx[self.network_params.num_groups] ax=subplot('%d1%d' % (self.network_params.num_groups+1,self.network_params.num_groups+1)) title('i') ax.plot(network_monitor['g_ampa_r'].times/ms, network_monitor['g_ampa_r'][neuron_idx]/nS, label='AMPA-recurrent') ax.plot(network_monitor['g_ampa_x'].times/ms, network_monitor['g_ampa_x'][neuron_idx]/nS, label='AMPA-task') ax.plot(network_monitor['g_ampa_b'].times/ms, network_monitor['g_ampa_b'][neuron_idx]/nS, label='AMPA-backgrnd') ax.plot(network_monitor['g_nmda'].times/ms, network_monitor['g_nmda'][neuron_idx]/nS, label='NMDA') ax.plot(network_monitor['g_gaba_a'].times/ms, network_monitor['g_gaba_a'][neuron_idx]/nS, label='GABA_A') #ax.plot(network_monitor['g_gaba_b'].times/ms, network_monitor['g_gaba_b'][neuron_idx]/nS, # label='GABA_B') ylim(0,max_conductance) xlabel('Time (ms)') ylabel('Conductance (nS)') legend() min_currents=[] max_currents=[] for neuron_idx in self.record_idx: max_currents.append(np.max(network_monitor['I_ampa_r'][neuron_idx]/nS)) max_currents.append(np.max(network_monitor['I_ampa_x'][neuron_idx]/nS)) max_currents.append(np.max(network_monitor['I_ampa_b'][neuron_idx]/nS)) max_currents.append(np.max(network_monitor['I_nmda'][neuron_idx]/nS)) max_currents.append(np.max(network_monitor['I_gaba_a'][neuron_idx]/nS)) #max_currents.append(np.max(network_monitor['I_gaba_b'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_ampa_r'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_ampa_x'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_ampa_b'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_nmda'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_gaba_a'][neuron_idx]/nS)) #min_currents.append(np.min(network_monitor['I_gaba_b'][neuron_idx]/nS)) max_current=np.max(max_currents) min_current=np.min(min_currents) fig=figure() for i in range(self.network_params.num_groups): ax=subplot(int('%d1%d' % (self.network_params.num_groups+1,i+1))) neuron_idx=self.record_idx[i] title('e%d' % i) ax.plot(network_monitor['I_ampa_r'].times/ms, network_monitor['I_ampa_r'][neuron_idx]/nA, label='AMPA-recurrent') ax.plot(network_monitor['I_ampa_x'].times/ms, network_monitor['I_ampa_x'][neuron_idx]/nA, label='AMPA-task') ax.plot(network_monitor['I_ampa_b'].times/ms, network_monitor['I_ampa_b'][neuron_idx]/nA, label='AMPA-backgrnd') ax.plot(network_monitor['I_nmda'].times/ms, network_monitor['I_nmda'][neuron_idx]/nA, label='NMDA') ax.plot(network_monitor['I_gaba_a'].times/ms, network_monitor['I_gaba_a'][neuron_idx]/nA, label='GABA_A') #ax.plot(network_monitor['I_gaba_b'].times/ms, network_monitor['I_gaba_b'][neuron_idx]/nA, # label='GABA_B') ylim(min_current,max_current) xlabel('Time (ms)') ylabel('Current (nA)') legend() ax=subplot(int('%d1%d' % (self.network_params.num_groups+1,self.network_params.num_groups+1))) neuron_idx=self.record_idx[self.network_params.num_groups] title('i') ax.plot(network_monitor['I_ampa_r'].times/ms, network_monitor['I_ampa_r'][neuron_idx]/nA, label='AMPA-recurrent') ax.plot(network_monitor['I_ampa_x'].times/ms, network_monitor['I_ampa_x'][neuron_idx]/nA, label='AMPA-task') ax.plot(network_monitor['I_ampa_b'].times/ms, network_monitor['I_ampa_b'][neuron_idx]/nA, label='AMPA-backgrnd') ax.plot(network_monitor['I_nmda'].times/ms, network_monitor['I_nmda'][neuron_idx]/nA, label='NMDA') ax.plot(network_monitor['I_gaba_a'].times/ms, network_monitor['I_gaba_a'][neuron_idx]/nA, label='GABA_A') #ax.plot(network_monitor['I_gaba_b'].times/ms, network_monitor['I_gaba_b'][neuron_idx]/nA, # label='GABA_B') ylim(min_current,max_current) xlabel('Time (ms)') ylabel('Current (nA)') legend() # LFP plot if self.record_lfp: figure() ax=subplot(111) ax.plot(self.monitors['lfp'].times / ms, self.monitors['lfp'][0]/mA) xlabel('Time (ms)') ylabel('LFP (mA)') # Voxel activity plots if self.record_voxel: voxel_monitor=self.monitors['voxel'] voxel_exc_monitor=None if 'voxel_exc' in self.monitors: voxel_exc_monitor=self.monitors['voxel_exc'] syn_max=np.max(voxel_monitor['G_total'][0] / nS) y_max=np.max(voxel_monitor['y'][0]) y_min=np.min(voxel_monitor['y'][0]) figure() if voxel_exc_monitor is None: ax=subplot(211) else: ax=subplot(221) syn_max=np.max([syn_max, np.max(voxel_exc_monitor['G_total'][0])]) y_max=np.max([y_max, np.max(voxel_exc_monitor['y'][0])]) y_min=np.min([y_min, np.min(voxel_exc_monitor['y'][0])]) ax.plot(voxel_monitor['G_total'].times / ms, voxel_monitor['G_total'][0] / nS) xlabel('Time (ms)') ylabel('Total Synaptic Activity (nS)') ylim(0, syn_max) if voxel_exc_monitor is None: ax=subplot(212) else: ax=subplot(222) ax.plot(voxel_monitor['y'].times / ms, voxel_monitor['y'][0]) xlabel('Time (ms)') ylabel('BOLD') ylim(y_min, y_max) if voxel_exc_monitor is not None: ax=subplot(223) ax.plot(voxel_exc_monitor['G_total'].times / ms, voxel_exc_monitor['G_total'][0] / nS) xlabel('Time (ms)') ylabel('Total Synaptic Activity (nS)') ylim(0, syn_max) ax=subplot(224) ax.plot(voxel_exc_monitor['y'].times / ms, voxel_exc_monitor['y'][0]) xlabel('Time (ms)') ylabel('BOLD') ylim(y_min, y_max) if self.record_connections: figure() ax=subplot(111) for mon in self.monitors: if mon.startswith('connection_'): conn_name=mon[11:] conns=np.zeros((len(self.monitors[mon].values),1)) conn_times=[] for idx, (time, conn_matrix) in enumerate(self.monitors[mon].values): conn_diag=np.diagonal(conn_matrix.todense()) mean_w=np.mean(conn_diag) conns[idx,0]=mean_w conn_times.append(time) ax.plot(np.array(conn_times) / ms, conns[:,0]/nS, label=conn_name) legend(loc='best') xlabel('Time (ms)') ylabel('Connection Weight (nS)')
# plot results #------------------------------------------------------------------------------ if rate_monitors: b.figure(fig_num) fig_num += 1 for i, name in enumerate(rate_monitors): b.subplot(len(rate_monitors), 1, i) b.plot(rate_monitors[name].times / b.second, rate_monitors[name].rate, '.') b.title('Rates of population ' + name) if spike_monitors: b.figure(fig_num) fig_num += 1 for i, name in enumerate(spike_monitors): b.subplot(len(spike_monitors), 1, i) b.raster_plot(spike_monitors[name]) b.title('Spikes of population ' + name) if spike_counters: b.figure(fig_num) fig_num += 1 for i, name in enumerate(spike_counters): b.subplot(len(spike_counters), 1, i) b.plot(spike_counters['Ae'].count[:]) b.title('Spike count of population ' + name) plot_2d_input_weights() b.ioff() b.show()
# Let's run our simulation network.run(duration, report='text') #plt.figure() #plt.plot(state_mon_isyn.times,state_mon_isyn.values[0,:]) # Plot spike raster plots, blue exc neurons, red inh neurons plt.figure() gs = gridspec.GridSpec(2, 1, height_ratios=[1, 3]) plt.subplot(gs[0]) raster_plot(spike_mon_i, color='r') plt.title('Inhibitory neurons') plt.subplot(gs[1]) raster_plot(spike_mon_e) plt.title('Excitatory neurons') # Plot the evolution of the membrane potentials '''plt.figure() for irun in range(1,6): plt.subplot(6,1,irun) if irun < 3: mon = state_mon_v_i idx = irun-1 color='r' else: mon = state_mon_v_e
def run_simulation(realizations=1, trials=1, t=3000 * ms, alpha=1, ree=1, k=50, winlen = 50 * ms, verbose=True, t_stim = 0): """ Run the whole simulation with the specified parameters. All model parameter are set in the function. Keyword arguments: :param realizations: number of repititions of the whole simulation, number of network instances :param trials: number of trials for network instance :param t: simulation time :param alpha: scaling factor for number of neurons in the network :param ree: clustering coefficient :param k: number of clusters :param t_stim : duration of stimulation of a subset of clusters :param winlen: length of window in ms :param verbose: plotting flag :return: numpy matrices with spike times """ # The equations defining our neuron model eqs_string = ''' dV/dt = (mu - V)/tau + x: volt dx/dt = -1.0/tau_2*(x - y/tau_1) : volt/second dy/dt = -y/tau_1 : volt mu : volt tau: second tau_2: second tau_1: second ''' # Model parameters n_e = int(4000 * alpha) # number of exc neurons n_i = int(1000 * alpha) # number of inh neurons tau_e = 15 * ms # membrane time constant (for excitatory synapses) tau_i = 10 * ms # membrane time constant (for inhibitory synapses) tau_syn_2_e = 3 * ms # exc synaptic time constant tau2 in paper tau_syn_2_i = 2 * ms # inh synaptic time constant tau2 in paper tau_syn_1 = 1 * ms # exc/inh synaptic time constant tau1 in paper vt = -50 * mV # firing threshold vr = -65 * mV # reset potential dv = vt - vr # delta v refrac = 5 * ms # absolute refractory period # scale the weights to ensure same variance in the inputs wee = 0.024 * dv * np.sqrt(1. / alpha) wie = 0.014 * dv * np.sqrt(1. / alpha) wii = -0.057 * dv * np.sqrt(1. / alpha) wei = -0.045 * dv * np.sqrt(1. / alpha) # Connection probability p_ee = 0.2 p_ii = 0.5 p_ie = 0.5 p_ei = 0.5 # determine probs for inside and outside of clusters p_in, p_out = get_cluster_connection_probs(ree, k, p_ee) mu_min_e, mu_max_e = 1.1, 1.2 mu_min_i, mu_max_i = 1.0, 1.05 # increase cluster weights if there are clusters wee_cluster = wee if p_in == p_out else 1.9 * wee # define numpy array for data storing all_data = np.zeros((realizations, trials, n_e+n_i, int(t/winlen)//2)) for realization in range(realizations): # clear workspace to make sure that is a new realization of the network clear(True, True) reinit() # set up new random bias parameter for every type of neuron mu_e = vr + np.random.uniform(mu_min_e, mu_max_e, n_e) * dv # bias for excitatory neurons mu_i = vr + np.random.uniform(mu_min_i, mu_max_i, n_i) * dv # bias for excitatory neurons # Let's create an equation object from our string and parameters model_eqs = Equations(eqs_string) # Let's create 5000 neurons all_neurons = NeuronGroup(N=n_e + n_i, model=model_eqs, threshold=vt, reset=vr, refractory=refrac, freeze=True, method='Euler', compile=True) # Divide the neurons into excitatory and inhibitory ones neurons_e = all_neurons[0:n_e] neurons_i = all_neurons[n_e:n_e + n_i] # set the bias neurons_e.mu = mu_e neurons_i.mu = mu_i neurons_e.tau = tau_e neurons_i.tau = tau_i neurons_e.tau_2 = tau_syn_2_e neurons_i.tau_2 = tau_syn_2_i all_neurons.tau_1 = tau_syn_1 # set up connections connections = Connection(all_neurons, all_neurons, 'y') # do the cluster connection like cross validation: cluster neuron := test idx; other neurons := train idx kf = KFold(n=n_e, n_folds=k) for idx_out, idx_in in kf: # idx_out holds all other neurons; idx_in holds all cluster neurons # connect current cluster to itself connections.connect_random(all_neurons[idx_in[0]:idx_in[-1]], all_neurons[idx_in[0]:idx_in[-1]], sparseness=p_in, weight=wee_cluster) # connect current cluster to other neurons connections.connect_random(all_neurons[idx_in[0]:idx_in[-1]], all_neurons[idx_out[0]:idx_out[-1]], sparseness=p_out, weight=wee) # connect all excitatory to all inhibitory, irrespective of clustering connections.connect_random(all_neurons[0:n_e], all_neurons[n_e:(n_e + n_i)], sparseness=p_ie, weight=wie) # connect all inhibitory to all excitatory connections.connect_random(all_neurons[n_e:(n_e + n_i)], all_neurons[0:n_e], sparseness=p_ei, weight=wei) # connect all inhibitory to all inhibitory connections.connect_random(all_neurons[n_e:(n_e + n_i)], all_neurons[n_e:(n_e + n_i)], sparseness=p_ii, weight=wii) # set up spike monitors spike_mon_e = SpikeMonitor(neurons_e) spike_mon_i = SpikeMonitor(neurons_i) # set up network with monitors network = Network(all_neurons, connections, spike_mon_e, spike_mon_i) # run this network for some number of trials, every time with for trial in range(trials): # different initial values all_neurons.V = vr + (vt - vr) * np.random.rand(len(all_neurons)) * 1.4 # Calibration phase # run for the first half of the time to let the neurons adapt network.run(t/2) # reset monitors to start recording phase spike_mon_i.reinit() spike_mon_e.reinit() # stimulation if duration is given # define index variable for the stimulation possibility (is 0 for stimulation time=0) t_stim_idx = int(t_stim / (winlen/ms)) if not(t_stim==0): # Stimulation phase, increase input to subset of clusters all_neurons[:400].mu += 0.07 * dv network.run(t_stim * ms, report='text') # set back to normal all_neurons[:400].mu -= 0.07 * dv # save data all_data[realization, trial, :n_e, :t_stim_idx] = spikes_counter(spike_mon_e, winlen) all_data[realization, trial, n_e:, :t_stim_idx] = spikes_counter(spike_mon_i, winlen) # reset monitors spike_mon_e.reinit() spike_mon_i.reinit() # run the remaining time of the simulation network.run((t/2) - t_stim*ms, report='text') # save results all_data[realization, trial, :n_e, t_stim_idx:] = spikes_counter(spike_mon_e, winlen) all_data[realization, trial, n_e:, t_stim_idx:] = spikes_counter(spike_mon_i, winlen) if verbose: plt.ion() plt.figure() raster_plot(spike_mon_e) plt.title('Excitatory neurons') spike_mon_e.reinit() spike_mon_i.reinit() return all_data
def plot(self): # Spike raster plots if self.record_spikes: num_plots=self.network_params.num_groups+1 plt.figure() for i in range(self.network_params.num_groups): plt.subplot(num_plots,1,i+1) raster_plot(self.monitors['excitatory_spike_%d' % i],newfigure=False) plt.subplot(num_plots,1,num_plots) raster_plot(self.monitors['inhibitory_spike'],newfigure=False) # Network firing rate plots if self.record_firing_rate: e_rate_0=self.monitors['excitatory_rate_0'].smooth_rate(width=5*ms)/hertz e_rate_1=self.monitors['excitatory_rate_1'].smooth_rate(width=5*ms)/hertz #i_rate=self.monitors['inhibitory_rate'].smooth_rate(width=5*ms)/hertz #plot_network_firing_rates(np.array([e_rate_0, e_rate_1]), i_rate, self.sim_params, self.network_params) plot_network_firing_rates(np.array([e_rate_0, e_rate_1]), self.sim_params, self.network_params) # Input firing rate plots if self.record_inputs: plt.figure() ax= plt.subplot(111) max_rate=0 task_rates=[] for i in range(self.network_params.num_groups): task_monitor=self.monitors['task_rate_%d' % i] task_rate=task_monitor.smooth_rate(width=5*ms,filter='gaussian')/hertz if np.max(task_rate)>max_rate: max_rate=np.max(task_rate) task_rates.append(task_rate) rect=Rectangle((0,0),(self.sim_params.stim_end_time-self.sim_params.stim_start_time)/ms, max_rate+5, alpha=0.25, facecolor='yellow', edgecolor='none') ax.add_patch(rect) for i in range(self.network_params.num_groups): ax.plot((np.array(range(len(task_rates[i])))*self.sim_params.dt)/ms-self.sim_params.stim_start_time/ms, task_rates[i]) plt.ylim(0,90) plt.ylabel('Firing rate (Hz)') plt.xlabel('Time (ms)') # Network state plots if self.record_neuron_state: network_monitor=self.monitors['network'] max_conductances=[] for neuron_idx in self.record_idx: max_conductances.append(np.max(network_monitor['g_ampa_r'][neuron_idx]/nS)) max_conductances.append(np.max(network_monitor['g_ampa_x'][neuron_idx]/nS)) max_conductances.append(np.max(network_monitor['g_ampa_b'][neuron_idx]/nS)) max_conductances.append(np.max(network_monitor['g_nmda'][neuron_idx]/nS)) max_conductances.append(np.max(network_monitor['g_gaba_a'][neuron_idx]/nS)) max_conductance=np.max(max_conductances) fig= plt.figure() for i in range(self.network_params.num_groups): neuron_idx=self.record_idx[i] ax= plt.subplot(int('%d1%d' % (self.network_params.num_groups+1,i+1))) plt.title('e%d' % i) ax.plot(network_monitor['g_ampa_r'].times/ms, network_monitor['g_ampa_r'][neuron_idx]/nS, label='AMPA-recurrent') ax.plot(network_monitor['g_ampa_x'].times/ms, network_monitor['g_ampa_x'][neuron_idx]/nS, label='AMPA-task') ax.plot(network_monitor['g_ampa_b'].times/ms, network_monitor['g_ampa_b'][neuron_idx]/nS, label='AMPA-backgrnd') ax.plot(network_monitor['g_nmda'].times/ms, network_monitor['g_nmda'][neuron_idx]/nS, label='NMDA') ax.plot(network_monitor['g_gaba_a'].times/ms, network_monitor['g_gaba_a'][neuron_idx]/nS, label='GABA_A') plt.ylim(0,max_conductance) plt.xlabel('Time (ms)') plt.ylabel('Conductance (nS)') plt.legend() neuron_idx=self.record_idx[self.network_params.num_groups] ax= plt.subplot('%d1%d' % (self.network_params.num_groups+1,self.network_params.num_groups+1)) plt.title('i') ax.plot(network_monitor['g_ampa_r'].times/ms, network_monitor['g_ampa_r'][neuron_idx]/nS, label='AMPA-recurrent') ax.plot(network_monitor['g_ampa_x'].times/ms, network_monitor['g_ampa_x'][neuron_idx]/nS, label='AMPA-task') ax.plot(network_monitor['g_ampa_b'].times/ms, network_monitor['g_ampa_b'][neuron_idx]/nS, label='AMPA-backgrnd') ax.plot(network_monitor['g_nmda'].times/ms, network_monitor['g_nmda'][neuron_idx]/nS, label='NMDA') ax.plot(network_monitor['g_gaba_a'].times/ms, network_monitor['g_gaba_a'][neuron_idx]/nS, label='GABA_A') plt.ylim(0,max_conductance) plt.xlabel('Time (ms)') plt.ylabel('Conductance (nS)') plt.legend() min_currents=[] max_currents=[] for neuron_idx in self.record_idx: max_currents.append(np.max(network_monitor['I_ampa_r'][neuron_idx]/nS)) max_currents.append(np.max(network_monitor['I_ampa_x'][neuron_idx]/nS)) max_currents.append(np.max(network_monitor['I_ampa_b'][neuron_idx]/nS)) max_currents.append(np.max(network_monitor['I_nmda'][neuron_idx]/nS)) max_currents.append(np.max(network_monitor['I_gaba_a'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_ampa_r'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_ampa_x'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_ampa_b'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_nmda'][neuron_idx]/nS)) min_currents.append(np.min(network_monitor['I_gaba_a'][neuron_idx]/nS)) max_current=np.max(max_currents) min_current=np.min(min_currents) fig=plt.figure() for i in range(self.network_params.num_groups): ax=plt.subplot(int('%d1%d' % (self.network_params.num_groups+1,i+1))) neuron_idx=self.record_idx[i] plt.title('e%d' % i) ax.plot(network_monitor['I_ampa_r'].times/ms, network_monitor['I_ampa_r'][neuron_idx]/nA, label='AMPA-recurrent') ax.plot(network_monitor['I_ampa_x'].times/ms, network_monitor['I_ampa_x'][neuron_idx]/nA, label='AMPA-task') ax.plot(network_monitor['I_ampa_b'].times/ms, network_monitor['I_ampa_b'][neuron_idx]/nA, label='AMPA-backgrnd') ax.plot(network_monitor['I_nmda'].times/ms, network_monitor['I_nmda'][neuron_idx]/nA, label='NMDA') ax.plot(network_monitor['I_gaba_a'].times/ms, network_monitor['I_gaba_a'][neuron_idx]/nA, label='GABA_A') plt.ylim(min_current,max_current) plt.xlabel('Time (ms)') plt.ylabel('Current (nA)') plt.legend() ax=plt.subplot(int('%d1%d' % (self.network_params.num_groups+1,self.network_params.num_groups+1))) neuron_idx=self.record_idx[self.network_params.num_groups] plt.title('i') ax.plot(network_monitor['I_ampa_r'].times/ms, network_monitor['I_ampa_r'][neuron_idx]/nA, label='AMPA-recurrent') ax.plot(network_monitor['I_ampa_x'].times/ms, network_monitor['I_ampa_x'][neuron_idx]/nA, label='AMPA-task') ax.plot(network_monitor['I_ampa_b'].times/ms, network_monitor['I_ampa_b'][neuron_idx]/nA, label='AMPA-backgrnd') ax.plot(network_monitor['I_nmda'].times/ms, network_monitor['I_nmda'][neuron_idx]/nA, label='NMDA') ax.plot(network_monitor['I_gaba_a'].times/ms, network_monitor['I_gaba_a'][neuron_idx]/nA, label='GABA_A') plt.ylim(min_current,max_current) plt.xlabel('Time (ms)') plt.ylabel('Current (nA)') plt.legend()
def build_network(): global fig_num neuron_groups['e'] = b.NeuronGroup(n_e_total, neuron_eqs_e, threshold=v_thresh_e, \ refractory=refrac_e, reset=scr_e, compile=True, freeze=True) neuron_groups['i'] = b.NeuronGroup(n_e_total, neuron_eqs_i, threshold=v_thresh_i, \ refractory=refrac_i, reset=v_reset_i, compile=True, freeze=True) for name in population_names: print '...Creating neuron group:', name # get a subgroup of size 'n_e' from all exc neuron_groups[name + 'e'] = neuron_groups['e'].subgroup(conv_features * n_e) # get a subgroup of size 'n_i' from the inhibitory layer neuron_groups[name + 'i'] = neuron_groups['i'].subgroup(conv_features * n_e) # start the membrane potentials of these groups 40mV below their resting potentials neuron_groups[name + 'e'].v = v_rest_e - 40. * b.mV neuron_groups[name + 'i'].v = v_rest_i - 40. * b.mV print '...Creating recurrent connections' for name in population_names: neuron_groups['e'].theta = np.load( os.path.join(best_weights_dir, '_'.join(['theta_A', ending + '_best.npy']))) for conn_type in recurrent_conn_names: if conn_type == 'ei': # create connection name (composed of population and connection types) conn_name = name + conn_type[0] + name + conn_type[1] # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection( neuron_groups[conn_name[0:2]], neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # instantiate the created connection for feature in xrange(conv_features): for n in xrange(n_e): connections[conn_name][feature * n_e + n, feature * n_e + n] = 10.4 elif conn_type == 'ie': # create connection name (composed of population and connection types) conn_name = name + conn_type[0] + name + conn_type[1] # load weight matrix weight_matrix = np.load( os.path.join(best_weights_dir, '_'.join([conn_name, ending, 'best.npy']))) # create a connection from the first group in conn_name with the second group connections[conn_name] = b.Connection( neuron_groups[conn_name[0:2]], neuron_groups[conn_name[2:4]], structure='sparse', state='g' + conn_type[0]) # define the actual synaptic connections and strengths for feature in xrange(conv_features): for other_feature in xrange(conv_features): if feature != other_feature: for n in xrange(n_e): connections[conn_name][feature * n_e + n, other_feature * n_e + n] = inhibition_level print '...Creating monitors for:', name # spike rate monitors for excitatory and inhibitory neuron populations rate_monitors[name + 'e'] = b.PopulationRateMonitor( neuron_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second) rate_monitors[name + 'i'] = b.PopulationRateMonitor( neuron_groups[name + 'i'], bin=(single_example_time + resting_time) / b.second) spike_counters[name + 'e'] = b.SpikeCounter(neuron_groups[name + 'e']) # record neuron population spikes if specified if record_spikes and do_plot: spike_monitors[name + 'e'] = b.SpikeMonitor(neuron_groups[name + 'e']) spike_monitors[name + 'i'] = b.SpikeMonitor(neuron_groups[name + 'i']) if record_spikes and do_plot: b.figure(fig_num, figsize=(8, 6)) b.ion() b.subplot(211) b.raster_plot(spike_monitors['Ae'], refresh=1000 * b.ms, showlast=1000 * b.ms, title='Excitatory spikes per neuron') b.subplot(212) b.raster_plot(spike_monitors['Ai'], refresh=1000 * b.ms, showlast=1000 * b.ms, title='Inhibitory spikes per neuron') b.tight_layout() fig_num += 1 # creating Poission spike train from input image (784 vector, 28x28 image) for name in input_population_names: input_groups[name + 'e'] = b.PoissonGroup(n_input, 0) rate_monitors[name + 'e'] = b.PopulationRateMonitor( input_groups[name + 'e'], bin=(single_example_time + resting_time) / b.second) # creating connections from input Poisson spike train to excitatory neuron population(s) for name in input_connection_names: print '\n...Creating connections between', name[0], 'and', name[1] # for each of the input connection types (in this case, excitatory -> excitatory) for conn_type in input_conn_names: # saved connection name conn_name = name[0] + conn_type[0] + name[1] + conn_type[1] # get weight matrix depending on training or test phase weight_matrix = np.load( os.path.join(best_weights_dir, '_'.join([conn_name, ending + '_best.npy']))) # create connections from the windows of the input group to the neuron population input_connections[conn_name] = b.Connection(input_groups['Xe'], neuron_groups[name[1] + conn_type[1]], \ structure='sparse', state='g' + conn_type[0], delay=True, max_delay=delay[conn_type][1]) for feature in xrange(conv_features): for n in xrange(n_e): for idx in xrange(conv_size**2): input_connections[conn_name][convolution_locations[n][idx], feature * n_e + n] = \ weight_matrix[convolution_locations[n][idx], feature * n_e + n] if do_plot: plot_2d_input_weights() fig_num += 1 print '\n'
def plot(self, trial_duration): # Spike raster plots if self.spike_monitors is not None: figure() subplot(811) raster_plot(self.spike_monitors['left_ec'], newfigure=False) xlim(0, trial_duration / ms) ylim(0, self.brain_network.left_lip.e_contra_size) ylabel('left EC') subplot(812) raster_plot(self.spike_monitors['left_ei'], newfigure=False) xlim(0, trial_duration / ms) ylim(0, self.brain_network.left_lip.e_ipsi_size) ylabel('left EI') subplot(813) raster_plot(self.spike_monitors['left_ic'], newfigure=False) xlim(0, trial_duration / ms) ylim(0, self.brain_network.left_lip.i_contra_size) ylabel('left IC') subplot(814) raster_plot(self.spike_monitors['left_ii'], newfigure=False) xlim(0, trial_duration / ms) ylim(0, self.brain_network.left_lip.i_ipsi_size) ylabel('left II') subplot(815) raster_plot(self.spike_monitors['right_ec'], newfigure=False) xlim(0, trial_duration / ms) ylim(0, self.brain_network.right_lip.e_contra_size) ylabel('right EC') subplot(816) raster_plot(self.spike_monitors['right_ei'], newfigure=False) xlim(0, trial_duration / ms) ylim(0, self.brain_network.right_lip.e_ipsi_size) ylabel('right EI') subplot(817) raster_plot(self.spike_monitors['right_ic'], newfigure=False) xlim(0, trial_duration / ms) ylim(0, self.brain_network.right_lip.i_contra_size) ylabel('right IC') subplot(818) raster_plot(self.spike_monitors['right_ii'], newfigure=False) xlim(0, trial_duration / ms) ylim(0, self.brain_network.right_lip.i_ipsi_size) ylabel('right II') # Network firing rate plots if self.population_rate_monitors is not None: smooth_width = 10 * ms left_ec_vis_rate = self.population_rate_monitors[ 'left_ec_vis'].smooth_rate(width=smooth_width) / hertz left_ec_mem_rate = self.population_rate_monitors[ 'left_ec_mem'].smooth_rate(width=smooth_width) / hertz left_ec_rate = self.population_rate_monitors[ 'left_ec'].smooth_rate(width=smooth_width) / hertz left_ei_vis_rate = self.population_rate_monitors[ 'left_ei_vis'].smooth_rate(width=smooth_width) / hertz left_ei_mem_rate = self.population_rate_monitors[ 'left_ei_mem'].smooth_rate(width=smooth_width) / hertz left_ei_rate = self.population_rate_monitors[ 'left_ei'].smooth_rate(width=smooth_width) / hertz left_ic_rate = self.population_rate_monitors[ 'left_ic'].smooth_rate(width=smooth_width) / hertz left_ii_rate = self.population_rate_monitors[ 'left_ii'].smooth_rate(width=smooth_width) / hertz right_ec_vis_rate = self.population_rate_monitors[ 'right_ec_vis'].smooth_rate(width=smooth_width) / hertz right_ec_mem_rate = self.population_rate_monitors[ 'right_ec_mem'].smooth_rate(width=smooth_width) / hertz right_ec_rate = self.population_rate_monitors[ 'right_ec'].smooth_rate(width=smooth_width) / hertz right_ei_vis_rate = self.population_rate_monitors[ 'right_ei_vis'].smooth_rate(width=smooth_width) / hertz right_ei_mem_rate = self.population_rate_monitors[ 'right_ei_mem'].smooth_rate(width=smooth_width) / hertz right_ei_rate = self.population_rate_monitors[ 'right_ei'].smooth_rate(width=smooth_width) / hertz right_ic_rate = self.population_rate_monitors[ 'right_ic'].smooth_rate(width=smooth_width) / hertz right_ii_rate = self.population_rate_monitors[ 'right_ii'].smooth_rate(width=smooth_width) / hertz max_rate = np.max([ np.max(left_ec_vis_rate), np.max(left_ec_mem_rate), np.max(left_ec_rate), np.max(left_ei_vis_rate), np.max(left_ei_mem_rate), np.max(left_ic_rate), np.max(left_ii_rate), np.max(right_ec_vis_rate), np.max(right_ec_mem_rate), np.max(right_ec_rate), np.max(right_ei_vis_rate), np.max(right_ei_mem_rate), np.max(right_ei_rate), np.max(right_ic_rate), np.max(right_ii_rate) ]) times_ms = self.population_rate_monitors['left_ec_vis'].times / ms figure() ax = subplot(211) ax.plot(times_ms, left_ec_vis_rate, label='left LIP EC vis') ax.plot(times_ms, left_ec_mem_rate, label='left LIP EC mem') #ax.plot(times_ms, left_ec_rate, label='left LIP EC') ax.plot(times_ms, left_ei_vis_rate, label='left LIP EI vis') ax.plot(times_ms, left_ei_mem_rate, label='left LIP EI mem') #ax.plot(times_ms, left_ei_rate, label='left LIP EI') ax.plot(times_ms, left_ic_rate, label='left LIP IC') ax.plot(times_ms, left_ii_rate, label='left LIP II') ylim(0, max_rate) legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') ax = subplot(212) ax.plot(times_ms, right_ec_vis_rate, label='right LIP EC vis') ax.plot(times_ms, right_ec_mem_rate, label='right LIP EC mem') #ax.plot(times_ms, right_ec_rate, label='right LIP EC') ax.plot(times_ms, right_ei_vis_rate, label='right LIP EI vis') ax.plot(times_ms, right_ei_mem_rate, label='right LIP EI mem') #ax.plot(times_ms, right_ei_rate, label='right LIP EI') ax.plot(times_ms, right_ic_rate, label='right LIP IC') ax.plot(times_ms, right_ii_rate, label='right LIP II') ylim(0, max_rate) legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') figure() ax = subplot(211) ax.plot(times_ms, left_ec_rate, label='left LIP EC') ax.plot(times_ms, left_ei_rate, label='left LIP EI') ylim(0, max_rate) legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') ax = subplot(212) ax.plot(times_ms, right_ec_rate, label='right LIP EC') ax.plot(times_ms, right_ei_rate, label='right LIP EI') ylim(0, max_rate) legend() xlabel('Time (ms)') ylabel('Population Firing Rate (Hz)') # Input firing rate plots if self.left_background_rate_monitor is not None and self.right_background_rate_monitor is not None and\ self.left_visual_cortex_monitor is not None and self.right_visual_cortex_monitor is not None and \ self.go_input_monitor is not None: figure() max_rate = np.max([ np.max( self.left_background_rate_monitor.smooth_rate(width=5 * ms) / hertz), np.max( self.right_background_rate_monitor.smooth_rate( width=5 * ms) / hertz), np.max( self.left_visual_cortex_monitor.smooth_rate(width=5 * ms) / hertz), np.max( self.right_visual_cortex_monitor.smooth_rate(width=5 * ms) / hertz), np.max( self.go_input_monitor.smooth_rate(width=5 * ms) / hertz) ]) ax = subplot(111) ax.plot( self.left_background_rate_monitor.times / ms, self.left_background_rate_monitor.smooth_rate(width=5 * ms) / hertz, label='left background') ax.plot( self.right_background_rate_monitor.times / ms, self.right_background_rate_monitor.smooth_rate(width=5 * ms) / hertz, label='right background') ax.plot(self.left_visual_cortex_monitor.times / ms, self.left_visual_cortex_monitor.smooth_rate(width=5 * ms) / hertz, label='left VC') ax.plot( self.right_visual_cortex_monitor.times / ms, self.right_visual_cortex_monitor.smooth_rate(width=5 * ms) / hertz, label='right VC') ax.plot(self.go_input_monitor.times / ms, self.go_input_monitor.smooth_rate(width=5 * ms) / hertz, label='Go') legend() ylim(0, max_rate) # Network state plots if self.left_network_monitor is not None and self.right_network_monitor is not None: max_conductances = [] for idx in self.left_record_idx: max_conductances.append( np.max(self.left_network_monitor['g_ampa_r'][idx] / nS)) max_conductances.append( np.max(self.left_network_monitor['g_ampa_x'][idx] / nS)) max_conductances.append( np.max(self.left_network_monitor['g_ampa_b'][idx] / nS)) max_conductances.append( np.max(self.left_network_monitor['g_ampa_g'][idx] / nS)) max_conductances.append( np.max(self.left_network_monitor['g_nmda'][idx] / nS)) max_conductances.append( np.max(self.left_network_monitor['g_gaba_a'][idx] / nS)) max_conductances.append( np.max(self.left_network_monitor['g_gaba_b'][idx] / nS)) for idx in self.right_record_idx: max_conductances.append( np.max(self.right_network_monitor['g_ampa_r'][idx] / nS)) max_conductances.append( np.max(self.right_network_monitor['g_ampa_x'][idx] / nS)) max_conductances.append( np.max(self.right_network_monitor['g_ampa_b'][idx] / nS)) max_conductances.append( np.max(self.right_network_monitor['g_ampa_g'][idx] / nS)) max_conductances.append( np.max(self.right_network_monitor['g_nmda'][idx] / nS)) max_conductances.append( np.max(self.right_network_monitor['g_gaba_a'][idx] / nS)) max_conductances.append( np.max(self.right_network_monitor['g_gaba_b'][idx] / nS)) max_conductance = np.max(max_conductances) figure() labels = [ 'e_contra_vis', 'e_contra_mem', 'e_ipsi_vis', 'e_ipsi_mem', 'i_contra', 'i_ipsi' ] for i, idx in enumerate(self.left_record_idx): ax = subplot(len(self.left_record_idx), 1, i + 1) ax.plot(self.left_network_monitor['g_ampa_r'].times / ms, self.left_network_monitor['g_ampa_r'][idx] / nS, label='AMPA recurrent') ax.plot(self.left_network_monitor['g_ampa_x'].times / ms, self.left_network_monitor['g_ampa_x'][idx] / nS, label='AMPA task') ax.plot(self.left_network_monitor['g_ampa_b'].times / ms, self.left_network_monitor['g_ampa_b'][idx] / nS, label='AMPA backgrnd') ax.plot(self.left_network_monitor['g_ampa_g'].times / ms, self.left_network_monitor['g_ampa_g'][idx] / nS, label='AMPA go') ax.plot(self.left_network_monitor['g_nmda'].times / ms, self.left_network_monitor['g_nmda'][idx] / nS, label='NMDA') ax.plot(self.left_network_monitor['g_gaba_a'].times / ms, self.left_network_monitor['g_gaba_a'][idx] / nS, label='GABA_A') ax.plot(self.left_network_monitor['g_gaba_b'].times / ms, self.left_network_monitor['g_gaba_b'][idx] / nS, label='GABA_B') ylim(0, max_conductance) ylabel(labels[i]) if not i: title('Left LIP - Conductance (nS)') legend() xlabel('Time (ms)') figure() for i, idx in enumerate(self.right_record_idx): ax = subplot(len(self.right_record_idx), 1, i + 1) ax.plot(self.right_network_monitor['g_ampa_r'].times / ms, self.right_network_monitor['g_ampa_r'][idx] / nS, label='AMPA recurrent') ax.plot(self.right_network_monitor['g_ampa_x'].times / ms, self.right_network_monitor['g_ampa_x'][idx] / nS, label='AMPA task') ax.plot(self.right_network_monitor['g_ampa_b'].times / ms, self.right_network_monitor['g_ampa_b'][idx] / nS, label='AMPA backgrnd') ax.plot(self.right_network_monitor['g_ampa_g'].times / ms, self.right_network_monitor['g_ampa_g'][idx] / nS, label='AMPA go') ax.plot(self.right_network_monitor['g_nmda'].times / ms, self.right_network_monitor['g_nmda'][idx] / nS, label='NMDA') ax.plot(self.right_network_monitor['g_gaba_a'].times / ms, self.right_network_monitor['g_gaba_a'][idx] / nS, label='GABA_A') ax.plot(self.right_network_monitor['g_gaba_b'].times / ms, self.right_network_monitor['g_gaba_b'][idx] / nS, label='GABA_B') ylim(0, max_conductance) ylabel(labels[i]) if not i: title('Right LIP - Conductance (nS)') legend() xlabel('Time (ms)') min_currents = [] max_currents = [] for idx in self.left_record_idx: max_currents.append( np.max(self.left_network_monitor['I_ampa_r'][idx] / nA)) max_currents.append( np.max(self.left_network_monitor['I_ampa_x'][idx] / nA)) max_currents.append( np.max(self.left_network_monitor['I_ampa_b'][idx] / nA)) max_currents.append( np.max(self.left_network_monitor['I_ampa_g'][idx] / nA)) max_currents.append( np.max(self.left_network_monitor['I_nmda'][idx] / nA)) max_currents.append( np.max(self.left_network_monitor['I_gaba_a'][idx] / nA)) max_currents.append( np.max(self.left_network_monitor['I_gaba_b'][idx] / nA)) min_currents.append( np.min(self.left_network_monitor['I_ampa_r'][idx] / nA)) min_currents.append( np.min(self.left_network_monitor['I_ampa_x'][idx] / nA)) min_currents.append( np.min(self.left_network_monitor['I_ampa_b'][idx] / nA)) min_currents.append( np.min(self.left_network_monitor['I_ampa_g'][idx] / nA)) min_currents.append( np.min(self.left_network_monitor['I_nmda'][idx] / nA)) min_currents.append( np.min(self.left_network_monitor['I_gaba_a'][idx] / nA)) min_currents.append( np.min(self.left_network_monitor['I_gaba_b'][idx] / nA)) for idx in self.right_record_idx: max_currents.append( np.max(self.right_network_monitor['I_ampa_r'][idx] / nA)) max_currents.append( np.max(self.right_network_monitor['I_ampa_x'][idx] / nA)) max_currents.append( np.max(self.right_network_monitor['I_ampa_b'][idx] / nA)) max_currents.append( np.max(self.right_network_monitor['I_ampa_g'][idx] / nA)) max_currents.append( np.max(self.right_network_monitor['I_nmda'][idx] / nA)) max_currents.append( np.max(self.right_network_monitor['I_gaba_a'][idx] / nA)) max_currents.append( np.max(self.right_network_monitor['I_gaba_b'][idx] / nA)) min_currents.append( np.min(self.right_network_monitor['I_ampa_r'][idx] / nA)) min_currents.append( np.min(self.right_network_monitor['I_ampa_x'][idx] / nA)) min_currents.append( np.min(self.right_network_monitor['I_ampa_b'][idx] / nA)) min_currents.append( np.min(self.right_network_monitor['I_ampa_g'][idx] / nA)) min_currents.append( np.min(self.right_network_monitor['I_nmda'][idx] / nA)) min_currents.append( np.min(self.right_network_monitor['I_gaba_a'][idx] / nA)) min_currents.append( np.min(self.right_network_monitor['I_gaba_b'][idx] / nA)) max_current = np.max(max_currents) min_current = np.min(min_currents) figure() for i, neuron_idx in enumerate(self.left_record_idx): ax = subplot(len(self.left_record_idx), 1, i + 1) ax.plot(self.left_network_monitor['I_ampa_r'].times / ms, self.left_network_monitor['I_ampa_r'][neuron_idx] / nA, label='AMPA-recurrent') ax.plot(self.left_network_monitor['I_ampa_x'].times / ms, self.left_network_monitor['I_ampa_x'][neuron_idx] / nA, label='AMPA-task') ax.plot(self.left_network_monitor['I_ampa_b'].times / ms, self.left_network_monitor['I_ampa_b'][neuron_idx] / nA, label='AMPA-backgrnd') ax.plot(self.left_network_monitor['I_ampa_b'].times / ms, self.left_network_monitor['I_ampa_g'][neuron_idx] / nA, label='AMPA-go') ax.plot(self.left_network_monitor['I_nmda'].times / ms, self.left_network_monitor['I_nmda'][neuron_idx] / nA, label='NMDA') ax.plot(self.left_network_monitor['I_gaba_a'].times / ms, self.left_network_monitor['I_gaba_a'][neuron_idx] / nA, label='GABA_A') ax.plot(self.left_network_monitor['I_gaba_b'].times / ms, self.left_network_monitor['I_gaba_b'][neuron_idx] / nA, label='GABA_B') ylim(min_current, max_current) ylabel(labels[i]) if not i: title('Left LIP - Current (nA)') legend() xlabel('Time (ms)') figure() for i, neuron_idx in enumerate(self.right_record_idx): ax = subplot(len(self.right_record_idx), 1, i + 1) ax.plot(self.right_network_monitor['I_ampa_r'].times / ms, self.right_network_monitor['I_ampa_r'][neuron_idx] / nA, label='AMPA-recurrent') ax.plot(self.right_network_monitor['I_ampa_x'].times / ms, self.right_network_monitor['I_ampa_x'][neuron_idx] / nA, label='AMPA-task') ax.plot(self.right_network_monitor['I_ampa_b'].times / ms, self.right_network_monitor['I_ampa_b'][neuron_idx] / nA, label='AMPA-backgrnd') ax.plot(self.right_network_monitor['I_ampa_b'].times / ms, self.right_network_monitor['I_ampa_g'][neuron_idx] / nA, label='AMPA-go') ax.plot(self.right_network_monitor['I_nmda'].times / ms, self.right_network_monitor['I_nmda'][neuron_idx] / nA, label='NMDA') ax.plot(self.right_network_monitor['I_gaba_a'].times / ms, self.right_network_monitor['I_gaba_a'][neuron_idx] / nA, label='GABA_A') ax.plot(self.right_network_monitor['I_gaba_b'].times / ms, self.right_network_monitor['I_gaba_b'][neuron_idx] / nA, label='GABA_B') ylim(min_current, max_current) ylabel(labels[i]) if not i: title('Right LIP - Current (nA)') legend() xlabel('Time (ms)') # LFP plot if self.left_lfp_monitor is not None and self.right_lfp_monitor is not None: figure() ax = subplot(111) ax.plot(self.left_lfp_monitor.times / ms, self.left_lfp_monitor[0] / mA, label='left LIP') ax.plot(self.right_lfp_monitor.times / ms, self.right_lfp_monitor[0] / mA, label='right LIP') legend() xlabel('Time (ms)') ylabel('LFP (mA)') # Voxel activity plots if self.left_voxel_monitor is not None and self.right_voxel_monitor is not None: syn_max = np.max([ np.max(self.left_voxel_monitor['G_total'][0] / nS), np.max(self.right_voxel_monitor['G_total'][0] / nS) ]) y_max = np.max([ np.max(self.left_voxel_monitor['y'][0]), np.max(self.right_voxel_monitor['y'][0]) ]) y_min = np.min([ np.min(self.left_voxel_monitor['y'][0]), np.min(self.right_voxel_monitor['y'][0]) ]) figure() if self.left_voxel_exc_monitor is None and self.right_voxel_exc_monitor is None: ax = subplot(211) else: ax = subplot(221) syn_max = np.max([ syn_max, np.max(self.left_voxel_exc_monitor['G_total'][0]), np.max(self.right_voxel_exc_monitor['G_total'][0]) ]) y_max = np.max([ y_max, np.max(self.left_voxel_exc_monitor['y'][0]), np.max(self.right_voxel_exc_monitor['y'][0]) ]) y_min = np.min([ y_min, np.min(self.left_voxel_exc_monitor['y'][0]), np.min(self.right_voxel_exc_monitor['y'][0]) ]) ax.plot(self.left_voxel_monitor['G_total'].times / ms, self.left_voxel_monitor['G_total'][0] / nS, label='left LIP') ax.plot(self.right_voxel_monitor['G_total'].times / ms, self.right_voxel_monitor['G_total'][0] / nS, label='right LIP') legend() xlabel('Time (ms)') ylabel('Total Synaptic Activity (nS)') ylim(0, syn_max) if self.left_voxel_exc_monitor is None and self.right_voxel_exc_monitor is None: ax = subplot(212) else: ax = subplot(222) ax.plot(self.left_voxel_monitor['y'].times / ms, self.left_voxel_monitor['y'][0], label='left LIP') ax.plot(self.right_voxel_monitor['y'].times / ms, self.right_voxel_monitor['y'][0], label='right LIP') legend() xlabel('Time (ms)') ylabel('BOLD') ylim(y_min, y_max * 2.0) if self.left_voxel_exc_monitor is not None and self.right_voxel_exc_monitor is not None: ax = subplot(223) ax.plot(self.left_voxel_exc_monitor['G_total'].times / ms, self.left_voxel_exc_monitor['G_total'][0] / nS, label='left LIP') ax.plot(self.right_voxel_exc_monitor['G_total'].times / ms, self.right_voxel_exc_monitor['G_total'][0] / nS, label='right LIP') legend() xlabel('Time (ms)') ylabel('Total Synaptic Activity (nS)') ylim(0, syn_max) ax = subplot(224) ax.plot(self.left_voxel_exc_monitor['y'].times / ms, self.left_voxel_exc_monitor['y'][0], label='left LIP') ax.plot(self.right_voxel_exc_monitor['y'].times / ms, self.right_voxel_exc_monitor['y'][0], label='right LIP') legend() xlabel('Time (ms)') ylabel('BOLD') ylim(y_min, y_max) show()