import scipy import matplotlib.pyplot as plt #from CellClass import * from CellClass import * from StateClass import * from random import * import math import pickle import numpy class Controller(object): def __init__(self,dim_stim,dim): self.variables = StateClass() self.variables.maxWeight = 0.005 #maximum weight synaptic connections can have self.variables.minWeight = 0 #minimum weight synaptic connections can have self.variables.dim = dim #number of cells on one side in a layer (ie the number of cells are dim*dim) self.variables.learningState = 1 #0: no synaptic modifications / 1: synaptic modifications with STDP self.variables.tstop = 300 #duration for each trial ([ms]) self.variables.maxWeightsMulti=1.5#1.5 #toL23 self.variables.maxWeightsMulti2=3#2.5# #toL5 self.resultFolderName = "results"; #h.dt = 1 # time-step ([ms]) -- PROBLEM: this value cannot be changed?? (stays 0.025) self.variables.hz = 40 #maximum frequency of the input signal. PROBLEM: If I increase too much, post-synaptic cell never get activated.. delay_rgb2channel = 1#+ uniform(-1,1) delay_ToL4 = 1 delay_C2ToL23 = 1 delay_L4ToL23 = 1 delay_L23ToL5 = 1 delay_lateral_pot1 = 1#0.1 delay_lateral_pot2 = 2#0.2 delay_lateral_pot3 = 3#0.3 delay_lateral_dep = 4#0.4#0.6 weight_rgb2channel = 0.005#0.01 weight_ToL4 = self.variables.maxWeight weight_L4ToL23 = self.variables.maxWeight*self.variables.maxWeightsMulti weight_C2ToL23 = self.variables.maxWeight*self.variables.maxWeightsMulti weight_L23ToL5 = self.variables.maxWeight*self.variables.maxWeightsMulti2 weight_lateral_pot1 = self.variables.maxWeight*0.9#*0.8*0.9 weight_lateral_pot2 = self.variables.maxWeight*0.5#*0.5*0.9 weight_lateral_pot3 = self.variables.maxWeight*0.3#*0.4*0.9 weight_lateral_dep = self.variables.maxWeight*1.5#0.9#*0.8*0.9 #to set range of the initial weights relative to (self.variables.maxWeight-self.variables.minWeight) initRandMinRange = 0 initRandMaxRange = 1 self.variables.dim_stim = dim_stim self.r_stims = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.g_stims = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.b_stims = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.steadyActivation = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.variables.delay_r = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.variables.delay_g = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.variables.delay_b = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] # self.variables.delay_steady = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] # self.variables.steady_state_activation = 0.2 self.noiseLv = 0.3; # self.noiseSteady = 1; for y in range(self.variables.dim_stim): for x in range(self.variables.dim_stim): self.r_stims[y][x] = h.NetStim(0.5) self.r_stims[y][x].noise = self.noiseLv#0.1 self.variables.delay_r[y][x] = random(); #starting timing self.g_stims[y][x] = h.NetStim(0.5) self.g_stims[y][x].noise = self.noiseLv#0.1 self.variables.delay_g[y][x] = random(); self.b_stims[y][x] = h.NetStim(0.5) self.b_stims[y][x].noise = self.noiseLv#0.1 self.variables.delay_b[y][x] = random(); # self.steadyActivation[y][x] = h.NetStim(0.5); # self.steadyActivation[y][x].noise = 0#0.1 # self.steadyActivation[y][x].noise = self.noiseSteady#0.1 # self.steadyActivation[y][x].number = 1e9 # self.variables.delay_steady[y][x] = random()*25; # self.steadyActivation[y][x].start = self.variables.delay_steady[y][x]; # self.variables.delay_steady[y][x] = random(); self.rds_r = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.rds_g = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.rds_b = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] # self.rds_steady = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.variables.seed_r = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.variables.seed_g = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] self.variables.seed_b = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] # self.variables.seed_steady = [[0 for x in xrange(self.variables.dim_stim)] for x in xrange(self.variables.dim_stim)] for y in range(self.variables.dim_stim): for x in range(self.variables.dim_stim): self.rds_r[y][x]= h.Random() self.rds_r[y][x].negexp(1) # must have this line! -- set random # generator using negexp(1) - avg interval in NetStim self.variables.seed_r[y][x] = random() # your random number seed (should differ for each NetStim) self.rds_r[y][x].MCellRan4(self.variables.seed_r[y][x],self.variables.seed_r[y][x]) # initialize here self.r_stims[y][x].noiseFromRandom(self.rds_r[y][x]) # use random # generator for this NetStim self.rds_g[y][x] = h.Random() self.rds_g[y][x].negexp(1) # must have this line! -- set random # generator using negexp(1) - avg interval in NetStim self.variables.seed_g[y][x] = random() # your random number seed (should differ for each NetStim) self.rds_g[y][x].MCellRan4(self.variables.seed_g[y][x],self.variables.seed_g[y][x]) # initialize here self.g_stims[y][x].noiseFromRandom(self.rds_g[y][x]) # use random # generator for this NetStim self.rds_b[y][x] = h.Random() self.rds_b[y][x].negexp(1) # must have this line! -- set random # generator using negexp(1) - avg interval in NetStim self.variables.seed_b[y][x] = random() # your random number seed (should differ for each NetStim) self.rds_b[y][x].MCellRan4(self.variables.seed_b[y][x],self.variables.seed_b[y][x]) # initialize here self.b_stims[y][x].noiseFromRandom(self.rds_b[y][x]) # use random # generator for this NetStim # # self.rds_steady[y][x] = h.Random() # self.rds_steady[y][x].negexp(1) # must have this line! -- set random # generator using negexp(1) - avg interval in NetStim # self.variables.seed_steady[y][x] = random() # your random number seed (should differ for each NetStim) # self.rds_steady[y][x].MCellRan4(self.variables.seed_steady[y][x],self.variables.seed_steady[y][x]) # initialize here # self.steadyActivation[y][x].noiseFromRandom(self.rds_steady[y][x]) # use random # generator for this NetStim # # #init layer to store cells self.L_channels = [] #L layer self.C1_channels = [] #C1 layer self.C2_channels = [] #C2 layer self.cortexLayer_4 = [] #output layer self.cortexLayer_2_3 = [] self.cortexLayer_5 = [] # self.cortexLayer_5 = [] #to record firing counts in the cortexLayer_4 when exposed to different stimuli self.firingSums = [] #init NetCon for C1, C2, L, cortexLayer_4 self.NetCons = [] #to store Synaptic connections where weights are fixed (rgb to L, C1, C2; lateral connections in cortexLayer_4) self.NetCons_STDP_LtoL4 = [] #to store synaptic connections of L self.NetCons_STDP_C1toL4 = [] #to store synaptic connections of C1 self.NetCons_STDP_C2toL23 = [] #to store synaptic connections of C2 self.NetCons_STDP_L4toL23 = [] self.NetCons_STDP_L23toL5 = [] # #init topologically corresponding synaptic connections (rgb to L, C1, C2; L, C1, C2 to the cortexLayer_4) for y in range(dim): for x in range(dim): index = y*dim + x self.L_channels.append(CellClass(x,y)) self.C1_channels.append(CellClass(x,y)) self.C2_channels.append(CellClass(x,y)) self.cortexLayer_4.append(CellClass(x,y)) self.cortexLayer_2_3.append(CellClass(x,y)) self.cortexLayer_5.append(CellClass(x,y)) self.cortexLayer_4[index].setWeightRange(self.variables.minWeight,self.variables.maxWeight) #set min/maxWeights self.cortexLayer_2_3[index].setWeightRange(self.variables.minWeight,self.variables.maxWeight*self.variables.maxWeightsMulti) #set min/maxWeights self.cortexLayer_5[index].setWeightRange(self.variables.minWeight,self.variables.maxWeight*self.variables.maxWeightsMulti2) #set min/maxWeights y_stim = int(y*self.variables.dim_stim/self.variables.dim); x_stim = int(x*self.variables.dim_stim/self.variables.dim); #Constructing synaptic connections between rgb and L, C1, C2 based on color oppornent theory #weights are varied by multiplying by uniform(0,2) delay = delay_rgb2channel weightConst = weight_rgb2channel #L NetCon init (luminance - LGN-M) weightTmp = weightConst*uniform(0.5,2); # weightTmp2 = weightConst*uniform(0.5,2)*0.5;#steadyState? self.NetCons.append(h.NetCon(self.r_stims[y_stim][x_stim],self.L_channels[index].AMPA,0,delay,weightTmp))#source, dest, threshold, delay, weight # self.NetCons.append(h.NetCon(self.steadyActivation[y_stim][x_stim],self.L_channels[index].AMPA,0,delay,weightTmp2)) weightTmp = weightConst*uniform(0.5,2); self.NetCons.append(h.NetCon(self.g_stims[y_stim][x_stim],self.L_channels[index].AMPA,0,delay,weightTmp))#source, dest, threshold, delay, weight # self.NetCons.append(h.NetCon(self.steadyActivation[y_stim][x_stim],self.L_channels[index].AMPA,0,delay,weightTmp2))#source, dest, threshold, delay, weight #C1 NetCon init (red-green - LGN-P) weightTmp = weightConst*uniform(0.5,2); self.NetCons.append(h.NetCon(self.r_stims[y_stim][x_stim],self.C1_channels[index].AMPA,0,delay,weightTmp))#source, dest, threshold, delay, weight # self.NetCons.append(h.NetCon(self.steadyActivation[y_stim][x_stim],self.C1_channels[index].AMPA,0,delay,weightTmp2))#source, dest, threshold, delay, weight weightTmp = weightConst*uniform(0.5,2); self.NetCons.append(h.NetCon(self.g_stims[y_stim][x_stim],self.C1_channels[index].GABA,0,delay,1.5*weightTmp))#source, dest, threshold, delay, weight # self.NetCons.append(h.NetCon(self.steadyActivation[y_stim][x_stim],self.C1_channels[index].GABA,0,delay,weightTmp2))#source, dest, threshold, delay, weight #C2 NetCon init (blue-yellow - LGN k-path) weightTmp = weightConst*uniform(0.5,2); self.NetCons.append(h.NetCon(self.r_stims[y_stim][x_stim],self.C2_channels[index].AMPA,0,delay,1*weightTmp))#source, dest, threshold, delay, weight # self.NetCons.append(h.NetCon(self.steadyActivation[y_stim][x_stim],self.C2_channels[index].AMPA,0,delay,1*weightTmp2))#source, dest, threshold, delay, weight weightTmp = weightConst*uniform(0.5,2); self.NetCons.append(h.NetCon(self.g_stims[y_stim][x_stim],self.C2_channels[index].AMPA,0,delay,1*weightTmp))#source, dest, threshold, delay, weight # self.NetCons.append(h.NetCon(self.steadyActivation[y_stim][x_stim],self.C2_channels[index].AMPA,0,delay,1*weightTmp2))#source, dest, threshold, delay, weight weightTmp = weightConst*uniform(0.5,2); self.NetCons.append(h.NetCon(self.b_stims[y_stim][x_stim],self.C2_channels[index].GABA,0,delay,3*weightTmp))#source, dest, threshold, delay, weight # self.NetCons.append(h.NetCon(self.steadyActivation[y_stim][x_stim],self.C2_channels[index].GABA,0,delay,2*weightTmp2))#source, dest, threshold, delay, weight #Constructing synaptic connections between L, C1 and CortexLayer_4 weightConst = weight_ToL4 delayConst = delay_ToL4# + uniform(-2,2) #L to cortex tmpNetCon = h.NetCon(self.L_channels[index].soma(0.5)._ref_v,self.cortexLayer_4[index].syn_STDP, sec = self.L_channels[index].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange) self.NetCons_STDP_LtoL4.append(tmpNetCon) #C1 to cortex tmpNetCon = h.NetCon(self.C1_channels[index].soma(0.5)._ref_v,self.cortexLayer_4[index].syn_STDP, sec = self.C1_channels[index].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_C1toL4.append(tmpNetCon) #Constructing synaptic connections between CortexLayer_4, C2 and CortexLayer_2_3 #C2 to cortexLayer_2_3 weightConst=weight_C2ToL23 delayConst = delay_C2ToL23 tmpNetCon = h.NetCon(self.C2_channels[index].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.C2_channels[index].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_C2toL23.append(tmpNetCon) #CortexLayer_4 to cortexLayer_2_3 weightConst=weight_L4ToL23 delayConst = delay_L4ToL23 tmpNetCon = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.cortexLayer_4[index].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L4toL23.append(tmpNetCon) #Constructing synaptic connections between CortexLayer_2_3 to CortexLayer_5 #L23 to cortexLayer_5 weightConst=weight_L23ToL5 delayConst = delay_L23ToL5 tmpNetCon = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v,self.cortexLayer_5[index].syn_STDP, sec = self.cortexLayer_2_3[index].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L23toL5.append(tmpNetCon) ##init feed-forward connections from 3 more neighboring cells in the preceding layers (L, C1, C2) to the cortex layer (could be removed) ## .... ## .TN. T:topologically corresponding cell ## .NN. N:neighboring cells ## .... ## ##*could be increased the number from 3 to 8 (all the surrounding neighbors) for y in range(dim): for x in range(dim): #LGN-monochrome path to L4 weightConst = weight_ToL4 delayConst = delay_ToL4 tmpNetCon = h.NetCon(self.L_channels[((y+1)%dim)*dim+x].soma(0.5)._ref_v,self.cortexLayer_4[index].syn_STDP, sec = self.L_channels[((y+1)%dim)*dim+x].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_LtoL4.append(tmpNetCon) tmpNetCon = h.NetCon(self.L_channels[y*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_4[index].syn_STDP, sec = self.L_channels[y*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_LtoL4.append(tmpNetCon) tmpNetCon = h.NetCon(self.L_channels[((y+1)%dim)*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_4[index].syn_STDP, sec = self.L_channels[((y+1)%dim)*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_LtoL4.append(tmpNetCon) #LGN-R/G-paht to L4 tmpNetCon = h.NetCon(self.C1_channels[((y+1)%dim)*dim+x].soma(0.5)._ref_v,self.cortexLayer_4[index].syn_STDP, sec = self.C1_channels[((y+1)%dim)*dim+x].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_C1toL4.append(tmpNetCon) tmpNetCon = h.NetCon(self.C1_channels[y*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_4[index].syn_STDP, sec = self.C1_channels[y*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_C1toL4.append(tmpNetCon) tmpNetCon = h.NetCon(self.C1_channels[((y+1)%dim)*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_4[index].syn_STDP, sec = self.C1_channels[((y+1)%dim)*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_C1toL4.append(tmpNetCon) #LGN-K-path to L_2/3 weightConst=weight_L4ToL23 tmpNetCon = h.NetCon(self.C2_channels[((y+1)%dim)*dim+x].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.C2_channels[((y+1)%dim)*dim+x].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_C2toL23.append(tmpNetCon) tmpNetCon = h.NetCon(self.C2_channels[y*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.C2_channels[y*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_C2toL23.append(tmpNetCon) tmpNetCon = h.NetCon(self.C2_channels[((y+1)%dim)*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.C2_channels[((y+1)%dim)*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_C2toL23.append(tmpNetCon) #L4 to L2/3 tmpNetCon = h.NetCon(self.cortexLayer_4[((y+1)%dim)*dim+x].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.cortexLayer_4[((y+1)%dim)*dim+x].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L4toL23.append(tmpNetCon) tmpNetCon = h.NetCon(self.cortexLayer_4[y*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.cortexLayer_4[y*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L4toL23.append(tmpNetCon) tmpNetCon = h.NetCon(self.cortexLayer_4[((y-1+dim)%dim)*dim+x].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.cortexLayer_4[((y-1+dim)%dim)*dim+x].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L4toL23.append(tmpNetCon) tmpNetCon = h.NetCon(self.cortexLayer_4[y*dim+(x-1+dim)%dim].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.cortexLayer_4[y*dim+(x-1+dim)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L4toL23.append(tmpNetCon) # tmpNetCon = h.NetCon(self.cortexLayer_4[((y+1)%dim)*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_2_3[index].syn_STDP, sec = self.cortexLayer_4[((y+1)%dim)*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight # tmpNetCon.threshold = 0 # tmpNetCon.delay = delayConst# + uniform(-2,2) # tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() # self.NetCons_STDP_L4toL23.append(tmpNetCon) #L2/3 to L5 weightConst=weight_L23ToL5 tmpNetCon = h.NetCon(self.cortexLayer_2_3[((y+1)%dim)*dim+x].soma(0.5)._ref_v,self.cortexLayer_5[index].syn_STDP, sec = self.cortexLayer_2_3[((y+1)%dim)*dim+x].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L23toL5.append(tmpNetCon) tmpNetCon = h.NetCon(self.cortexLayer_2_3[y*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_5[index].syn_STDP, sec = self.cortexLayer_2_3[y*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L23toL5.append(tmpNetCon) tmpNetCon = h.NetCon(self.cortexLayer_2_3[((y-1+dim)%dim)*dim+x].soma(0.5)._ref_v,self.cortexLayer_5[index].syn_STDP, sec = self.cortexLayer_2_3[((y-1+dim)%dim)*dim+x].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L23toL5.append(tmpNetCon) tmpNetCon = h.NetCon(self.cortexLayer_2_3[y*dim+(x-1+dim)%dim].soma(0.5)._ref_v,self.cortexLayer_5[index].syn_STDP, sec = self.cortexLayer_2_3[y*dim+(x-1+dim)%dim].soma)#source, dest, threshold, delay, weight tmpNetCon.threshold = 0 tmpNetCon.delay = delayConst# + uniform(-2,2) tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() self.NetCons_STDP_L23toL5.append(tmpNetCon) # tmpNetCon = h.NetCon(self.cortexLayer_2_3[((y+1)%dim)*dim+(x+1)%dim].soma(0.5)._ref_v,self.cortexLayer_5[index].syn_STDP, sec = self.cortexLayer_2_3[((y+1)%dim)*dim+(x+1)%dim].soma)#source, dest, threshold, delay, weight # tmpNetCon.threshold = 0 # tmpNetCon.delay = delayConst# + uniform(-2,2) # tmpNetCon.weight[0] = weightConst*uniform(initRandMinRange,initRandMaxRange)#*random() # self.NetCons_STDP_L23toL5.append(tmpNetCon) ##Lateral connections in cortex layer for y in range(dim): for x in range(dim): index = y*dim + x #Lateral potent. ## ## .P. S:source ## PSP P:potentiation ## .P. ## #layer V1_4 weightTemp = weight_lateral_pot1 delayConst = delay_lateral_pot1 index_tmp = y*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = y*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #layer V1_23 index_tmp = y*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = y*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #layer V1_5 index_tmp = y*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = y*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #Lateral potent 2 ## ## P.P S:source ## .S. P:potentiation ## P.P ## #layer V1_4 weightTemp = weight_lateral_pot2 delayConst = delay_lateral_pot2 #diagonal index_tmp = ((y+1)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x-1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x+1)%dim #print ((y-1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x-1+dim)%dim #print ((y-1)%dim),(x-1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #layer V1_23 index_tmp = ((y+1)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x-1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x+1)%dim #print ((y-1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x-1+dim)%dim #print ((y-1)%dim),(x-1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #layer V1_5 index_tmp = ((y+1)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x-1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x+1)%dim #print ((y-1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x-1+dim)%dim #print ((y-1)%dim),(x-1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #Lateral potent 3 ## PPP ## P...P S:source ## P.S.P P:potentiation ## P...P ## PPP #layer V1_4 weightTemp = weight_lateral_pot3 delayConst = delay_lateral_pot3 #top_l index_tmp = ((y-2+dim)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #top_m index_tmp = ((y-2+dim)%dim)*dim+x #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #top_r index_tmp = ((y-2+dim)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_t index_tmp = ((y-1+dim)%dim)*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_m index_tmp = y*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_b index_tmp = ((y+1)%dim)*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_r index_tmp = ((y+2)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_m index_tmp = ((y+2)%dim)*dim+(x)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_l index_tmp = ((y+2)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_b index_tmp = ((y+1)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_m index_tmp = ((y)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_t index_tmp = ((y-1+dim)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].AMPA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #layer V1_23 #top_l index_tmp = ((y-2+dim)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #top_m index_tmp = ((y-2+dim)%dim)*dim+x #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #top_r index_tmp = ((y-2+dim)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_t index_tmp = ((y-1+dim)%dim)*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_m index_tmp = y*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_b index_tmp = ((y+1)%dim)*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_r index_tmp = ((y+2)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_m index_tmp = ((y+2)%dim)*dim+(x)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_l index_tmp = ((y+2)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_b index_tmp = ((y+1)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_m index_tmp = ((y)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_t index_tmp = ((y-1+dim)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].AMPA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #layer V1_5 #top_l index_tmp = ((y-2+dim)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #top_m index_tmp = ((y-2+dim)%dim)*dim+x #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #top_r index_tmp = ((y-2+dim)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_t index_tmp = ((y-1+dim)%dim)*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_m index_tmp = y*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #right_b index_tmp = ((y+1)%dim)*dim+(x+2)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_r index_tmp = ((y+2)%dim)*dim+(x+1)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_m index_tmp = ((y+2)%dim)*dim+(x)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #bottom_l index_tmp = ((y+2)%dim)*dim+(x-1+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_b index_tmp = ((y+1)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_m index_tmp = ((y)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #left_t index_tmp = ((y-1+dim)%dim)*dim+(x-2+dim)%dim #print ((y+1)%dim),(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].AMPA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #Lateral depression ## DDD ## D...D ## D.....D S:source ## D..S..D D:depression ## D.....D ## D...D ## DDD weightTemp = weight_lateral_dep*1.7#2 delayConst = delay_lateral_dep #L4 index_tmp = y*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = y*dim+(x-3+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x-3+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x-3+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-2+dim)%dim)*dim+(x-2+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-2+dim)%dim)*dim+(x+2)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+2)%dim)*dim+(x-2+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+2)%dim)*dim+(x+2)%dim nc_tmp = h.NetCon(self.cortexLayer_4[index].soma(0.5)._ref_v, self.cortexLayer_4[index_tmp].GABA, sec=self.cortexLayer_4[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #L2_3 weightTemp = weight_lateral_dep*1.5#1.7 index_tmp = y*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = y*dim+(x-3)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x-3+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x-3+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-2+dim)%dim)*dim+(x-2+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-2+dim)%dim)*dim+(x+2)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+2)%dim)*dim+(x-2+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+2)%dim)*dim+(x+2)%dim nc_tmp = h.NetCon(self.cortexLayer_2_3[index].soma(0.5)._ref_v, self.cortexLayer_2_3[index_tmp].GABA, sec=self.cortexLayer_2_3[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) #layer V1_5 weightTemp = weight_lateral_dep * 1 index_tmp = y*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x+3)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = y*dim+(x-3+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+1)%dim)*dim+(x-3+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-1+dim)%dim)*dim+(x-3+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+3)%dim)*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+x nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+(x+1)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-3+dim)%dim)*dim+(x-1+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-2+dim)%dim)*dim+(x-2+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y-2+dim)%dim)*dim+(x+2)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+2)%dim)*dim+(x-2+dim)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) index_tmp = ((y+2)%dim)*dim+(x+2)%dim nc_tmp = h.NetCon(self.cortexLayer_5[index].soma(0.5)._ref_v, self.cortexLayer_5[index_tmp].GABA, sec=self.cortexLayer_5[index].soma) nc_tmp.delay=delayConst#*(random()+0.001) nc_tmp.threshold=0 nc_tmp.weight[0]=weightTemp self.NetCons.append(nc_tmp) def initExtra(self): self.variables.trainingColors = numpy.zeros(3*self.variables.nTrainings).reshape((self.variables.nTrainings, 3)) def myInitNetStims (self): # print 'in myInitNetStims' for y in range(self.variables.dim_stim): for x in range(self.variables.dim_stim): self.rds_r[y][x].MCellRan4(self.variables.seed_r[y][x],self.variables.seed_r[y][x]) self.rds_r[y][x].negexp(1) self.rds_g[y][x].MCellRan4(self.variables.seed_g[y][x],self.variables.seed_g[y][x]) self.rds_g[y][x].negexp(1) self.rds_b[y][x].MCellRan4(self.variables.seed_b[y][x],self.variables.seed_b[y][x]) self.rds_b[y][x].negexp(1) # self.rds_steady[y][x].MCellRan4(self.variables.seed_steady[y][x],self.variables.seed_steady[y][x]) # self.rds_steady[y][x].negexp(1) #function to save the current state of the network so that it could be loaded by runMe2.py to test it with different stimuli def saveWeightsAndDelays(self, itr): self.variables.NetCons_Weights = [] self.variables.NetCons_Delays = [] self.variables.NetCons_STDP_LtoL4_Weights = [] self.variables.NetCons_STDP_LtoL4_Delays = [] self.variables.NetCons_STDP_C1toL4_Weights = [] self.variables.NetCons_STDP_C1toL4_Delays = [] self.variables.NetCons_STDP_C2toL23_Weights = [] self.variables.NetCons_STDP_C2toL23_Delays = [] self.variables.NetCons_STDP_L4toL23_Weights = [] self.variables.NetCons_STDP_L4toL23_Delays = [] self.variables.NetCons_STDP_L23toL5_Weights = [] self.variables.NetCons_STDP_L23toL5_Delays = [] for ind in range(len(self.NetCons)): self.variables.NetCons_Weights.append(self.NetCons[ind].weight[0]) self.variables.NetCons_Delays.append(self.NetCons[ind].delay) for ind in range(len(self.NetCons_STDP_LtoL4)): self.variables.NetCons_STDP_LtoL4_Weights.append(self.NetCons_STDP_LtoL4[ind].weight[0]) self.variables.NetCons_STDP_LtoL4_Delays.append(self.NetCons_STDP_LtoL4[ind].delay) self.variables.NetCons_STDP_C1toL4_Weights.append(self.NetCons_STDP_C1toL4[ind].weight[0]) self.variables.NetCons_STDP_C1toL4_Delays.append(self.NetCons_STDP_C1toL4[ind].delay) self.variables.NetCons_STDP_C2toL23_Weights.append(self.NetCons_STDP_C2toL23[ind].weight[0]) self.variables.NetCons_STDP_C2toL23_Delays.append(self.NetCons_STDP_C2toL23[ind].delay) for ind in range(len(self.NetCons_STDP_L4toL23)): self.variables.NetCons_STDP_L4toL23_Weights.append(self.NetCons_STDP_L4toL23[ind].weight[0]) self.variables.NetCons_STDP_L4toL23_Delays.append(self.NetCons_STDP_L4toL23[ind].delay) self.variables.NetCons_STDP_L23toL5_Weights.append(self.NetCons_STDP_L23toL5[ind].weight[0]) self.variables.NetCons_STDP_L23toL5_Delays.append(self.NetCons_STDP_L23toL5[ind].delay) f = open(self.resultFolderName+"/Network_"+str(itr)+".obj", "wb") pickle.dump(self.variables, f) f.close() #function to load **.obj files that store network state information def loadWeightsAndDelays(self, filename, folder = "results"): f = open(folder+"/"+filename) self.variables = pickle.load(f) f.close() for ind in range(len(self.NetCons)): self.NetCons[ind].weight[0] = self.variables.NetCons_Weights[ind] self.NetCons[ind].delay = self.variables.NetCons_Delays[ind] for ind in range(len(self.NetCons_STDP_LtoL4)): self.NetCons_STDP_LtoL4[ind].weight[0] = self.variables.NetCons_STDP_LtoL4_Weights[ind] self.NetCons_STDP_LtoL4[ind].delay = self.variables.NetCons_STDP_LtoL4_Delays[ind] self.NetCons_STDP_C1toL4[ind].weight[0] = self.variables.NetCons_STDP_C1toL4_Weights[ind] self.NetCons_STDP_C1toL4[ind].delay = self.variables.NetCons_STDP_C1toL4_Delays[ind] self.NetCons_STDP_C2toL23[ind].weight[0] = self.variables.NetCons_STDP_C2toL23_Weights[ind] self.NetCons_STDP_C2toL23[ind].delay = self.variables.NetCons_STDP_C2toL23_Delays[ind] for ind in range(len(self.NetCons_STDP_L4toL23)): self.NetCons_STDP_L4toL23[ind].weight[0] = self.variables.NetCons_STDP_L4toL23_Weights[ind] self.NetCons_STDP_L4toL23[ind].delay = self.variables.NetCons_STDP_L4toL23_Delays[ind] self.NetCons_STDP_L23toL5[ind].weight[0] = self.variables.NetCons_STDP_L23toL5_Weights[ind] self.NetCons_STDP_L23toL5[ind].delay = self.variables.NetCons_STDP_L23toL5_Delays[ind] #set input that is currently presented to the network def setInput(self,inputStim,duration=1):#inputStim[r][g][b] #spike input delay = 0#self.variables.tstop * (1-duration)/2 eps = 0.0001 noDelay = 0; if(noDelay==0): for y in range(self.variables.dim_stim): for x in range(self.variables.dim_stim): r = (inputStim[y][x].r + inputStim[y][x].g * 0.7 + inputStim[y][x].b * 0.25)/(1+0.7+0.25); g = (inputStim[y][x].r * 0.7 + inputStim[y][x].g + inputStim[y][x].b * 0.25)/(1+0.7+0.25); b = inputStim[y][x].b self.r_stims[y][x].number = self.variables.hz*self.variables.tstop/1000*r+eps#*3#(average) number of spikes self.r_stims[y][x].interval = self.variables.tstop/self.r_stims[y][x].number# ms (mean) time between spikes if(delay+self.r_stims[y][x].interval*self.variables.delay_r[y][x]>self.variables.tstop*duration): self.r_stims[y][x].number = 0 self.r_stims[y][x].start = self.variables.tstop else: self.r_stims[y][x].start = (delay+self.r_stims[y][x].interval*self.variables.delay_r[y][x]) self.r_stims[y][x].number = (self.variables.tstop*duration - self.r_stims[y][x].start)/self.r_stims[y][x].interval self.g_stims[y][x].number = self.variables.hz*self.variables.tstop/1000*g+eps#*3#(average) number of spikes self.g_stims[y][x].interval = self.variables.tstop/self.g_stims[y][x].number# ms (mean) time between spikes if(delay+self.g_stims[y][x].interval*self.variables.delay_g[y][x]>self.variables.tstop*duration): self.g_stims[y][x].number = 0 self.g_stims[y][x].start = self.variables.tstop else: self.g_stims[y][x].start = delay+self.g_stims[y][x].interval*self.variables.delay_g[y][x] self.g_stims[y][x].number = (self.variables.tstop*duration - self.g_stims[y][x].start)/self.g_stims[y][x].interval self.b_stims[y][x].number = self.variables.hz*self.variables.tstop/1000*b+eps#*3#(average) number of spikes self.b_stims[y][x].interval = self.variables.tstop/self.b_stims[y][x].number# ms (mean) time between spikes if (delay+self.b_stims[y][x].interval*self.variables.delay_b[y][x]>self.variables.tstop*duration): self.b_stims[y][x].number = 0 self.b_stims[y][x].start = self.variables.tstop else: self.b_stims[y][x].start = (delay+self.b_stims[y][x].interval*self.variables.delay_b[y][x]) self.b_stims[y][x].number = (self.variables.tstop*duration - self.b_stims[y][x].start)/self.b_stims[y][x].interval # self.steadyActivation[y][x].number = self.variables.hz*self.variables.tstop/1000*self.variables.steady_state_activation # self.steadyActivation[y][x].interval = self.variables.tstop/self.steadyActivation[y][x].number# ms (mean) time between spikes # self.steadyActivation[y][x].start = (delay+self.steadyActivation[y][x].interval*self.variables.delay_steady[y][x])%(self.variables.tstop) # self.r_stim.number = self.variables.hz*self.variables.tstop/1000*(self.variables.steady_state_activation+(1-self.variables.steady_state_activation)*r)#*3#(average) number of spikes # self.r_stim.interval = self.variables.tstop/self.r_stim.number# ms (mean) time between spikes # self.r_stim.start = self.r_stim.interval/2#*random() # # self.g_stim.number = self.variables.hz*self.variables.tstop/1000*(self.variables.steady_state_activation+(1-self.variables.steady_state_activation)*g)#*3#(average) number of spikes # self.g_stim.interval = self.variables.tstop/self.g_stim.number# ms (mean) time between spikes # self.g_stim.start = self.g_stim.interval/2#*random() # # self.b_stim.number = self.variables.hz*self.variables.tstop/1000*(self.variables.steady_state_activation+(1-self.variables.steady_state_activation)*b)#*3#(average) number of spikes # self.b_stim.interval = self.variables.tstop/self.b_stim.number# ms (mean) time between spikes # self.b_stim.start = self.b_stim.interval/2#*random() else: for y in range(self.variables.dim_stim): for x in range(self.variables.dim_stim): r = (inputStim[y][x].r + inputStim[y][x].g * 0.7 + inputStim[y][x].b * 0.25)/(1+0.7+0.25); g = (inputStim[y][x].r * 0.7 + inputStim[y][x].g + inputStim[y][x].b * 0.25)/(1+0.7+0.25); b = inputStim[y][x].b self.r_stims[y][x].number = self.variables.hz*self.variables.tstop/1000*r+eps#*3#(average) number of spikes self.r_stims[y][x].interval = self.variables.tstop/self.r_stims[y][x].number# ms (mean) time between spikes if(delay>self.variables.tstop*duration): self.r_stims[y][x].number = 0 self.r_stims[y][x].start = self.variables.tstop else: self.r_stims[y][x].start = (delay) self.r_stims[y][x].number = (self.variables.tstop*duration - self.r_stims[y][x].start)/self.r_stims[y][x].interval self.g_stims[y][x].number = self.variables.hz*self.variables.tstop/1000*g+eps#*3#(average) number of spikes self.g_stims[y][x].interval = self.variables.tstop/self.g_stims[y][x].number# ms (mean) time between spikes if(delay>self.variables.tstop*duration): self.g_stims[y][x].number = 0 self.g_stims[y][x].start = self.variables.tstop else: self.g_stims[y][x].start = delay self.g_stims[y][x].number = (self.variables.tstop*duration - self.g_stims[y][x].start)/self.g_stims[y][x].interval self.b_stims[y][x].number = self.variables.hz*self.variables.tstop/1000*b+eps#*3#(average) number of spikes self.b_stims[y][x].interval = self.variables.tstop/self.b_stims[y][x].number# ms (mean) time between spikes if (delay>self.variables.tstop*duration): self.b_stims[y][x].number = 0 self.b_stims[y][x].start = self.variables.tstop else: self.b_stims[y][x].start = (delay) self.b_stims[y][x].number = (self.variables.tstop*duration - self.b_stims[y][x].start)/self.b_stims[y][x].interval def saveColor(self,r,g,b,itr): self.variables.trainingColors[itr,0] = r; self.variables.trainingColors[itr,1] = g; self.variables.trainingColors[itr,2] = b; #function to set Learning rate (learning rate decreases proportion to the training iterations) def setLR(self,progress): for index in range(self.variables.dim*self.variables.dim): self.cortexLayer_4[index].setLR(progress) # for index in range(self.variables.dim*self.variables.dim): # self.cortexLayer_2_3[index].setLR(1-progress) #function to start recording def recordChannelVols(self): #record voltage dynamics of neuron[0] in each channels self.vvolt_channel_L = [] for index in range(self.variables.dim*self.variables.dim): self.vvolt_channel_L.append(h.Vector(int(self.variables.tstop / h.dt) + 1)) # make a Vector self.vvolt_channel_L[index].record(self.L_channels[index].soma(0.5)._ref_v) self.vvolt_channel_C1 = [] for index in range(self.variables.dim*self.variables.dim): self.vvolt_channel_C1.append(h.Vector(int(self.variables.tstop / h.dt) + 1)) # make a Vector self.vvolt_channel_C1[index].record(self.C1_channels[index].soma(0.5)._ref_v) self.vvolt_channel_C2 = [] for index in range(self.variables.dim*self.variables.dim): self.vvolt_channel_C2.append(h.Vector(int(self.variables.tstop / h.dt) + 1)) # make a Vector self.vvolt_channel_C2[index].record(self.C2_channels[index].soma(0.5)._ref_v) def recordVols(self): #record voltage dynamics of all neurons in the cortex layer self.vvolt_cortexL_4 = [] for index in range(self.variables.dim*self.variables.dim): self.vvolt_cortexL_4.append(h.Vector(int(self.variables.tstop / h.dt) + 1)) # make a Vector self.vvolt_cortexL_4[index].record(self.cortexLayer_4[index].soma(0.5)._ref_v) self.vvolt_cortexL_2_3 = [] for index in range(self.variables.dim*self.variables.dim): self.vvolt_cortexL_2_3.append(h.Vector(int(self.variables.tstop / h.dt) + 1)) # make a Vector self.vvolt_cortexL_2_3[index].record(self.cortexLayer_2_3[index].soma(0.5)._ref_v) self.vvolt_cortexL_5 = [] for index in range(self.variables.dim*self.variables.dim): self.vvolt_cortexL_5.append(h.Vector(int(self.variables.tstop / h.dt) + 1)) # make a Vector self.vvolt_cortexL_5[index].record(self.cortexLayer_5[index].soma(0.5)._ref_v) def weightNormalization(self): #find Max LtoL4_avg = 0 C1toL4_avg = 0 C2toL23_avg = 0 L4toL23_avg = 0 L23toL5_avg = 0 #calculate average weight for index in range(len(self.NetCons_STDP_LtoL4)):#self.variables.dim*self.variables.dim): LtoL4_avg+=self.NetCons_STDP_LtoL4[index].weight[0] C1toL4_avg+=self.NetCons_STDP_C1toL4[index].weight[0] C2toL23_avg+=self.NetCons_STDP_C2toL23[index].weight[0] for index in range(len(self.NetCons_STDP_L4toL23)):#self.variables.dim*self.variables.dim): L4toL23_avg+=self.NetCons_STDP_L4toL23[index].weight[0] L23toL5_avg+=self.NetCons_STDP_L23toL5[index].weight[0] LtoL4_avg/=len(self.NetCons_STDP_LtoL4) C1toL4_avg/=len(self.NetCons_STDP_C1toL4) C2toL23_avg/=len(self.NetCons_STDP_C2toL23) L4toL23_avg/=len(self.NetCons_STDP_L4toL23) L23toL5_avg/=len(self.NetCons_STDP_L23toL5) # print "avg="+str([LtoL4_avg, C1toL4_avg, C2toL23_avg]) + "ideal=" +str((self.variables.maxWeight-self.variables.minWeight)/2) #calculate the differences between the ideal average values and actual average values LtoL4_mod = (self.variables.maxWeight-self.variables.minWeight)/2-LtoL4_avg C1toL4_mod = (self.variables.maxWeight-self.variables.minWeight)/2-C1toL4_avg C2toL23_mod = (self.variables.maxWeight*self.variables.maxWeightsMulti-self.variables.minWeight)/2-C2toL23_avg L4toL23_mod = (self.variables.maxWeight*self.variables.maxWeightsMulti-self.variables.minWeight)/2-L4toL23_avg L23toL5_mod = (self.variables.maxWeight*self.variables.maxWeightsMulti2-self.variables.minWeight)/2-L23toL5_avg # print "shift=" + str([LtoL4_mod, C1toL4_mod, C2toL23_mod]) #adjust the weight values to make the average is around 50% for index in range(len(self.NetCons_STDP_LtoL4)): tmp = self.NetCons_STDP_LtoL4[index].weight[0]+LtoL4_mod if(tmp>=self.variables.maxWeight): self.NetCons_STDP_LtoL4[index].weight[0] = self.variables.maxWeight # LtoL4_mod+=(tmp-self.variables.maxWeight)/(len(self.NetCons_STDP_LtoL4)-index) elif(tmp<=self.variables.minWeight): self.NetCons_STDP_LtoL4[index].weight[0] = self.variables.minWeight # LtoL4_mod-=(self.variables.minWeight-tmp)/(len(self.NetCons_STDP_LtoL4)-index) else: self.NetCons_STDP_LtoL4[index].weight[0] = tmp tmp = self.NetCons_STDP_C1toL4[index].weight[0]+C1toL4_mod if(tmp>=self.variables.maxWeight): self.NetCons_STDP_C1toL4[index].weight[0] = self.variables.maxWeight # C1toL4_mod+=(tmp-self.variables.maxWeight)/(len(self.NetCons_STDP_C1toL4)-index) elif(tmp<=self.variables.minWeight): self.NetCons_STDP_C1toL4[index].weight[0] = self.variables.minWeight # C1toL4_mod-=(self.variables.minWeight-tmp)/(len(self.NetCons_STDP_C1toL4)-index) else: self.NetCons_STDP_C1toL4[index].weight[0] = tmp tmp = self.NetCons_STDP_C2toL23[index].weight[0]+C2toL23_mod if(tmp>=self.variables.maxWeight*self.variables.maxWeightsMulti): self.NetCons_STDP_C2toL23[index].weight[0] = self.variables.maxWeight*self.variables.maxWeightsMulti # C2toL23_mod+=(tmp-self.variables.maxWeight*self.variables.maxWeightsMulti)/(len(self.NetCons_STDP_C2toL23)-index) elif(tmp<=self.variables.minWeight): self.NetCons_STDP_C2toL23[index].weight[0] = self.variables.minWeight # C2toL23_mod-=(self.variables.minWeight-tmp)/(len(self.NetCons_STDP_C2toL23)-index) else: self.NetCons_STDP_C2toL23[index].weight[0] = tmp for index in range(len(self.NetCons_STDP_L4toL23)): tmp = self.NetCons_STDP_L4toL23[index].weight[0]+L4toL23_mod if(tmp>=self.variables.maxWeight*self.variables.maxWeightsMulti): self.NetCons_STDP_L4toL23[index].weight[0] = self.variables.maxWeight*self.variables.maxWeightsMulti # L4toL23_mod+=(tmp-self.variables.maxWeight*self.variables.maxWeightsMulti)/(len(self.NetCons_STDP_L4toL23)-index) elif(tmp<=self.variables.minWeight): self.NetCons_STDP_L4toL23[index].weight[0] = self.variables.minWeight # L4toL23_mod-=(self.variables.minWeight-tmp)/(len(self.NetCons_STDP_L4toL23)-index) else: self.NetCons_STDP_L4toL23[index].weight[0] = tmp tmp = self.NetCons_STDP_L23toL5[index].weight[0]+L23toL5_mod if(tmp>=self.variables.maxWeight*self.variables.maxWeightsMulti2): self.NetCons_STDP_L23toL5[index].weight[0] = self.variables.maxWeight*self.variables.maxWeightsMulti2 # L23toL5_mod+=(tmp-self.variables.maxWeight*self.variables.maxWeightsMulti2)/(len(self.NetCons_STDP_L23toL5)-index) elif(tmp<=self.variables.minWeight): self.NetCons_STDP_L23toL5[index].weight[0] = self.variables.minWeight # L23toL5_mod-=(self.variables.minWeight-tmp)/(len(self.NetCons_STDP_L23toL5)-index) else: self.NetCons_STDP_L23toL5[index].weight[0] = tmp # # def weightNormalization2(self): # #find Max # LtoL4_div = 0 # C1toL4_div = 0 # C2toL23_div = 0 # L4toL23_div = 0 # L23toL5_div = 0 # # #calculate average weight # for index in range(len(self.NetCons_STDP_LtoL4)):#self.variables.dim*self.variables.dim): # LtoL4_div+=pow(self.NetCons_STDP_LtoL4[index].weight[0],2) # C1toL4_div+=pow(self.NetCons_STDP_C1toL4[index].weight[0],2) # C2toL23_div+=pow(self.NetCons_STDP_C2toL23[index].weight[0],2) # for index in range(len(self.NetCons_STDP_L4toL23)):#self.variables.dim*self.variables.dim): # L4toL23_div+=pow(self.NetCons_STDP_L4toL23[index].weight[0],2) # L23toL5_div+=pow(self.NetCons_STDP_L23toL5[index].weight[0],2) # # #adjust the weight values to make the average is around 50% # for index in range(len(self.NetCons_STDP_LtoL4)): # self.NetCons_STDP_LtoL4[index].weight[0]= self.NetCons_STDP_LtoL4[index].weight[0]/math.sqrt(LtoL4_div)*self.variables.maxWeight # self.NetCons_STDP_C1toL4[index].weight[0] = self.NetCons_STDP_C1toL4[index].weight[0]/math.sqrt(C1toL4_div)*self.variables.maxWeight # self.NetCons_STDP_C2toL23[index].weight[0] = self.NetCons_STDP_C2toL23[index].weight[0]/math.sqrt(C2toL23_div)*self.variables.maxWeight*self.variables.maxWeightsMulti # # for index in range(len(self.NetCons_STDP_L4toL23)): # self.NetCons_STDP_L4toL23[index].weight[0] = self.NetCons_STDP_L4toL23[index].weight[0]/math.sqrt(L4toL23_div)*self.variables.maxWeight*self.variables.maxWeightsMulti # self.NetCons_STDP_L23toL5[index].weight[0] = self.NetCons_STDP_L23toL5[index].weight[0]/math.sqrt(L23toL5_div)*self.variables.maxWeight*self.variables.maxWeightsMulti2 # def saveSpikeDetails(self,r,g,b,itr): #output voltage dynamics of each cells in the cortex layer f = open(self.resultFolderName+"/L4_firing_"+str(itr)+"_"+str([r, g, b])+".txt", "w") for index in range(len(self.vvolt_cortexL_4)): f.write(str(r)+str(g)+str(b)+",") for t in range(len(self.vvolt_cortexL_4[index])): if t>0: f.write(",") if (self.vvolt_cortexL_4[index][t]>0): f.write(str(1)) else: f.write(str(0)) f.write("\n") f.write("\n") f.close() f = open(self.resultFolderName+"/L23_firing_"+str(itr)+"_"+str([r, g, b])+".txt", "w") for index in range(len(self.vvolt_cortexL_2_3)): f.write(str(r)+str(g)+str(b)+",") for t in range(len(self.vvolt_cortexL_2_3[index])): if t>0: f.write(",") if (self.vvolt_cortexL_2_3[index][t]>0): f.write(str(1)) else: f.write(str(0)) f.write("\n") f.write("\n") f.close() f = open(self.resultFolderName+"/L5_firing_"+str(itr)+"_"+str([r, g, b])+".txt", "w") for index in range(len(self.vvolt_cortexL_5)): f.write(str(r)+str(g)+str(b)+",") for t in range(len(self.vvolt_cortexL_5[index])): if t>0: f.write(",") if (self.vvolt_cortexL_5[index][t]>0): f.write(str(1)) else: f.write(str(0)) f.write("\n") f.write("\n") f.close() def saveChannelSpikeDetails(self,r,g,b,itr): #output voltage dynamics of each cells in the cortex layer f = open(self.resultFolderName+"/L_firing_"+str(itr)+"_"+str([r, g, b])+".txt", "w") for index in range(len(self.vvolt_channel_L)): f.write(str(r)+str(g)+str(b)+",") for t in range(len(self.vvolt_channel_L[index])): if t>0: f.write(",") if (self.vvolt_channel_L[index][t]>0): f.write(str(1)) else: f.write(str(0)) f.write("\n") f.write("\n") f.close() f = open(self.resultFolderName+"/C1_firing_"+str(itr)+"_"+str([r, g, b])+".txt", "w") for index in range(len(self.vvolt_channel_C1)): f.write(str(r)+str(g)+str(b)+",") for t in range(len(self.vvolt_channel_C1[index])): if t>0: f.write(",") if (self.vvolt_channel_C1[index][t]>0): f.write(str(1)) else: f.write(str(0)) f.write("\n") f.write("\n") f.close() f = open(self.resultFolderName+"/C2_firing_"+str(itr)+"_"+str([r, g, b])+".txt", "w") for index in range(len(self.vvolt_channel_C2)): f.write(str(r)+str(g)+str(b)+",") for t in range(len(self.vvolt_channel_C2[index])): if t>0: f.write(",") if (self.vvolt_channel_C2[index][t]>0): f.write(str(1)) else: f.write(str(0)) f.write("\n") f.write("\n") f.close() #save FR data (if a stimulus undergoes transformation; i.e., input contains colour regarded as the same but slightly different in this case) def outputFR_trans(self,r,g,b,itr): #output spike counts of each cell f = open(self.resultFolderName+"/trans_L23_FR_"+str(itr)+"_"+str([r, g, b])+".txt", "a") for y in range(self.variables.dim): for x in range(self.variables.dim): index = y*self.variables.dim+x f.write(str(self.spikeCount_L23[y][x])) if(index != self.variables.dim*self.variables.dim-1): f.write(",") f.write("\n") f.close() f = open(self.resultFolderName+"/trans_L4_FR_"+str(itr)+"_"+str([r, g, b])+".txt", "a") for y in range(self.variables.dim): for x in range(self.variables.dim): index = y*self.variables.dim+x f.write(str(self.spikeCount_L4[y][x])) if(index != self.variables.dim*self.variables.dim-1): f.write(",") f.write("\n") f.close() f = open(self.resultFolderName+"/trans_L5_FR_"+str(itr)+"_"+str([r, g, b])+".txt", "a") for y in range(self.variables.dim): for x in range(self.variables.dim): index = y*self.variables.dim+x f.write(str(self.spikeCount_L5[y][x])) if(index != self.variables.dim*self.variables.dim-1): f.write(",") f.write("\n") f.close() #save FR data (without any transformation) def outputFR(self,itr): #output spike counts of each cell f = open(self.resultFolderName+"/L4_FR_"+str(itr)+".txt", "a") for y in range(self.variables.dim): for x in range(self.variables.dim): index = y*self.variables.dim+x f.write(str(self.spikeCount_L4[y][x])) if(index != self.variables.dim*self.variables.dim-1): f.write(",") f.write("\n") f.close() f = open(self.resultFolderName+"/L23_FR_"+str(itr)+".txt", "a") for y in range(self.variables.dim): for x in range(self.variables.dim): index = y*self.variables.dim+x f.write(str(self.spikeCount_L23[y][x])) if(index != self.variables.dim*self.variables.dim-1): f.write(",") f.write("\n") f.close() f = open(self.resultFolderName+"/L5_FR_"+str(itr)+".txt", "a") for y in range(self.variables.dim): for x in range(self.variables.dim): index = y*self.variables.dim+x f.write(str(self.spikeCount_L5[y][x])) if(index != self.variables.dim*self.variables.dim-1): f.write(",") f.write("\n") f.close() def updateAllSpikeCount(self):#including channels self.updateSpikeCount() dim = self.variables.dim self.spikeCount_L = [[0 for x in xrange(dim)] for x in xrange(dim)] for y in range(dim): for x in range(dim): index = y*dim+x for _i in range(int(self.variables.tstop / h.dt) + 1): if self.vvolt_channel_L[index][_i]>0: if (_i>0 and self.vvolt_channel_L[index][_i-1]>0): continue self.spikeCount_L[y][x] += 1#self.vvolt_cortexL_4[index][_i] self.spikeCount_C1 = [[0 for x in xrange(dim)] for x in xrange(dim)] for y in range(dim): for x in range(dim): index = y*dim+x for _i in range(int(self.variables.tstop / h.dt) + 1): if self.vvolt_channel_C1[index][_i]>0: if (_i>0 and self.vvolt_channel_C1[index][_i-1]>0): continue self.spikeCount_C1[y][x] += 1#self.vvolt_cortexL_4[index][_i] self.spikeCount_C2 = [[0 for x in xrange(dim)] for x in xrange(dim)] for y in range(dim): for x in range(dim): index = y*dim+x for _i in range(int(self.variables.tstop / h.dt) + 1): if self.vvolt_channel_C2[index][_i]>0: if (_i>0 and self.vvolt_channel_C2[index][_i-1]>0): continue self.spikeCount_C2[y][x] += 1#self.vvolt_cortexL_4[index][_i] #function to count number of spikes def updateSpikeCount(self): dim = self.variables.dim self.spikeCount_L4 = [[0 for x in xrange(dim)] for x in xrange(dim)] for y in range(dim): for x in range(dim): index = y*dim+x for _i in range(int(self.variables.tstop / h.dt) + 1): if self.vvolt_cortexL_4[index][_i]>0: if (_i>0 and self.vvolt_cortexL_4[index][_i-1]>0): continue self.spikeCount_L4[y][x] += 1#self.vvolt_cortexL_4[index][_i] self.spikeCount_L23 = [[0 for x in xrange(dim)] for x in xrange(dim)] for y in range(dim): for x in range(dim): index = y*dim+x for _i in range(int(self.variables.tstop / h.dt) + 1): if self.vvolt_cortexL_2_3[index][_i]>0: if (_i>0 and self.vvolt_cortexL_2_3[index][_i-1]>0): continue self.spikeCount_L23[y][x] += 1#self.vvolt_cortexL_4[index][_i] self.spikeCount_L5 = [[0 for x in xrange(dim)] for x in xrange(dim)] for y in range(dim): for x in range(dim): index = y*dim+x for _i in range(int(self.variables.tstop / h.dt) + 1): if self.vvolt_cortexL_5[index][_i]>0: if (_i>0 and self.vvolt_cortexL_5[index][_i-1]>0): continue self.spikeCount_L5[y][x] += 1#self.vvolt_cortexL_4[index][_i] def hebbUpdate(self):#todo sometime in the future self.updateAllSpikeCount() #C1 #update the weights based on the firing count at the end of each iteration #to change synaptic modifications are active or not def setLearningStates(self,state):#state=0: no learning, state=1:learning is active self.learningState = state for index in range(self.variables.dim*self.variables.dim): self.cortexLayer_4[index].setLearningState(state) self.cortexLayer_2_3[index].setLearningState(state) self.cortexLayer_5[index].setLearningState(state) #to plot voltage changes with neuron simulator's GUI def drawGraph(self): g = h.Graph() self.vvolt_channel_L[0].plot(g, h.dt, 1, 1)#black self.vvolt_channel_C1[0].plot(g, h.dt, 2, 1)#red self.vvolt_channel_C2[0].plot(g, h.dt, 3, 1)#blue self.vvolt_cortexL_4[0].plot(g, h.dt, 4, 1)#light green g.exec_menu("View = plot") # set Graph view to what was drawn raw_input("Press Enter to exit...") def run(self): h.tstop = self.variables.tstop fihns = h.FInitializeHandler(0, self.myInitNetStims) # create an object h.run()