postStd, sim.OneToOneConnector(), sim.StaticSynapse(weight=-5.0), receptor_type='inhibitory', label='inh_proj', ) sProj = sim.Projection( preInh, postShunt, sim.OneToOneConnector(), sim.StaticSynapse(weight=-5.0), receptor_type='inhShunt', label='shunt_proj', ) sim.run(runtime) data_exc = preExc.get_data().segments[0] data_inh = preInh.get_data().segments[0] data_std = postStd.get_data().segments[0] data_shunt = postShunt.get_data().segments[0] sim.end() figsize = (15, 5) plot_data(data_exc, data_inh, data_shunt, title='shunt', figsize=figsize) plt.tight_layout() plot_data(data_exc, data_inh, data_std, title='standard', figsize=figsize) plt.tight_layout() plt.show()
label='pre') params['tau_syn_E'] = 5. post = sim.Population(n_neurons, sim.IF_curr_exp, params, label='post') post.record('spikes') dist_params = {'low': 0.0, 'high': 10.0} dist = 'uniform' rand_dist = RandomDistribution(dist, rng=rng, **dist_params) var = 'weight' on_device_init = bool(1) conn = sim.AllToAllConnector() syn = sim.StaticSynapse(weight=5./n_neurons, delay=1)#rand_dist) proj = sim.Projection(pre, post, conn, synapse_type=syn, use_procedural=bool(0)) sim.run(2 * n_neurons) data = post.get_data() spikes = np.asarray(data.segments[0].spiketrains) sim.end() all_at_appr_time = 0 sum_spikes = 0 for i, times in enumerate(spikes): sum_spikes += len(times) if int(times[0]) == 9: all_at_appr_time += 1 assert sum_spikes == n_neurons assert all_at_appr_time == n_neurons #each neuron spikes once because
params = copy.copy(sim.IF_curr_exp.default_parameters) pre = sim.Population(n_pre, sim.IF_curr_exp, params, label='pre') post = sim.Population(n_post, sim.IF_curr_exp, params, label='post') dist_params = {'low': 0.0, 'high': 10.0} dist = 'uniform' rand_dist = RandomDistribution(dist, rng=rng, **dist_params) var = 'weight' on_device_init = bool(1) p_conn = 0.3 n = 30 #int(n_post * p_conn) conn = sim.FixedNumberPostConnector(n, rng=rng, with_replacement=True) syn = sim.StaticSynapse(weight=rand_dist, delay=1) #rand_dist) proj = sim.Projection(pre, post, conn, synapse_type=syn) sim.run(10) comp_var = np.asarray(proj.getWeights(format='array')) shape = np.copy(comp_var.shape) n_cols = [] for r in comp_var: n_cols.append(len(np.where(~np.isnan(r))[0])) connected = np.where(~np.isnan(comp_var)) comp_var = comp_var[connected] num_active = comp_var.size sim.end() abs_diff = np.abs(n - np.mean(n_cols)) print("abs({} - {}) = {}".format(n, np.mean(n_cols), abs_diff))
inh_cells.record('spikes') #exc_cells[0, 1].record('v') buildCPUTime = timer.diff() # === Save connections to file ================================================= #for prj in connections.keys(): #connections[prj].saveConnections('Results/VAbenchmark_%s_%s_%s_np%d.conn' % (benchmark, prj, options.simulator, np)) saveCPUTime = timer.diff() # === Run simulation =========================================================== print("%d Running simulation..." % node_id) sim.run(tstop) simCPUTime = timer.diff() #------------------------------------------------------------------------------ # Plot output #------------------------------------------------------------------------------ def plot_spiketrains(axis, segment, offset, **kwargs): for spiketrain in segment.spiketrains: y = numpy.ones_like(spiketrain) * ( offset + spiketrain.annotations["source_index"]) axis.scatter(spiketrain, y, **kwargs) def calculate_rate(segment, rate_bins, population_size):
n_spikes = int(np.random.choice(spikes_per_neuron)) spikes = np.round(np.random.choice(max_t, size=n_spikes, replace=False)).tolist() spikes[:] = sorted(spikes) spike_times.append(sorted(spikes)) sources[ssa_id]['times'] = spike_times ssa = sim.Population(n_neurons[ssa_id], sim.SpikeSourceArray(spike_times=spike_times), label='ssa %d' % ssa_id) ssa.record(['spikes']) sources[ssa_id]['pop'] = ssa sim.run(int(1.5 * max_t)) for ssa_id in range(n_ssa): data = sources[ssa_id]['pop'].get_data() sources[ssa_id]['spikes'] = spikes_from_data(data) sources[ssa_id]['data'] = data sim.end() for ssa_id in range(n_ssa): plt.figure() for nid in range(n_neurons[ssa_id]): in_spikes = sources[ssa_id]['times'] out_spikes = sources[ssa_id]['spikes'] plt.plot(in_spikes[nid],
# Clear simulation state sim.setup(min_delay=1.0, max_delay=7.0, timestep=1.0) # Build inhibitory plasticity model stdp_model = sim.STDPMechanism( timing_dependence=sim.Vogels2011Rule(rho=0.12, tau=20.0, eta=0.005), weight_dependence=sim.AdditiveWeightDependence(w_min=-1.0, w_max=0.0), weight=0.0, delay=1.0, ) # Build plastic network plastic_ex_pop, plastic_ie_projection = build_network(stdp_model, 10.0) # Run simulation sim.run(10000) # Get plastic spikes and save to disk plastic_data = plastic_ex_pop.get_data() plastic_weights = plastic_ie_projection.get("weight", format="list", with_address=False) mean_weight = numpy.average(plastic_weights) print "Mean learnt ie weight:%f" % mean_weight def plot_spiketrains(axis, segment, offset, **kwargs): for spiketrain in segment.spiketrains: y = numpy.ones_like(spiketrain) * ( offset + spiketrain.annotations["source_index"])
sim.setup(timestep=timestep, min_delay=timestep, backend='SingleThreadedCPU') post = sim.Population(n_neurons, neuron_class(**base_params)) post.record('spikes') post.record('v_thresh_adapt') post.record('v') pre = sim.Population( n_neurons, sim.SpikeSourceArray(spike_times=[[10] for _ in range(n_neurons)]), ) proj = sim.Projection(pre, post, sim.OneToOneConnector(), sim.StaticSynapse(weight=3.2)) sim.run(sim_time) data = post.get_data() sim.end() vthresh = data.segments[0].filter(name='v_thresh_adapt') v = data.segments[0].filter(name='v') np.savez_compressed("genn_spiking_behaviour.npz", spikes=data.segments[0]) plt.figure() ax = plt.subplot() plt.plot(v[0]) plt.plot(vthresh[0]) # plot_spiketrains(data.segments[0])
pylab.rc("text", usetex=True) labels = [ "Regular spiking", "Fast spiking", "Chattering", "Intrinsically bursting" ] a = [0.02, 0.1, 0.02, 0.02] b = [0.2, 0.2, 0.2, 0.2] c = [-65.0, -65.0, -50.0, -55.0] d = [8.0, 2.0, 2.0, 4.0] sim.setup(timestep=0.1, min_delay=0.1, max_delay=4.0) ifcell = sim.Population(len(labels), sim.Izhikevich(i_offset=0.01, a=a, b=b, c=c, d=d)) ifcell.record("v") sim.run(200.0) data = ifcell.get_data() sim.end() figure, axes = pylab.subplots(2, 2, sharex="col", sharey="row") axes[0, 0].set_ylabel("Membrane potential [mV]") axes[1, 0].set_ylabel("Membrane potential [mV]") axes[1, 0].set_xlabel("Time [ms]") axes[1, 1].set_xlabel("Time [ms]") signal = data.segments[0].analogsignals[0] for i, l in enumerate(labels): axis = axes[i // 2, i % 2]
sim.DCSource(amplitude=1.0, start=segmentationSignalStart, stop=simTime)) if len(surfaceOnTarget) > 0: SurfaceSegmentationOn[surfaceOnTarget].inject( sim.DCSource(amplitude=1.0, start=segmentationSignalStart, stop=simTime)) if len(boundaryOnTarget) > 0: BoundarySegmentationOn[boundaryOnTarget].inject( sim.DCSource(amplitude=1.0, start=segmentationSignalStart, stop=simTime)) # Actual run of the network, using the input and the segmentation signals sim.run(stepDuration) # To store results for later plotting plotDensityLGNBright = [[0 for j in range(ImageNumPixelColumns)] for i in range(ImageNumPixelRows)] plotDensityLGNDark = [[0 for j in range(ImageNumPixelColumns)] for i in range(ImageNumPixelRows)] plotDensityOrientationV1 = [[[0 for j in range(numPixelColumns)] for i in range(numPixelRows)] for k in range(numOrientations)] plotDensityOrientationV2 = [[[[0 for j in range(numPixelColumns)] for i in range(numPixelRows)] for h in range(numSegmentationLayers)] for k in range(numOrientations)] plotDensityBrightnessV4 = [[[0 for j in range(ImageNumPixelColumns)] for i in range(ImageNumPixelRows)]
'start': 20.0, 'stop': t_stop - 20.0, 'amplitude': 0.6 } } neurons = sim.Population(4, sim.GIF_cond_exp(**parameters['neurons'])) electrode = sim.DCSource(**parameters['stimulus']) electrode.inject_into(neurons) neurons.record(['v']) #, 'i_eta', 'v_t']) # === Run the simulation ===================================================== sim.run(t_stop) data = neurons.get_data().segments[0] v = data.filter(name="v")[0] #v_t = data.filter(name="v_t")[0] #i_eta = data.filter(name="i_eta")[0] Figure( Panel(v, ylabel="Membrane potential (mV)", yticks=True, ylim=[-66, -52]), #Panel(v_t, ylabel="Threshold (mV)", # yticks=True), #Panel(i_eta, ylabel="i_eta (nA)", xticks=True, # xlabel="Time (ms)", yticks=True), ) plt.show()
def run(self, params): self._do_record = True self._network = {} self._network['timestep'] = 0.1 #ms self._network['min_delay'] = 0.1 #ms self._network['run_time'] = 1000 sim.setup(self._network['timestep'], model_name=self.name, backend='CUDA') # Neuron populations pops = {} pops['input'] = self.gen_input_pop() pops['output'] = self.gen_output_pop() self._network['populations'] = pops # Projections projs = {} projs['inupt to output'] = self.gen_input_to_output_proj() self._network['projections'] = projs # Run log.info('Running sim for {}ms.'.format(self._network['run_time'])) sim.run(self._network['run_time']) # Collect data if self._do_record: log.info('Collect data from all populations:') for popname, pop in pops.items(): log.info(' -> Saving recorded data for "{}".'.format(popname)) # Voltages voltagedata = pop.get_data('v') signal = voltagedata.segments[0].analogsignals[0] source_ids = signal.annotations['source_ids'] for idx in range(len(source_ids)): s_id = source_ids[idx] filename = "%s_%s_%s.dat" % ( pop.label, pop.id_to_index(s_id), signal.name) vm = signal.transpose()[idx] tt = np.array([ t * sim.get_time_step() / 1000. for t in range(len(vm)) ]) times_vm = np.array([tt, vm / 1000.]).transpose() np.savetxt(filename, times_vm, delimiter='\t', fmt='%s') # Spikes log.info(pop) spikedata = pop.get_data('spikes') filename = '{}.spikes'.format(pop.label) thefile = open(filename, 'w') for spiketrain in spikedata.segments[0].spiketrains: source_id = spiketrain.annotations['source_id'] source_index = spiketrain.annotations['source_index'] # #log.info(pp.pprint(vars(spiketrain))) for t in spiketrain: thefile.write('%s\t%f\n' % (source_index, t.magnitude / 1000.)) thefile.close() # End sim.end()
sim.setup(**simulator_params[simulator]) import network # create network start_netw = time.time() n = network.Network(sim) n.setup(sim) end_netw = time.time() if sim.rank() == 0 : print('Creating the network took %g s' % (end_netw - start_netw,)) # simulate if sim.rank() == 0 : print("Simulating...") start_sim = time.time() t = sim.run(simulator_params[simulator]['sim_duration']) end_sim = time.time() if sim.rank() == 0 : print('Simulation took %g s' % (end_sim - start_sim,)) start_writing = time.time() for layer in n.pops : for pop in n.pops[layer] : io = PyNNTextIO(filename=system_params['output_path'] \ + "/spikes_" + layer + '_' + pop + '_' + str(sim.rank()) + ".txt") spikes = n.pops[layer][pop].get_data('spikes', gather=False) for segment in spikes.segments : io.write_segment(segment) if record_v : io = PyNNTextIO(filename=system_params['output_path'] \
stop=450.0, amplitude=0.2, offset=0.1, frequency=10.0, phase=180.0), sim.NoisyCurrentSource(mean=0.5, stdev=0.2, start=50.0, stop=450.0, dt=1.0) ] for cell, current_source in zip(cells, current_sources): cell.inject(current_source) cells.record('v') # === Run the simulation ===================================================== sim.run(500.0) # === Save the results, optionally plot a figure ============================= vm = cells.get_data().segments[0].filter(name="v")[0] sim.end() from pyNN.utility.plotting import Figure, Panel from quantities import mV Figure(Panel(vm, y_offset=-10 * mV, xticks=True, yticks=True, xlabel="Time (ms)", ylabel="Membrane potential (mV)", ylim=(-96, -59)),
sim.EIF_cond_exp_isfa_ista(i_offset=1.0), label="EIF_cond_exp_isfa_ista") adapt = sim.Population(1, sim.IF_cond_exp_gsfa_grr(i_offset=2.0), label="IF_cond_exp_gsfa_grr") izh = sim.Population(1, sim.Izhikevich(i_offset=0.01), label="Izhikevich") all_neurons = cuba_exp + hh + adexp + adapt + izh all_neurons.record('v') adexp.record('w') izh.record('u') # === Run the simulation ===================================================== sim.run(100.0) # === Save the results, optionally plot a figure ============================= from pyNN.utility.plotting import Figure, Panel Figure( Panel(cuba_exp.get_data().segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[cuba_exp.label], yticks=True, ylim=(-66, -48)), Panel(hh.get_data().segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[hh.label], yticks=True, ylim=(-100, 60)),