connector_ie, facilitating_synapse_ie, receptor_type='excitatory', label="excitatory to inhibitory" ) # from excitatory to inhibitory connection I_E_connections = sim.Projection( Pinh, Pexc, connector_ei, facilitating_synapse_ei, receptor_type='inhibitory', label="inhibitory to excitatory") # from inhibitory to excitatory # ==========injecting neuron currents OR connect to the input signal======================= syn = sim.StaticSynapse(weight=weight_ini, delay=0.5) Ie_E_connections = sim.Projection( Excinp, Pexc, sim.FixedProbabilityConnector(p_connect=0.5), syn, receptor_type='excitatory', label="excitatory input to excitatory neurons") Ii_E_connections = sim.Projection( Inhinp, Pexc, sim.FixedProbabilityConnector(p_connect=0.5), syn, receptor_type='inhibitory', label="inhibitory input to excitatory neurons") Ie_I_connections = sim.Projection(
# cm = 1.0, v_reset = -65, tau_syn_I = 0.5, i_offset = 0.0) # Pexc.initialize(**cell_type_parameters) # print Pexc.celltype.default_initial_values # print Pexc.get('tau_m') # syn = sim.StaticSynapse(weight = 0.05, delay = 0.5) depressing_synapse_ee = sim.TsodyksMarkramSynapse(weight=0.05, delay=0.2, U=0.5, tau_rec=800.0, tau_facil=0.01) facilitating_synapse_ee = sim.TsodyksMarkramSynapse(weight=0.05, delay=0.5, U=0.04, tau_rec=100.0, tau_facil=1000) static_synapse = sim.StaticSynapse(weight=0.05, delay=0.5) Input_E_connection = sim.Projection(Excinp, Pexc, sim.AllToAllConnector(), static_synapse, receptor_type='excitatory') E_E_connection = sim.Projection(Pexc, Pexc, sim.FixedProbabilityConnector(p_connect=0.5), depressing_synapse_ee, receptor_type='excitatory') Excinp.record('spikes') # Excinp[1].record('v')
def test(spikeTimes, trained_weights, label): #spikeTimes = extractSpikes(sample) runTime = int(max(max(spikeTimes))) + 100 ########################################## sim.setup(timestep=1) pre_pop = sim.Population(input_size, sim.SpikeSourceArray, {'spike_times': spikeTimes}, label="pre_pop") post_pop = sim.Population(output_size, sim.IF_curr_exp, cell_params_lif, label="post_pop") ''' if len(untrained_weights)>input_size: training_weights = [[0 for j in range(output_size)] for i in range(input_size)] #np array? size 1024x25 k=0 for i in untrained_weights: training_weights[i[0]][i[1]]=i[2] ''' if len(trained_weights) > input_size: weigths = [[0 for j in range(output_size)] for i in range(input_size)] #np array? size 1024x25 k = 0 for i in range(input_size): for j in range(output_size): weigths[i][j] = trained_weights[k] k += 1 else: weigths = trained_weights connections = [] #k = 0 for n_pre in range(input_size): # len(untrained_weights) = input_size for n_post in range( output_size ): # len(untrained_weight[0]) = output_size; 0 or any n_pre #connections.append((n_pre, n_post, weigths[n_pre][n_post]*(wMax), __delay__)) connections.append((n_pre, n_post, weigths[n_pre][n_post] * (wMax) / max(trained_weights), __delay__)) # #k += 1 prepost_proj = sim.Projection( pre_pop, post_pop, sim.FromListConnector(connections), synapse_type=sim.StaticSynapse(), receptor_type='excitatory') # no more learning !! #inhib_proj = sim.Projection(post_pop, post_pop, sim.AllToAllConnector(), synapse_type=sim.StaticSynapse(weight=inhibWeight, delay=__delay__), receptor_type='inhibitory') # no more lateral inhib post_pop.record(['v', 'spikes']) sim.run(runTime) neo = post_pop.get_data(['v', 'spikes']) spikes = neo.segments[0].spiketrains v = neo.segments[0].filter(name='v')[0] f1 = pplt.Figure( # plot voltage pplt.Panel(v, ylabel="Membrane potential (mV)", xticks=True, yticks=True, xlim=(0, runTime + 100)), # raster plot pplt.Panel(spikes, xlabel="Time (ms)", xticks=True, yticks=True, markersize=2, xlim=(0, runTime + 100)), title='Test with label ' + str(label), annotations='Test with label ' + str(label)) f1.save('plot/' + str(trylabel) + str(label) + '_test.png') f1.fig.texts = [] print("Weights:{}".format(prepost_proj.get('weight', 'list'))) weight_list = [ prepost_proj.get('weight', 'list'), prepost_proj.get('weight', format='list', with_address=False) ] #predict_label= sim.end() return spikes
def train(label, untrained_weights=None): organisedStim = {} labelSpikes = [] spikeTimes = generate_data(label) for i in range(output_size): labelSpikes.append([]) labelSpikes[label] = [int(max(max(spikeTimes))) + 1] if untrained_weights == None: untrained_weights = RandomDistribution('uniform', low=wMin, high=wMaxInit).next(input_size * output_size) #untrained_weights = RandomDistribution('normal_clipped', mu=0.1, sigma=0.05, low=wMin, high=wMaxInit).next(input_size*output_size) untrained_weights = np.around(untrained_weights, 3) #saveWeights(untrained_weights, 'untrained_weightssupmodel1traj') print("init!") print "length untrained_weights :", len(untrained_weights) if len(untrained_weights) > input_size: training_weights = [[0 for j in range(output_size)] for i in range(input_size) ] #np array? size 1024x25 k = 0 #for i in untrained_weights: # training_weights[i[0]][i[1]]=i[2] for i in range(input_size): for j in range(output_size): training_weights[i][j] = untrained_weights[k] k += 1 else: training_weights = untrained_weights connections = [] for n_pre in range(input_size): # len(untrained_weights) = input_size for n_post in range( output_size ): # len(untrained_weight[0]) = output_size; 0 or any n_pre connections.append((n_pre, n_post, training_weights[n_pre][n_post], __delay__)) #index runTime = int(max(max(spikeTimes))) + 100 ##################### sim.setup(timestep=1) #def populations layer1 = sim.Population(input_size, sim.SpikeSourceArray, {'spike_times': spikeTimes}, label='inputspikes') layer2 = sim.Population(output_size, sim.IF_curr_exp, cellparams=cell_params_lif, label='outputspikes') supsignal = sim.Population(output_size, sim.SpikeSourceArray, {'spike_times': labelSpikes}, label='supersignal') #def learning rule stdp = sim.STDPMechanism( #weight=untrained_weights, #weight=0.02, # this is the initial value of the weight #delay="0.2 + 0.01*d", timing_dependence=sim.SpikePairRule(tau_plus=tauPlus, tau_minus=tauMinus, A_plus=aPlus, A_minus=aMinus), #weight_dependence=sim.MultiplicativeWeightDependence(w_min=wMin, w_max=wMax), weight_dependence=sim.AdditiveWeightDependence(w_min=wMin, w_max=wMax), dendritic_delay_fraction=0) #def projections stdp_proj = sim.Projection(layer1, layer2, sim.FromListConnector(connections), synapse_type=stdp) inhibitory_connections = sim.Projection( layer2, layer2, sim.AllToAllConnector(allow_self_connections=False), synapse_type=sim.StaticSynapse(weight=inhibWeight, delay=__delay__), receptor_type='inhibitory') stim_proj = sim.Projection(supsignal, layer2, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse( weight=stimWeight, delay=__delay__)) layer1.record(['spikes']) layer2.record(['v', 'spikes']) supsignal.record(['spikes']) sim.run(runTime) print("Weights:{}".format(stdp_proj.get('weight', 'list'))) weight_list = [ stdp_proj.get('weight', 'list'), stdp_proj.get('weight', format='list', with_address=False) ] neo = layer2.get_data(["spikes", "v"]) spikes = neo.segments[0].spiketrains v = neo.segments[0].filter(name='v')[0] neostim = supsignal.get_data(["spikes"]) print(label) spikestim = neostim.segments[0].spiketrains neoinput = layer1.get_data(["spikes"]) spikesinput = neoinput.segments[0].spiketrains plt.close('all') pplt.Figure(pplt.Panel(v, ylabel="Membrane potential (mV)", xticks=True, yticks=True, xlim=(0, runTime)), pplt.Panel(spikesinput, xticks=True, yticks=True, markersize=2, xlim=(0, runTime)), pplt.Panel(spikestim, xticks=True, yticks=True, markersize=2, xlim=(0, runTime)), pplt.Panel(spikes, xticks=True, xlabel="Time (ms)", yticks=True, markersize=2, xlim=(0, runTime)), title="Training" + str(label), annotations="Training" + str(label)).save('plot/' + str(trylabel) + str(label) + '_training.png') #plt.hist(weight_list[1], bins=100) #plt.show() plt.close('all') print(wMax) ''' plt.hist([weight_list[1][0:input_size], weight_list[1][input_size:input_size*2], weight_list[1][input_size*2:]], bins=20, label=['neuron 0', 'neuron 1', 'neuron 2'], range=(0, wMax)) plt.title('weight distribution') plt.xlabel('Weight value') plt.ylabel('Weight count') ''' #plt.show() #plt.show() sim.end() for i in weight_list[0]: #training_weights[int(i[0])][int(i[1])]=float(i[2]) weight_list[1][int(i[0]) * output_size + int(i[1])] = i[2] return weight_list[1]
import pyNN.brian 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 for i in range(2): sim.run(500.0) spikes_in = p_in.get_data() data_out = p_out.get_data() sim.reset() connections.set(weight=0.05) sim.end() print 'finish simulation'
spikeSourcePlastic = sim.Population(1, sim.SpikeSourceArray, {'spike_times': stimulusPlastic}) assert (spikeSourceStim != None) assert (spikeSourcePlastic != None) # configure stdp stdp = sim.STDPMechanism(weight = 0.2, # this is the initial value of the weight timing_dependence = sim.SpikePairRule(tau_plus = 20.0, tau_minus = 20.0, A_plus = 0.01, A_minus = 0.012),\ weight_dependence = sim.AdditiveWeightDependence(w_min = 0, w_max = 0.04)) # connect stimulus sim.Projection(spikeSourceStim, neuron, sim.AllToAllConnector(), sim.StaticSynapse(weight=0.04, delay=timingPrePostStim), receptor_type='excitatory') # create plastic synapse prj = sim.Projection(spikeSourcePlastic, neuron, sim.AllToAllConnector(), stdp) weightBefore = prj.get('weight', format='list') prj.set(weight=0.15) print weightBefore neuron.record('spikes') lastInputSpike = np.max(np.concatenate((stimulus, stimulusPlastic))) runtime = lastInputSpike + stimulusOffset sim.run(runtime) weightAfter = prj.get('weight', format='list')
def setUp(self): sim.setup() self.syn = sim.StaticSynapse(weight=0.123, delay=0.5)
connector_ee = sim.FixedProbabilityConnector( p_connect=p_ee) # connector algorithm connector_ie = sim.FixedProbabilityConnector(p_connect=p_ie) connector_ei = sim.FixedProbabilityConnector(p_connect=p_ei) connector_ii = sim.FixedProbabilityConnector(p_connect=p_ii) # connection weight # todo: weight distribution according to position W_c = 0.5 # scaling factor of weight w_ee = W_c * 1 w_ie = 0.5 * W_c * 0.1 w_ei = W_c * 3 w_ii = 0.5 * W_c * 0.5 # type of synaptic connection static_synapse_ee = sim.StaticSynapse(weight=w_ee, delay=0.2) static_synapse_ii = sim.StaticSynapse(weight=w_ii, delay=0.2) static_synapse_ie = sim.StaticSynapse(weight=w_ie, delay=0.5) static_synapse_ei = sim.StaticSynapse(weight=w_ei, delay=0.5) # connect the neuronal network E_E_connections = sim.Projection( Pexc, Pexc, connector_ee, static_synapse_ee, receptor_type='excitatory', label="excitatory to excitatory") # excitatory to excitatory connection I_I_connections = sim.Projection(
import pyNN.brian as sim from pyNN.random import (NumpyRNG, RandomDistribution) #import matplotlib.pyplot as plt import numpy as np sim.setup(timestep=0.01) ''' Synapse types ''' #=====Fixed synaptic weight===== syn = sim.StaticSynapse(weight=0.04, delay=0.5) #random w = RandomDistribution('gamma', [10, 0.004], rng=NumpyRNG(seed=4242)) syn = sim.StaticSynapse(weight=w, delay=0.5) #specify parameters as a function of the distance- um syn = sim.StaticSynapse(weight=w, delay="0.2 + 0.01*d") #=====Short-term synaptic plasticity===== depressing_synapse = sim.TsodyksMarkramSynapse(weight=w, delay=0.2, U=0.5, tau_rec=800.0, tau_facil=0.0) tau_rec = RandomDistribution('normal', [100.0, 10.0]) facilitating_synapse = sim.TsodyksMarkramSynapse(weight=w, delay=0.5, U=0.04, tau_rec=tau_rec) #=====Spike-timing-dependent plasticity=====
for i in range(len(training_label)): # for i in range(1): lg.info('iteration number %d' % i) sim.setup() In_1 = sim.Population( 10, sim.SpikeSourcePoisson(rate=source_rate[training_label[i]])) In_2 = sim.Population( 10, sim.SpikeSourcePoisson(rate=source_rate[1 - training_label[i]])) In = In_1 + In_2 Out_1 = sim.Population(10, sim.IF_cond_exp()) Out_2 = sim.Population(10, sim.IF_cond_exp()) Out = Out_1 + Out_2 syn_1_1 = sim.StaticSynapse(weight=w1_1, delay=0.5) syn_1_2 = sim.StaticSynapse(weight=w1_2, delay=0.5) syn_2_1 = sim.StaticSynapse(weight=w2_1, delay=0.5) syn_2_2 = sim.StaticSynapse(weight=w2_2, delay=0.5) prj_1_1 = sim.Projection(In_1, Out_1, sim.ArrayConnector(connector1_1), syn_1_1, receptor_type='excitatory') prj_1_2 = sim.Projection(In_1, Out_2, sim.ArrayConnector(connector1_2), syn_1_2, receptor_type='excitatory') prj_2_1 = sim.Projection(In_2, Out_1,
import pyNN.brian as sim import numpy as np training_data = np.loadtxt('training_data_0_1.txt', delimiter=',') training_label = training_data[:, -1] training_rate = training_data[:, 0:64] # print training_rate[1, :] inputpop = [] sim.setup() for i in range(np.size(training_rate, 1)): inputpop.append( sim.Population(1, sim.SpikeSourcePoisson(rate=abs(training_rate[0, i])))) # print inputpop[0].get('rate') # inputpop[0].set(rate = 8) # print inputpop[0].get('rate') pop = sim.Population(1, sim.IF_cond_exp(), label='exc') prj1 = sim.Projection(inputpop[0], pop, sim.OneToOneConnector(), synapse_type=sim.StaticSynapse(weight=0.04, delay=0.5), receptor_type='inhibitory') print prj1.get('weight', format='list')