def create_empty_spike_source_layer_with_shape(shape): """ Creates a spike source layer with the given shape and its firing rates set to zero. This is also a helper function of create_spike_source_layer_from(). """ spike_source_layer = sim.Population( size=shape[0] * shape[1], cellclass=sim.SpikeSourcePoisson(rate=0)) return Layer(spike_source_layer, shape)
def test_nest_dense_shape(): p1 = pynn.Population(12, pynn.SpikeSourcePoisson(rate = 10)) p2 = pynn.Population(10, pynn.IF_cond_exp()) d = v.Dense(p1, p2, v.ReLU(), weights = 1) pynn.run(1000) d.store_spikes() assert d.input.shape == (12,) assert d.output.shape[0] == 10
def test_nest_dense_increased_weight_fire(): p1 = pynn.Population(1, pynn.SpikeSourcePoisson(rate = 1)) p2 = pynn.Population(1, pynn.IF_cond_exp()) p2.record('spikes') d = v.Dense(p1, p2, v.ReLU(), weights = 2) pynn.run(1000) spiketrains = p2.get_data().segments[-1].spiketrains count1 = spiketrains[0].size pynn.reset() p1 = pynn.Population(1, pynn.SpikeSourcePoisson(rate = 1)) p2 = pynn.Population(1, pynn.IF_cond_exp()) p2.record('spikes') d = v.Dense(p1, p2, v.ReLU(), weights = 2) pynn.run(1000) spiketrains = p2.get_data().segments[-1].spiketrains count2 = spiketrains[0].size assert count2 >= count1 * 2
def test_nest_dense_chain(): p1 = pynn.Population(12, pynn.SpikeSourcePoisson(rate = 100)) p2 = pynn.Population(10, pynn.IF_cond_exp()) p3 = pynn.Population(2, pynn.IF_cond_exp()) p3.record('spikes') d1 = v.Dense(p1, p2, v.ReLU()) d2 = v.Dense(p2, p3, v.ReLU()) pynn.run(1000) assert len(p3.get_data().segments[-1].spiketrains) > 0
def test_ticket244(): nest = pyNN.nest nest.setup(threads=4) p1 = nest.Population(4, nest.IF_curr_exp()) p1.record('spikes') poisson_generator = nest.Population(3, nest.SpikeSourcePoisson(rate=1000.0)) conn = nest.OneToOneConnector() syn = nest.StaticSynapse(weight=1.0) nest.Projection(poisson_generator, p1.sample(3), conn, syn, receptor_type="excitatory") nest.run(15) p1.get_data()
def test_nest_dense_projection(): p1 = pynn.Population(12, pynn.SpikeSourcePoisson(rate = 10)) p2 = pynn.Population(10, pynn.IF_cond_exp()) p2.record('spikes') d = v.Dense(p1, p2, v.ReLU(), weights = 1) pynn.run(1000) spiketrains = p2.get_data().segments[-1].spiketrains assert len(spiketrains) == 10 avg_len = np.array(list(map(len, spiketrains))).mean() # Should have equal activation for train in spiketrains: assert abs(len(train) - avg_len) <= 1
def presentStimuli(pres_duration, num_pres_per_stim, num_source, num_target, bright_on_weights, bright_off_weights, bright_lat_weights, dark_on_weights, dark_off_weights, dark_lat_weights, is_repeated=False): """ For presenting a stimulus to the target network. Callback is used to switch between presentation rates. Arguments: num_source num_target num_pres_per_stim, pres_duration """ num_stim = 2 # two stimuli 'bright' and 'dark' total_duration = num_stim * num_pres_per_stim * pres_duration source_on_pop = pynn.Population(num_source, pynn.SpikeSourcePoisson(), label='source_on_pop') source_off_pop = pynn.Population(num_source, pynn.SpikeSourcePoisson(), label='source_off_pop') is_bright, random_on_rates, random_off_rates = getPresentationRatesForCallback(num_stim, num_source, num_pres_per_stim, is_repeated=is_repeated) bright_target_pop = pynn.Population(num_target, pynn.IF_cond_exp, {'i_offset':0.11, 'tau_refrac':3.0, 'v_thresh':-51.0}, label='target_pop') dark_target_pop = pynn.Population(num_target, pynn.IF_cond_exp, {'i_offset':0.11, 'tau_refrac':3.0, 'v_thresh':-51.0}, label='target_pop') bright_on_conn = pynn.Projection(source_on_pop, bright_target_pop, connector=pynn.AllToAllConnector(), synapse_type=pynn.StaticSynapse(weight=bright_on_weights), receptor_type='excitatory') bright_off_conn = pynn.Projection(source_off_pop, bright_target_pop, connector=pynn.AllToAllConnector(), synapse_type=pynn.StaticSynapse(weight=bright_off_weights), receptor_type='excitatory') bright_lat_conn = pynn.Projection(bright_target_pop, bright_target_pop, connector=pynn.AllToAllConnector(), synapse_type=pynn.StaticSynapse(weight=bright_lat_weights), receptor_type='inhibitory') dark_on_conn = pynn.Projection(source_on_pop, dark_target_pop, connector=pynn.AllToAllConnector(), synapse_type=pynn.StaticSynapse(weight=dark_on_weights), receptor_type='excitatory') dark_off_conn = pynn.Projection(source_off_pop, dark_target_pop, connector=pynn.AllToAllConnector(), synapse_type=pynn.StaticSynapse(weight=dark_off_weights), receptor_type='excitatory') dark_lat_conn = pynn.Projection(dark_target_pop, dark_target_pop, connector=pynn.AllToAllConnector(), synapse_type=pynn.StaticSynapse(weight=dark_lat_weights), receptor_type='inhibitory') source_on_pop.record('spikes') source_off_pop.record('spikes') bright_target_pop.record(['spikes']) dark_target_pop.record(['spikes']) pynn.run(total_duration, callbacks=[PoissonWeightVariation(source_on_pop, random_on_rates, pres_duration), PoissonWeightVariation(source_off_pop, random_off_rates, pres_duration)]) pynn.end() source_on_spikes = source_on_pop.get_data('spikes').segments[0].spiketrains source_off_spikes = source_off_pop.get_data('spikes').segments[0].spiketrains bright_spikes = bright_target_pop.get_data('spikes').segments[0].spiketrains dark_spikes = dark_target_pop.get_data('spikes').segments[0].spiketrains return is_bright, source_on_spikes, source_off_spikes, bright_spikes, dark_spikes
def test_native_stdp_model(): nest = pyNN.nest from pyNN.utility import init_logging init_logging(logfile=None, debug=True) nest.setup() p1 = nest.Population(10, nest.IF_cond_exp()) p2 = nest.Population(10, nest.SpikeSourcePoisson()) stdp_params = {'Wmax': 50.0, 'lambda': 0.015, 'weight': 0.001} stdp = nest.native_synapse_type("stdp_synapse")(**stdp_params) connector = nest.AllToAllConnector() prj = nest.Projection(p2, p1, connector, receptor_type='excitatory', synapse_type=stdp)
Neurons_RS, sim.FixedProbabilityConnector( 0.05, allow_self_connections=False), receptor_type='inhibitory', synapse_type=sim.StaticSynapse(weight=0.005)) # inh_inh inh_inh = sim.Projection(Neurons_FS, Neurons_FS, sim.FixedProbabilityConnector( 0.05, allow_self_connections=False), receptor_type='inhibitory', synapse_type=sim.StaticSynapse(weight=0.005)) ##FEEDFORWARD CONNECTIONS # feedforward input on INH pop input_exc = sim.Population(N_exc, sim.SpikeSourcePoisson(rate=0)) fdfrwd_to_exc = sim.Projection( input_exc, Neurons_RS, sim.FixedProbabilityConnector(0.05, allow_self_connections=False), synapse_type=sim.StaticSynapse(weight=0.001)) # feedforward input on EXC pop fdfrwd_to_inh = sim.Projection( input_exc, Neurons_FS, sim.FixedProbabilityConnector(0.05, allow_self_connections=False), synapse_type=sim.StaticSynapse(weight=0.001)) #To calcul the firing rate def rate(segment, bin_size): if segment == []:
# Take the neuron layers that need to be updated online or that we want to take records of LGNBright = network.get_population("LGNBright") LGNDark = network.get_population("LGNDark") V1 = network.get_population("V1LayerToPlot") V2 = network.get_population("V2LayerToPlot") V4Bright = network.get_population("V4Brightness") V4Dark = network.get_population("V4Darkness") LGNBright.record("spikes") LGNDark.record("spikes") V1.record("spikes") V2.record("spikes") V4Bright.record("spikes") V4Dark.record("spikes") if inputPoisson: LGNBrightInput = sim.Population(ImageNumPixelRows * ImageNumPixelColumns, sim.SpikeSourcePoisson()) LGNDarkInput = sim.Population(ImageNumPixelRows * ImageNumPixelColumns, sim.SpikeSourcePoisson()) sim.Projection(LGNBrightInput, LGNBright, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['brightInputToLGN'])) sim.Projection(LGNDarkInput, LGNDark, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['darkInputToLGN'])) if numSegmentationLayers > 1: if useSurfaceSegmentation: SurfaceSegmentationOff = network.get_population( "SurfaceSegmentationOff") SurfaceSegmentationOn = network.get_population("SurfaceSegmentationOn") if useBoundarySegmentation: BoundarySegmentationOff = network.get_population( "BoundarySegmentationOff") BoundarySegmentationOn = network.get_population(
from scipy import signal from common import (spike_mean_rate, generate_labeledImages, print_mean_spike_rate, compute_weights) from common import param # All-to-all connections between input and reservoir # Uniform weights between input and reservoir # Unifrom weights inside reservoir # Uniform reservoir (all excitatory neurons) p.setup(timestep=param.dt) ###### Neurons ####### input_neurons = p.Population(param.input_nr, p.SpikeSourcePoisson()) readout_neurons = p.Population(param.readout_nr, p.IF_curr_exp, {}, label="readout") reservoir = p.Population(param.reservoir_nr, p.IF_curr_exp, {}, label="reservoir") ###################### ###### Synapses ####### stat_syn_res = p.StaticSynapse(weight=5.0, delay=1) stat_syn_input = p.StaticSynapse(weight=50.0, delay=1) stat_syn_rout = p.StaticSynapse(weight=0.0, delay=1)
import pyNN.nest as sim # can of course replace `neuron` with `nest`, `brian`, etc. import matplotlib.pyplot as plt import numpy as np sim.setup(timestep=0.01) p_in = sim.Population(10, sim.SpikeSourcePoisson(rate=10.0), label="input") p_out = sim.Population(10, sim.EIF_cond_exp_isfa_ista(), label="AdExp neurons") syn = sim.StaticSynapse(weight=0.05) random = sim.FixedProbabilityConnector(p_connect=0.5) connections = sim.Projection(p_in, p_out, random, syn, receptor_type='excitatory') p_in.record('spikes') p_out.record('spikes') # record spikes from all neurons p_out[0:2].record(['v', 'w', 'gsyn_exc' ]) # record other variables from first two neurons sim.run(500.0) spikes_in = p_in.get_data() print("spikes_in : ", type(spikes_in)) print("spikes_in.segments[0].spiketrains[0]", spikes_in.segments[0].spiketrains[0]) #print("spikes_in.segments[-1].spiketrains",spikes_in.segments[-1].spiketrains) spike_result = p_in.getSpikes(compatible_output=True)
import pyNN.nest as sim import numpy import nest __population_views = {} pop1 = sim.Population(10, sim.IF_cond_alpha()) __population_views['pop1'] = pop1 source = sim.Population(1, sim.SpikeSourcePoisson(rate=1000000.0)) nest_source = nest.Create('poisson_generator') nest.SetStatus(nest_source, {'rate': 100000.0}) nest.Connect(nest_source, map(int, pop1.all_cells), 'all_to_all') print "Network loaded"
'v_reset': 0, 'v_rest': 0, 'i_offset': 0, 'cm': 1, 'tau_m': 1000, 'tau_refrac': 0.001, 'tau_syn_E': 0.01, 'tau_syn_I': 0.01 } simparams = {'duration': 10, 'dt': 1, 'delay': 1, 'input_rate': 0} sim.setup(simparams['dt']) inp = sim.Population( 1, sim.SpikeSourcePoisson(duration=simparams['duration'], rate=simparams['input_rate'])) inp.label = 'input cell' outp = sim.Population(1, sim.IF_curr_exp, cellparams=cellparams) outp.label = 'output cell' inp.record('spikes') outp.record(['v', 'spikes']) synapse = sim.StaticSynapse(weight=1, delay=simparams['delay']) connector = sim.OneToOneConnector() connection = sim.Projection(inp, outp, connector, synapse) def report_time(t):
from pyNN.parameters import Sequence from pyNN.random import RandomDistribution as rnd import matplotlib.pyplot as plt plt.interactive(False) sim.setup(0.1) neurons = sim.Population(64, sim.IF_curr_exp, {}, label="neurons") print(neurons.celltype.recordable) params = { 'rate': 10000.0, # Mean spike frequency (Hz) 'start': 0.0, # Start time (ms) 'duration': 1e10 # Duration of spike sequence (ms) } input = sim.Population(64, sim.SpikeSourcePoisson(**params), label="input") input_proj = sim.Projection( input, neurons, sim.OneToOneConnector(), receptor_type='excitatory' ) ##https://github.com/NeuralEnsemble/PyNN/issues/273 def twoDto1D(x): return (8 * x[0] + x[1]) def oneDto2D(n): return np.array([int(n / 8.), int(n - 8 * (int(n / 8.)))]) def plot_spiketrains(segment):
structure=excitatory_structure, label='Excitatory layer') cortical_neurons_inh = simulator.Population(Ncell_inh**2, inhibitory_cell, structure=inhibitory_structure, label='Inhibitory layer') ############################# # Add background noise ############################# correlated = False noise_rate = 5800 # Hz g_noise = 0.00089 * 0 # Microsiemens (0.89 Nanosiemens) noise_delay = 1 # ms noise_model = simulator.SpikeSourcePoisson(rate=noise_rate) noise_syn = simulator.StaticSynapse(weight=g_noise, delay=noise_delay) if correlated: # If correlated is True all the cortical neurons receive noise from the same cell. noise_population = simulator.Population(1, noise_model, label='Background Noise') background_noise_to_exc = simulator.Projection( noise_population, cortical_neurons_exc, simulator.AllToAllConnector(), noise_syn) background_noise_to_inh = simulator.Projection( noise_population, cortical_neurons_inh, simulator.AllToAllConnector(), noise_syn) else: # If correlated is False, all cortical neurons receive independent noise
parser.add_argument('-t', '--duration', help='duration of simulation.', default=500.0, type=float) parser.add_argument('-s', '--stdp', help='use STDP', default=False, action='store_true') parser.add_argument('-a', '--record_target_spikes', help='Record the target spikes.', default=False, action='store_true') parser.add_argument('-m', '--make_plots', help='make the plots, or not.', default=False, action='store_true') parser.add_argument('-d', '--debug', help='enter debug mode', default=False, action='store_true') args = parser.parse_args() pynn.setup(timestep=0.1, min_delay=2.0) if not args.debug: # define target cell target_cell = pynn.create(pynn.IF_cond_exp, {'i_offset':0.11, 'tau_refrac':3.0, 'v_thresh':-51.0}) # define inhibitory and excitatory populations inhib_rates, excit_rates = getRatesForInhibExcit(args.inhib_rates_lower, args.excit_rates_lower, args.num_inhib, args.num_excit) inhib_source = pynn.Population(args.num_inhib, pynn.SpikeSourcePoisson(rate=inhib_rates), label="inhib_input") excit_source = pynn.Population(args.num_excit, pynn.SpikeSourcePoisson(rate=excit_rates), label="excit_input") # define stdp rules, parameters could be messed around with here. stdp = pynn.STDPMechanism(weight=0.02, # this is the initial value of the weight timing_dependence=pynn.SpikePairRule(tau_plus=20.0, tau_minus=20.0, A_plus=0.01, A_minus=0.012), weight_dependence=pynn.AdditiveWeightDependence(w_min=0, w_max=0.04)) synapse_to_use = stdp if args.stdp else pynn.StaticSynapse(weight=0.02) # connect inhibitory and excitatory sources to target. Could connect inhib to excit? inhib_conn = pynn.Projection(inhib_source, target_cell, connector=pynn.AllToAllConnector(), synapse_type=synapse_to_use, receptor_type='inhibitory') excit_conn = pynn.Projection(excit_source, target_cell, connector=pynn.AllToAllConnector(), synapse_type=synapse_to_use, receptor_type='excitatory') # tell the sim what to record target_cell.record(['spikes', 'v', 'gsyn_exc', 'gsyn_inh']) if args.record_target_spikes else target_cell.record(['v', 'gsyn_exc', 'gsyn_inh']) inhib_source.record('spikes')
def runSimGivenStim(stim_type, num_source, num_target, duration, use_stdp, record_source_spikes, source_rates_params, synapse_to_use, ff_conn, lat_conn): """ For running the simulation and returning the required results. Arguments: stim_type, 'bright' or 'dark' num_source, number of cells in the source layers num_target, number of cells in the target layer duration, float use_stdp, record_source_spikes, source_rates_params, params for 8 Gamma distributions synapse_to_use, either STDPMechanism or StaticSynapse ff_conn, either AllToAllConnector or FixedProbabilityConnector lat_conn, same as ff_conn but with a different probability, maybe Returns: target_spikes, ff_on_weights, ff_off_weights, lat_weights, ff_on_weights_over_time, ff_off_weights_over_time, lat_weights_over_time """ on_rates, off_rates = getOnOffSourceRates( num_source, stim_type, on_bright_params=args.source_rates_params[0], on_dark_params=args.source_rates_params[1], off_bright_params=args.source_rates_params[2], off_dark_params=args.source_rates_params[3]) source_on_pop = pynn.Population(num_source, pynn.SpikeSourcePoisson(rate=on_rates), label='source_on_pop') source_off_pop = pynn.Population(num_source, pynn.SpikeSourcePoisson(rate=off_rates), label='source_off_pop') target_pop = pynn.Population(num_target, pynn.IF_cond_exp, { 'i_offset': 0.11, 'tau_refrac': 3.0, 'v_thresh': -51.0 }, label='target_pop') ff_on_proj = pynn.Projection(source_on_pop, target_pop, connector=ff_conn, synapse_type=synapse_to_use, receptor_type='excitatory') ff_off_proj = pynn.Projection(source_off_pop, target_pop, connector=ff_conn, synapse_type=synapse_to_use, receptor_type='excitatory') lat_proj = pynn.Projection(target_pop, target_pop, connector=lat_conn, synapse_type=synapse_to_use, receptor_type='inhibitory') target_pop.record(['spikes']) [source_on_pop.record('spikes'), source_off_pop.record('spikes')] if args.record_source_spikes else None ff_on_weight_recorder = WeightRecorder(sampling_interval=1.0, projection=ff_on_proj) ff_off_weight_recorder = WeightRecorder(sampling_interval=1.0, projection=ff_off_proj) lat_weight_recorder = WeightRecorder(sampling_interval=1.0, projection=lat_proj) pynn.run(duration, callbacks=[ ff_on_weight_recorder, ff_off_weight_recorder, lat_weight_recorder ]) pynn.end() target_spikes = target_pop.get_data('spikes').segments[0].spiketrains if record_source_spikes: source_on_spikes = source_on_pop.get_data( 'spikes').segments[0].spiketrains source_off_spikes = source_off_pop.get_data( 'spikes').segments[0].spiketrains ff_on_weights = ff_on_proj.get('weight', format='array') ff_off_weights = ff_off_proj.get('weight', format='array') lat_weights = lat_proj.get('weight', format='array') ff_on_weights_over_time = ff_on_weight_recorder.get_weights() ff_off_weights_over_time = ff_off_weight_recorder.get_weights() lat_weights_over_time = lat_weight_recorder.get_weights() pynn.reset() return target_spikes, ff_on_weights, ff_off_weights, lat_weights, ff_on_weights_over_time, ff_off_weights_over_time, lat_weights_over_time
def __init__(self, sim_params=None, cell_params=None, verbose=True): ''' Parameters : Stimulus, Population, Synapses, Recording, Running ''' self.verbose = verbose self.sim_params = sim_params self.cell_params = cell_params sim.setup() #spike_precision='on_grid')#timestep = .1) N_inh = int(sim_params['nb_neurons'] * sim_params['p']) #total pop * proportion of inhib self.spike_source = sim.Population( N_inh, sim.SpikeSourcePoisson(rate=sim_params['input_rate'], duration=sim_params['simtime'] / 2)) #orientation stimulus, see bottom section of notebook angle = 1. * np.arange(N_inh) rates = self.tuning_function(angle, sim_params['angle_input'] / 180. * N_inh, sim_params['b_input'], N_inh) rates /= rates.mean() rates *= sim_params['input_rate'] for i, cell in enumerate(self.spike_source): cell.set_parameters(rate=rates[i]) #neuron model selection if sim_params['neuron_model'] == 'IF_cond_alpha': model = sim.IF_cond_alpha #LIF with nice dynamics else: model = sim.IF_cond_exp #LIF with exp dynamics #populations E_neurons = sim.Population( N_inh, model(**cell_params), initial_values={ 'v': rnd('uniform', (sim_params['v_init_min'], sim_params['v_init_max'])) }, label="Excitateurs") I_neurons = sim.Population( int(sim_params['nb_neurons'] - N_inh), model(**cell_params), initial_values={ 'v': rnd('uniform', (sim_params['v_init_min'], sim_params['v_init_max'])) }, label="Inhibiteurs") #input to excitatories input_exc = sim.Projection( self.spike_source, E_neurons, sim.OneToOneConnector(), sim.StaticSynapse(weight=sim_params['w_input_exc'], delay=sim_params['s_input_exc'])) #loop through connections type and use associated params, can be a bit slow conn_types = ['exc_inh', 'inh_exc', 'exc_exc', 'inh_inh'] #connection types ''' self.proj = self.set_synapses(conn_types = conn_types, sim_params =sim_params, E_neurons = E_neurons, I_neurons = I_neurons, N_inh = N_inh) ''' #Multi threading support NE MARCHE PAS LAISSER LE NJOBS EN 1 self.proj = Parallel(n_jobs=1, backend='multiprocessing')( delayed(self.set_synapses)(conn_type, sim_params=sim_params, E_neurons=E_neurons, I_neurons=I_neurons, N_inh=N_inh, conn_types=conn_types, verbose=verbose) for conn_type in range(len(conn_types))) if verbose: print('Done building synapses !') #record self.spike_source.record('spikes') E_neurons.record('spikes') I_neurons.record('spikes') #run if verbose: print('Running simulation..') sim.run(sim_params['simtime']) if verbose: print('Done running !') #get the spikes self.E_spikes = E_neurons #.get_data().segments[0] self.I_spikes = I_neurons #.get_data().segments[0] self.P_spikes = self.spike_source #.get_data().segments[0]
if not args.debug: # define target cell target_pop = pynn.Population(args.num_target, pynn.IF_cond_exp, { 'i_offset': 0.11, 'tau_refrac': 3.0, 'v_thresh': -51.0 }) # define inhibitory and excitatory populations inhib_rates, excit_rates = getRatesForInhibExcit(args.inhib_rates_lower, args.excit_rates_lower, args.num_inhib, args.num_excit) inhib_source = pynn.Population( args.num_inhib, pynn.SpikeSourcePoisson(rate=inhib_rates), label="inhib_input") if args.inhib_conn_type == 'ff' else None excit_source = pynn.Population(args.num_excit, pynn.SpikeSourcePoisson(rate=excit_rates), label="excit_input") # define stdp rules, parameters could be messed around with here. stdp = pynn.STDPMechanism( weight=0.02, # this is the initial value of the weight timing_dependence=pynn.SpikePairRule(tau_plus=20.0, tau_minus=20.0, A_plus=0.01, A_minus=0.012), weight_dependence=pynn.AdditiveWeightDependence(w_min=0, w_max=0.04)) synapse_to_use = stdp if args.stdp else pynn.StaticSynapse(weight=0.02)