def gen_input_to_output_proj(self, params=None):
pops = self._network['populations']
proj = sim.Projection(
pops['input'],
pops['output'],
sim.AllToAllConnector(),
sim.StaticSynapse(
weight=-5.0,
delay=0.1, # ms (equals timestep here)
#label='input to output',
#receptor_type='inhibitory'
))
return proj
def build_network(ie_synapse, e_mean_firing_rate):
# Create excitatory and inhibitory populations of neurons
ex_pop = sim.Population(NUM_EXCITATORY, model(**cell_params), label="E")
in_pop = sim.Population(NUM_EXCITATORY / 4,
model(**cell_params),
label="I")
# Randomize initial membrane voltages
#rng = sim.NativeRNG(host_rng=NumpyRNG())
rng = sim.NumpyRNG()
uniformDistr = RandomDistribution('uniform',
low=-60.0,
high=-50.0,
rng=rng)
ex_pop.initialize(v=uniformDistr)
in_pop.initialize(v=uniformDistr)
# Record excitatory spikes
ex_pop.record("spikes")
# Make excitatory->inhibitory projections
static_synapse = sim.StaticSynapse(weight=0.03)
connector = sim.FixedProbabilityConnector(0.02, rng=rng)
sim.Projection(ex_pop,
in_pop,
connector,
static_synapse,
receptor_type='excitatory')
sim.Projection(ex_pop,
ex_pop,
connector,
static_synapse,
receptor_type='excitatory')
# Make inhibitory->inhibitory projections
sim.Projection(in_pop,
in_pop,
connector,
static_synapse,
receptor_type='inhibitory')
# Make inhibitory->excitatory projections
ie_projection = sim.Projection(in_pop,
ex_pop,
connector,
ie_synapse,
receptor_type='inhibitory')
return ex_pop, ie_projection
IF_curr_exp_i(**parameters),
label='output standard',
)
postStd.record(['v', 'spikes'])
postShunt = sim.Population(
n_neurons,
IF_curr_exp_i(**parameters),
label='output shunt',
)
postShunt.record(['v', 'spikes'])
eProjStd = sim.Projection(
preExc,
postStd,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=5.),
receptor_type='excitatory',
label='exc_proj_std',
)
eProjShunt = sim.Projection(
preExc,
postShunt,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=5.),
receptor_type='excitatory',
label='exc_proj_shunt',
)
iProj = sim.Projection(
preInh,
postStd,
def buildNetworkAndConnections(sim, ImageNumPixelRows, ImageNumPixelColumns, numOrientations, oriFilterSize, V1PoolSize, V2PoolSize, phi,
connections, normalCellType, numSegmentationLayers, useBoundarySegmentation, useSurfaceSegmentation):
#########################################################
### Build orientation filters and connection patterns ###
#########################################################
sys.stdout.write('\nSetting up orientation filters...')
# Boundary coordinates (boundaries exist at positions between retinotopic coordinates, so add extra pixel on each side to insure a boundary could exists for retinal pixel)
numPixelRows = ImageNumPixelRows + 1 # height for oriented neurons (placed between un-oriented pixels)
numPixelColumns = ImageNumPixelColumns + 1 # width for oriented neurons (placed between un-oriented pixels)
# Set the orientation filters (orientation kernels, V1 and V2 layer23 pooling filters)
filters1, filters2 = createFilters(numOrientations, oriFilterSize, sigma2=0.75, Olambda=4, phi=phi)
V1PoolingFilters, V1PoolingConnections1, V1PoolingConnections2 = createPoolingConnectionsAndFilters(numOrientations, VPoolSize=V1PoolSize, sigma2=4.0, Olambda=5, phi=phi)
V2PoolingFilters, V2PoolingConnections1, V2PoolingConnections2 = createPoolingConnectionsAndFilters(numOrientations, VPoolSize=V2PoolSize, sigma2=26.0, Olambda=9, phi=phi)
OppositeOrientationIndex = list(numpy.roll(range(numOrientations), numOrientations//2))
# For numOrientations = 2, orientation indexes = [vertical, horizontal] -> opposite orientation indexes = [horizontal, vertical]
# For numOrientations = 4, orientation indexes = [ /, |, \, - ] -> opposite orientation indexes = [ \, -, \, | ]
# For numOrientations = 8, [ /h, /, /v, |, \v, \, \h, - ] -> [ \v, \, \h, -, /h, /, /v, | ] ([h,v] = [more horizontal, more vertical])
# Set up filters for filling-in stage (spreads in various directions).
# Interneurons receive inhib. input from all but boundary ori. that matches flow direction. Up, Right (Down and Left are defined implicitly by these)
numFlows = 2 # (brightness/darkness) right and down
flowFilter = [[1,0], [0,1]] # down, right ; default is [[1,0],[0,1]]
# Specify flow orientation (all others block) and position of blockers (different subarrays are for different flow directions)
# BoundaryBlockFilter = [[[vertical, 1, 1], [vertical, 1, 0]], [[horizontal, 1, 1], [horizontal, 0, 1]]]
# 1 added to each offset position because boundary grid is (1,1) offset from brightness grid
BoundaryBlockFilter = [[[numOrientations/2-1, 1, 1], [numOrientations/2-1, 1, 0]], [[numOrientations-1, 1, 1], [numOrientations-1, 0, 1]]]
########################################################################################################################
### Create the neuron layers ((Retina,) LGN, V1, V2, V4, Boundary and Surface Segmentation Layers) + Spike Detectors ###
########################################################################################################################
sys.stdout.write('Done. \nDefining cells...')
sys.stdout.flush()
# LGN
sys.stdout.write('LGN,...')
sys.stdout.flush()
# Neural LGN cells will receive input values from LGN
LGNBright = sim.Population(ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="LGNBright")
LGNDark = sim.Population(ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="LGNDark")
# Area V1
sys.stdout.write('V1,...')
sys.stdout.flush()
# Simple oriented neurons
V1Layer6P1 = sim.Population(numOrientations*numPixelRows*numPixelColumns, normalCellType)
V1Layer6P2 = sim.Population(numOrientations*numPixelRows*numPixelColumns, normalCellType)
V1Layer4P1 = sim.Population(numOrientations*numPixelRows*numPixelColumns, normalCellType)
V1Layer4P2 = sim.Population(numOrientations*numPixelRows*numPixelColumns, normalCellType)
# Complex cells
V1Layer23 = sim.Population(numOrientations*numPixelRows*numPixelColumns, normalCellType, label="V1LayerToPlot")
V1Layer23Pool = sim.Population(numOrientations*numPixelRows*numPixelColumns, normalCellType)
V1Layer23Inter1 = sim.Population(numOrientations*numPixelRows*numPixelColumns, normalCellType)
V1Layer23Inter2 = sim.Population(numOrientations*numPixelRows*numPixelColumns, normalCellType)
###### All subsequent areas have multiple segmentation representations
# Area V2
sys.stdout.write('V2,...')
sys.stdout.flush()
V2Layer23Inter1 = sim.Population(numSegmentationLayers*numOrientations*numPixelRows*numPixelColumns, normalCellType)
V2Layer23Inter2 = sim.Population(numSegmentationLayers*numOrientations*numPixelRows*numPixelColumns, normalCellType)
V2Layer6 = sim.Population(numSegmentationLayers*numOrientations*numPixelRows*numPixelColumns, normalCellType)
V2Layer4 = sim.Population(numSegmentationLayers*numOrientations*numPixelRows*numPixelColumns, normalCellType)
V2Layer23 = sim.Population(numSegmentationLayers*numOrientations*numPixelRows*numPixelColumns, normalCellType, label="V2LayerToPlot")
V2Layer23Pool = sim.Population(numSegmentationLayers*numOrientations*numPixelRows*numPixelColumns, normalCellType)
# Area V4
sys.stdout.write('V4,...')
sys.stdout.flush()
V4Brightness = sim.Population(numSegmentationLayers*ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="V4Brightness")
V4InterBrightness1 = sim.Population(numSegmentationLayers*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
V4InterBrightness2 = sim.Population(numSegmentationLayers*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
V4Darkness = sim.Population(numSegmentationLayers*ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="V4Darkness")
V4InterDarkness1 = sim.Population(numSegmentationLayers*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
V4InterDarkness2 = sim.Population(numSegmentationLayers*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
if numSegmentationLayers>1:
if useSurfaceSegmentation==1:
# Surface Segmentation cells
sys.stdout.write('Surface,...')
sys.stdout.flush()
SurfaceSegmentationOn = sim.Population((numSegmentationLayers-1)*ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="SurfaceSegmentationOn")
SurfaceSegmentationOnInter1 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
SurfaceSegmentationOnInter2 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
SurfaceSegmentationOff = sim.Population((numSegmentationLayers-1)*ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="SurfaceSegmentationOff")
SurfaceSegmentationOffInter1 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
SurfaceSegmentationOffInter2 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
if useBoundarySegmentation==1:
# Boundary Segmentation cells
sys.stdout.write('Boundary,...')
sys.stdout.flush()
BoundarySegmentationOn = sim.Population((numSegmentationLayers-1)*ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="BoundarySegmentationOn")
BoundarySegmentationOnInter1 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
BoundarySegmentationOnInter2 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
BoundarySegmentationOnInter3 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="BoundarySegmentationOnInter3")
BoundarySegmentationOff = sim.Population((numSegmentationLayers-1)*ImageNumPixelRows*ImageNumPixelColumns, normalCellType, label="BoundarySegmentationOff")
BoundarySegmentationOffInter1 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
BoundarySegmentationOffInter2 = sim.Population((numSegmentationLayers-1)*numFlows*ImageNumPixelRows*ImageNumPixelColumns, normalCellType)
######################################################################
### Neurons layers are defined, now set up connexions between them ###
######################################################################
synapseCount = 0
############### Area V1 ##################
sys.stdout.write('done. \nSetting up V1, Layers 4 and 6...')
sys.stdout.flush()
oriFilterWeight = connections['LGN_ToV1Excite']
for k in range(0, numOrientations): # Orientations
for i2 in range(-oriFilterSize//2, oriFilterSize//2): # Filter rows
for j2 in range(-oriFilterSize//2, oriFilterSize//2): # Filter columns
ST = [] # Source-Target vector containing indexes of neurons to connect within specific layers
ST2 = [] # Second Source-Target vector for another connection
for i in range(oriFilterSize//2, numPixelRows-oriFilterSize//2): # Rows
for j in range(oriFilterSize//2, numPixelColumns-oriFilterSize//2): # Columns
if i+i2 >=0 and i+i2<ImageNumPixelRows and j+j2>=0 and j+j2<ImageNumPixelColumns:
# Dark inputs use reverse polarity filter
if abs(filters1[k][i2+oriFilterSize//2][j2+oriFilterSize//2]) > 0.1:
ST.append(((i+i2)*ImageNumPixelColumns + (j+j2),
k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
if abs(filters2[k][i2+oriFilterSize//2][j2+oriFilterSize//2]) > 0.1:
ST2.append(((i+i2)*ImageNumPixelColumns + (j+j2),
k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
if len(ST)>0:
# LGN -> Layer 6 and 4 (simple cells) connections (no connections at the edges, to avoid edge-effects) first polarity filter
sim.Projection(LGNBright, V1Layer6P1, MyConnector(ST),
sim.StaticSynapse(weight=oriFilterWeight*filters1[k][i2+oriFilterSize//2][j2+oriFilterSize//2]))
sim.Projection(LGNDark, V1Layer6P2, MyConnector(ST),
sim.StaticSynapse(weight=oriFilterWeight*filters1[k][i2+oriFilterSize//2][j2+oriFilterSize//2]))
sim.Projection(LGNBright, V1Layer4P1, MyConnector(ST),
sim.StaticSynapse(weight=oriFilterWeight*filters1[k][i2+oriFilterSize//2][j2+oriFilterSize//2]))
sim.Projection(LGNDark, V1Layer4P2, MyConnector(ST),
sim.StaticSynapse(weight=oriFilterWeight*filters1[k][i2+oriFilterSize//2][j2+oriFilterSize//2]))
synapseCount += 4*len(ST)
if len(ST2)>0:
# LGN -> Layer 6 and 4 (simple cells) connections (no connections at the edges, to avoid edge-effects) second polarity filter
sim.Projection(LGNBright, V1Layer6P2, MyConnector(ST2),
sim.StaticSynapse(weight=oriFilterWeight*filters2[k][i2+oriFilterSize//2][j2+oriFilterSize//2]))
sim.Projection(LGNDark, V1Layer6P1, MyConnector(ST2),
sim.StaticSynapse(weight=oriFilterWeight*filters2[k][i2+oriFilterSize//2][j2+oriFilterSize//2]))
sim.Projection(LGNBright, V1Layer4P2, MyConnector(ST2),
sim.StaticSynapse(weight=oriFilterWeight*filters2[k][i2+oriFilterSize//2][j2+oriFilterSize//2]))
sim.Projection(LGNDark, V1Layer4P1, MyConnector(ST2),
sim.StaticSynapse(weight=oriFilterWeight*filters2[k][i2+oriFilterSize//2][j2+oriFilterSize//2]))
synapseCount += 4*len(ST2)
# Excitatory connection from same orientation and polarity 1, input from layer 6
sim.Projection(V1Layer6P1, V1Layer4P1, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V1_6To4Excite']))
sim.Projection(V1Layer6P2, V1Layer4P2, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V1_6To4Excite']))
synapseCount += (len(V1Layer6P1)+len(V1Layer6P2))
ST = [] # Source-Target vector containing indexes of neurons to connect within specific layers
for k in range(0, numOrientations): # Orientations
for i in range(0, numPixelRows): # Rows
for j in range(0, numPixelColumns): # Columns
for i2 in range(-1,1):
for j2 in range(-1,1):
if i2!=0 or j2!=0:
if i+i2 >=0 and i+i2 <numPixelRows and j+j2>=0 and j+j2<numPixelColumns:
ST.append((k*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
# Surround inhibition from layer 6 of same orientation and polarity
sim.Projection(V1Layer6P1, V1Layer4P1, MyConnector(ST),
sim.StaticSynapse(weight=connections['V1_6To4Inhib']))
sim.Projection(V1Layer6P2, V1Layer4P2, MyConnector(ST),
sim.StaticSynapse(weight=connections['V1_6To4Inhib']))
synapseCount += 2*len(ST)
sys.stdout.write('done. \nSetting up V1, Layers 23 and 6 (feedback)...')
sys.stdout.flush()
ST = []
ST2 = []
ST3 = []
ST4 = []
ST5 = []
ST6 = []
for k in range(0, numOrientations): # Orientations
for i in range(0, numPixelRows): # Rows
for j in range(0, numPixelColumns): # Columns
for k2 in range(0, numOrientations): # Other orientations
if k != k2:
ST.append((k*numPixelRows*numPixelColumns + i*numPixelColumns + j,
k2*numPixelRows*numPixelColumns + i*numPixelColumns + j))
for i2 in range(-V1PoolSize//2+1, V1PoolSize//2+1): # Filter rows (extra +1 to insure get top of odd-numbered filter)
for j2 in range(-V1PoolSize//2+1, V1PoolSize//2+1): # Filter columns
if V1PoolingFilters[k][i2+V1PoolSize//2][j2+V1PoolSize//2] > 0:
if i+i2 >= 0 and i+i2 < ImageNumPixelRows and j+j2 >= 0 and j+j2 < ImageNumPixelColumns:
ST2.append((k*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
ST3.append((OppositeOrientationIndex[k]*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
if V1PoolingConnections1[k][i2+V1PoolSize//2][j2+V1PoolSize//2] > 0:
if i+i2 >= 0 and i+i2 < ImageNumPixelRows and j+j2 >= 0 and j+j2 < ImageNumPixelColumns:
ST4.append((k*numPixelRows*numPixelColumns + i*numPixelColumns + j,
k*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2)))
if V1PoolingConnections2[k][i2+V1PoolSize//2][j2+V1PoolSize//2] > 0:
if i+i2 >= 0 and i+i2 < ImageNumPixelRows and j+j2 >= 0 and j+j2 < ImageNumPixelColumns:
ST5.append((k*numPixelRows*numPixelColumns + i*numPixelColumns + j,
k*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2)))
ST6.append((OppositeOrientationIndex[k]*numPixelRows*numPixelColumns + i*numPixelColumns + j,
k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
# Layer 4 -> Layer23 (complex cell connections)
sim.Projection(V1Layer4P1, V1Layer23, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V1_4To23Excite']))
sim.Projection(V1Layer4P2, V1Layer23, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V1_4To23Excite']))
synapseCount += (len(V1Layer4P1)+len(V1Layer4P2))
# Cross-orientation inhibition
sim.Projection(V1Layer23, V1Layer23, MyConnector(ST), sim.StaticSynapse(weight=connections['V1_CrossOriInhib']))
synapseCount += len(ST)
# Pooling neurons in Layer 23 (excitation from same orientation, inhibition from orthogonal), V1PoolingFilters pools from both sides
sim.Projection(V1Layer23, V1Layer23Pool, MyConnector(ST2), sim.StaticSynapse(weight=connections['V1_ComplexExcite']))
sim.Projection(V1Layer23, V1Layer23Pool, MyConnector(ST3), sim.StaticSynapse(weight=connections['V1_ComplexInhib']))
synapseCount += (len(ST2) + len(ST3))
# Pooling neurons back to Layer 23 and to interneurons (ST4 for one side and ST5 for the other), V1poolingconnections pools from only one side
sim.Projection(V1Layer23Pool, V1Layer23, MyConnector(ST4), sim.StaticSynapse(weight=connections['V1_FeedbackExcite']))
sim.Projection(V1Layer23Pool, V1Layer23Inter1, MyConnector(ST4), sim.StaticSynapse(weight=connections['V1_FeedbackExcite']))
sim.Projection(V1Layer23Pool, V1Layer23Inter2, MyConnector(ST4), sim.StaticSynapse(weight=connections['V1_NegFeedbackInhib']))
sim.Projection(V1Layer23Pool, V1Layer23, MyConnector(ST5), sim.StaticSynapse(weight=connections['V1_FeedbackExcite']))
sim.Projection(V1Layer23Pool, V1Layer23Inter2, MyConnector(ST5), sim.StaticSynapse(weight=connections['V1_FeedbackExcite']))
sim.Projection(V1Layer23Pool, V1Layer23Inter1, MyConnector(ST5), sim.StaticSynapse(weight=connections['V1_NegFeedbackInhib']))
synapseCount += 3*(len(ST4) + len(ST5))
# Connect interneurons to complex cell and each other
sim.Projection(V1Layer23Inter1, V1Layer23, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V1_InterInhib']))
sim.Projection(V1Layer23Inter2, V1Layer23, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V1_InterInhib']))
synapseCount += (len(V1Layer23Inter1) + len(V1Layer23Inter2))
# End-cutting (excitation from orthogonal interneuron)
sim.Projection(V1Layer23Inter1, V1Layer23, MyConnector(ST6), sim.StaticSynapse(weight=connections['V1_EndCutExcite']))
sim.Projection(V1Layer23Inter2, V1Layer23, MyConnector(ST6), sim.StaticSynapse(weight=connections['V1_EndCutExcite']))
synapseCount += 2*len(ST6)
# Connect Layer 23 cells to Layer 6 cells (folded feedback)
sim.Projection(V1Layer23, V1Layer6P1, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V1_23To6Excite']))
sim.Projection(V1Layer23, V1Layer6P2, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V1_23To6Excite']))
synapseCount += 2*len(V1Layer23)
############### Area V2 #################
sys.stdout.write('done. \nSetting up V2, Layers 4 and 6...')
sys.stdout.flush()
inhibRange64=1
ST = []
ST2 = []
for h in range(0, numSegmentationLayers): # segmentation layers
for k in range(0, numOrientations): # Orientations
for i in range(0, numPixelRows): # Rows
for j in range(0, numPixelColumns): # Columns
ST.append((k*numPixelRows*numPixelColumns + i*numPixelColumns + j,
h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
for i2 in range(-inhibRange64, inhibRange64+1):
for j2 in range(-inhibRange64, inhibRange64+1):
if i+i2 >=0 and i+i2 <numPixelRows and i2!=0 and j+j2 >=0 and j+j2 <numPixelColumns and j2!=0:
ST2.append((h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
# V2 Layers 4 and 6 connections
sim.Projection(V1Layer23, V2Layer6, MyConnector(ST), sim.StaticSynapse(weight=connections['V1_ToV2Excite']))
sim.Projection(V1Layer23, V2Layer4, MyConnector(ST), sim.StaticSynapse(weight=connections['V1_ToV2Excite']))
sim.Projection(V2Layer6, V2Layer4, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V2_6To4Excite']))
synapseCount += (2*len(ST) + len(V2Layer6))
# Surround inhibition V2 Layer 6 -> 4
sim.Projection(V2Layer6, V2Layer4, MyConnector(ST2), sim.StaticSynapse(weight=connections['V2_6To4Inhib']))
synapseCount += len(ST2)
sys.stdout.write('done. \nSetting up V2, Layers 23 and 6 (feedback)...')
sys.stdout.flush()
ST = []
ST2 = []
ST3 = []
ST4 = []
ST5 = []
ST6 = []
for h in range(0, numSegmentationLayers): # segmentation layers
for k in range(0, numOrientations): # Orientations
for i in range(0, numPixelRows): # Rows
for j in range(0, numPixelColumns): # Columns
ST.append((h*numOrientations*numPixelRows*numPixelColumns + OppositeOrientationIndex[k]*numPixelRows*numPixelColumns + i*numPixelColumns + j,
h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
for i2 in range(-V2PoolSize//2+1, V2PoolSize//2+1): # Filter rows (extra +1 to insure get top of odd-numbered filter)
for j2 in range(-V2PoolSize//2+1, V2PoolSize//2+1): # Filter columns
if V2PoolingFilters[k][i2+V2PoolSize//2][j2+V2PoolSize//2] > 0:
if i+i2 >= 0 and i+i2 < ImageNumPixelRows and j+j2 >= 0 and j+j2 < ImageNumPixelColumns:
ST2.append((h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
for k2 in range(0, numOrientations):
if k2 != k:
if k2 == OppositeOrientationIndex[k]:
for h2 in range(numSegmentationLayers): # for all segmentation layers
ST3.append((h2*numOrientations*numPixelRows*numPixelColumns + k2*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
else:
ST4.append((h*numOrientations*numPixelRows*numPixelColumns + k2*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + i*numPixelColumns + j))
if V2PoolingConnections1[k][i2+V2PoolSize//2][j2+V2PoolSize//2] > 0:
if i+i2 >= 0 and i+i2 < ImageNumPixelRows and j+j2 >= 0 and j+j2 < ImageNumPixelColumns:
ST5.append((h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + i*numPixelColumns + j,
h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2)))
if V2PoolingConnections2[k][i2+V2PoolSize//2][j2+V2PoolSize//2] > 0:
if i+i2 >= 0 and i+i2 < ImageNumPixelRows and j+j2 >= 0 and j+j2 < ImageNumPixelColumns:
ST6.append((h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + i*numPixelColumns + j,
h*numOrientations*numPixelRows*numPixelColumns + k*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2)))
# V2 Layer 4 -> V2 Layer23 (complex cell connections)
sim.Projection(V2Layer4, V2Layer23, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V2_4To23Excite']))
synapseCount += len(V2Layer4)
# Cross-orientation inhibition
sim.Projection(V2Layer23, V2Layer23, MyConnector(ST), sim.StaticSynapse(weight=connections['V2_CrossOriInhib']))
synapseCount += len(ST)
# Pooling neurons in V2Layer 23 (excitation from same orientation, inhibition from different + stronger for orthogonal orientation)
sim.Projection(V2Layer23, V2Layer23Pool, MyConnector(ST2), sim.StaticSynapse(weight=connections['V2_ComplexExcite']))
sim.Projection(V2Layer23, V2Layer23Pool, MyConnector(ST3), sim.StaticSynapse(weight=connections['V2_ComplexInhib']))
synapseCount += (len(ST2) + len(ST3))
if len(ST4) > 0: # non-orthogonal inhibition
sim.Projection(V2Layer23, V2Layer23Pool, MyConnector(ST4), sim.StaticSynapse(weight=connections['V2_ComplexInhib2']))
synapseCount += len(ST4)
# Pooling neurons back to Layer 23 and to interneurons (ST5 for one side and ST6 for the other), V1poolingconnections pools from only one side
sim.Projection(V2Layer23Pool, V2Layer23, MyConnector(ST5), sim.StaticSynapse(weight=connections['V2_FeedbackExcite']))
sim.Projection(V2Layer23Pool, V2Layer23Inter1, MyConnector(ST5), sim.StaticSynapse(weight=connections['V2_FeedbackExcite']))
sim.Projection(V2Layer23Pool, V2Layer23Inter2, MyConnector(ST5), sim.StaticSynapse(weight=connections['V2_NegFeedbackInhib']))
sim.Projection(V2Layer23Pool, V2Layer23, MyConnector(ST6), sim.StaticSynapse(weight=connections['V2_FeedbackExcite']))
sim.Projection(V2Layer23Pool, V2Layer23Inter2, MyConnector(ST6), sim.StaticSynapse(weight=connections['V2_FeedbackExcite']))
sim.Projection(V2Layer23Pool, V2Layer23Inter1, MyConnector(ST6), sim.StaticSynapse(weight=connections['V2_NegFeedbackInhib']))
synapseCount += (3*len(ST5) + 3*len(ST6))
# Connect interneurons to complex cell
sim.Projection(V2Layer23Inter1, V2Layer23, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V2_InterInhib']))
sim.Projection(V2Layer23Inter2, V2Layer23, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V2_InterInhib']))
synapseCount += (len(V2Layer23Inter1) + len(V2Layer23Inter2))
# Connect Layer 23 cells to Layer 6 cells (folded feedback)
sim.Projection(V2Layer23, V2Layer6, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V2_23To6Excite']))
synapseCount += len(V2Layer23)
# # Feedback from V2 to V1 (layer 6)
# sim.Projection(V2Layer6, V1Layer6P1, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V2_ToV1FeedbackExcite']))
# sim.Projection(V2Layer6, V1Layer6P2, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V2_ToV1FeedbackExcite']))
############# Area V4 filling-in #############
sys.stdout.write('done. \nSetting up V4...')
sys.stdout.flush()
ST = []
ST2 = []
ST3 = []
ST4 = []
for h in range(0, numSegmentationLayers): # Segmentation layers
for i in range(0, ImageNumPixelRows): # Rows
for j in range(0, ImageNumPixelColumns): # Columns
ST.append((i*ImageNumPixelColumns + j,
h*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
for k in range(0, numFlows): # Flow directions
ST2.append((h*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j,
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
# set up flow indices
i2 = flowFilter[k][0]
j2 = flowFilter[k][1]
if i + i2 >= 0 and i + i2 < ImageNumPixelRows and j + j2 >= 0 and j + j2 < ImageNumPixelColumns:
ST3.append((h*ImageNumPixelRows*ImageNumPixelColumns + (i+i2)*ImageNumPixelColumns + (j+j2),
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
for k2 in range(0, len(BoundaryBlockFilter[k])):
for k3 in range(0, numOrientations):
if BoundaryBlockFilter[k][k2][0] != k3:
i2 = BoundaryBlockFilter[k][k2][1]
j2 = BoundaryBlockFilter[k][k2][2]
if i + i2 < numPixelRows and j + j2 < numPixelColumns:
ST4.append((h*numOrientations*numPixelRows*numPixelColumns + k3*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
# Brightness and darkness at V4 compete
sim.Projection(V4Darkness, V4Brightness, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V4_BetweenColorsInhib']))
sim.Projection(V4Brightness, V4Darkness, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['V4_BetweenColorsInhib']))
synapseCount += (len(V4Darkness) + len(V4Brightness))
# LGNBright->V4brightness and LGNDark->V4darkness
sim.Projection(LGNBright, V4Brightness, MyConnector(ST), sim.StaticSynapse(weight=connections['LGN_ToV4Excite']))
sim.Projection(LGNDark, V4Darkness, MyConnector(ST), sim.StaticSynapse(weight=connections['LGN_ToV4Excite']))
synapseCount += 2*len(ST)
# V4brightness<->Interneurons (flow out on interneuron 1 flow in on interneuron 2) ; fliplr to use the connections in the way "target indexes --> source indexes"
sim.Projection(V4Brightness, V4InterBrightness1, MyConnector(ST2), sim.StaticSynapse(weight=connections['V4_BrightnessExcite']))
sim.Projection(V4Brightness, V4InterBrightness2, MyConnector(ST2), sim.StaticSynapse(weight=connections['V4_BrightnessInhib']))
sim.Projection(V4InterBrightness1, V4Brightness, MyConnector(numpy.fliplr(ST2)), sim.StaticSynapse(weight=connections['V4_BrightnessInhib']))
sim.Projection(V4InterBrightness2, V4Brightness, MyConnector(numpy.fliplr(ST2)), sim.StaticSynapse(weight=connections['V4_BrightnessExcite']))
synapseCount += 4*len(ST2)
# V4darkness<->Interneurons (flow out on interneuron 1 flow in on interneuron 2) ; fliplr to use the connections in the way "target indexes --> source indexes"
sim.Projection(V4Darkness, V4InterDarkness1, MyConnector(ST2), sim.StaticSynapse(weight=connections['V4_BrightnessExcite']))
sim.Projection(V4Darkness, V4InterDarkness2, MyConnector(ST2), sim.StaticSynapse(weight=connections['V4_BrightnessInhib']))
sim.Projection(V4InterDarkness1, V4Darkness, MyConnector(numpy.fliplr(ST2)), sim.StaticSynapse(weight=connections['V4_BrightnessInhib']))
sim.Projection(V4InterDarkness2, V4Darkness, MyConnector(numpy.fliplr(ST2)), sim.StaticSynapse(weight=connections['V4_BrightnessExcite']))
synapseCount += 4*len(ST2)
# V4brightness neighbors<->Interneurons (flow out on interneuron 1 flow in on interneuron 2) ; fliplr to use the connections in the way "target indexes --> source indexes"
sim.Projection(V4Brightness, V4InterBrightness2, MyConnector(ST3), sim.StaticSynapse(weight=connections['V4_BrightnessExcite']))
sim.Projection(V4Brightness, V4InterBrightness1, MyConnector(ST3), sim.StaticSynapse(weight=connections['V4_BrightnessInhib']))
sim.Projection(V4InterBrightness2, V4Brightness, MyConnector(numpy.fliplr(ST3)), sim.StaticSynapse(weight=connections['V4_BrightnessInhib']))
sim.Projection(V4InterBrightness1, V4Brightness, MyConnector(numpy.fliplr(ST3)), sim.StaticSynapse(weight=connections['V4_BrightnessExcite']))
synapseCount += 4*len(ST3)
# V4darkness neighbors<->Interneurons (flow out on interneuron 1 flow in on interneuron 2) ; fliplr to use the connections in the way "target indexes --> source indexes"
sim.Projection(V4Darkness, V4InterDarkness2, MyConnector(ST3), sim.StaticSynapse(weight=connections['V4_BrightnessExcite']))
sim.Projection(V4Darkness, V4InterDarkness1, MyConnector(ST3), sim.StaticSynapse(weight=connections['V4_BrightnessInhib']))
sim.Projection(V4InterDarkness2, V4Darkness, MyConnector(numpy.fliplr(ST3)), sim.StaticSynapse(weight=connections['V4_BrightnessInhib']))
sim.Projection(V4InterDarkness1, V4Darkness, MyConnector(numpy.fliplr(ST3)), sim.StaticSynapse(weight=connections['V4_BrightnessExcite']))
synapseCount += 4*len(ST3)
# V2Layer23 -> V4 Interneurons (all boundaries block except for orientation of flow)
sim.Projection(V2Layer23, V4InterBrightness1, MyConnector(ST4), sim.StaticSynapse(weight=connections['V2_BoundaryInhib']))
sim.Projection(V2Layer23, V4InterBrightness2, MyConnector(ST4), sim.StaticSynapse(weight=connections['V2_BoundaryInhib']))
sim.Projection(V2Layer23, V4InterDarkness1, MyConnector(ST4), sim.StaticSynapse(weight=connections['V2_BoundaryInhib']))
sim.Projection(V2Layer23, V4InterDarkness2, MyConnector(ST4), sim.StaticSynapse(weight=connections['V2_BoundaryInhib']))
synapseCount += 4*len(ST4)
# Strong inhibition between segmentation layers (WHY TWICE?)
if numSegmentationLayers>1:
ST = []
for h in range(0, numSegmentationLayers-1): # Num layers (not including baseline layer)
for i in range(0, ImageNumPixelRows): # Rows
for j in range(0, ImageNumPixelColumns): # Columns
for k2 in range(0, numOrientations):
for h2 in range(h, numSegmentationLayers-1):
ST.append((h*numOrientations*numPixelRows*numPixelColumns + k2*numPixelRows*numPixelColumns + i*numPixelColumns + j,
(h2+1)*numOrientations*numPixelRows*numPixelColumns + k2*numPixelRows*numPixelColumns + i*numPixelColumns + j))
# Boundaries in lower levels strongly inhibit boundaries in higher segmentation levels (lower levels can be inhibited by segmentation signals)
sim.Projection(V2Layer23, V2Layer4, MyConnector(ST), sim.StaticSynapse(weight=connections['V2_SegmentInhib']))
synapseCount += len(ST)
########### Surface segmentation network ############
if numSegmentationLayers>1 and useSurfaceSegmentation==1:
sys.stdout.write('done. \nSetting up surface segmentation network...')
sys.stdout.flush()
ST = []
ST2 = []
ST3 = []
ST4 = []
ST5 = []
for h in range(0, numSegmentationLayers-1): # Segmentation layers (not including baseline layer)
for i in range(0, ImageNumPixelRows): # Rows
for j in range(0, ImageNumPixelColumns): # Columns
for k in range(0, numFlows): # Flow directions
ST.append((h*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j,
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
i2 = flowFilter[k][0] # Vertical flow indices (surface segmentation signal flows through closed shapes)
j2 = flowFilter[k][1] # Horizontal flow indices
if i + i2 >= 0 and i + i2 < ImageNumPixelRows and j + j2 >= 0 and j + j2 < ImageNumPixelColumns:
ST2.append((h*ImageNumPixelRows*ImageNumPixelColumns + (i+i2)*ImageNumPixelColumns + (j+j2),
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
for k2 in range(0, len(BoundaryBlockFilter[k])):
for k3 in range(0, numOrientations):
if BoundaryBlockFilter[k][k2][0] != k3:
i2 = BoundaryBlockFilter[k][k2][1]
j2 = BoundaryBlockFilter[k][k2][2]
if i + i2 < numPixelRows and j + j2 < numPixelColumns:
for h2 in range(0, numSegmentationLayers): # draw boundaries from all segmentation layers
ST3.append((h2*numOrientations*numPixelRows*numPixelColumns + k3*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
for k2 in range(0, numOrientations):
for h2 in range(h, numSegmentationLayers-1):
ST4.append((h*numOrientations*numPixelRows*numPixelColumns + k2*numPixelRows*numPixelColumns + i*numPixelColumns + j,
(h2+1)*numOrientations*numPixelRows*numPixelColumns + k2*numPixelRows*numPixelColumns + i*numPixelColumns + j))
for i2 in range(-2, 4): # offset by (1,1) to reflect boundary grid is offset from surface grid
for j2 in range(-2, 4):
if i + i2 >= 0 and i + i2 < ImageNumPixelRows and j + j2 >= 0 and j + j2 < ImageNumPixelColumns:
for h2 in range(0, h+1):
ST5.append((h*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j,
h2*numOrientations*numPixelRows*numPixelColumns + k2*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2)))
# Off signals inhibit On Signals (can be separated by boundaries)
sim.Projection(SurfaceSegmentationOff, SurfaceSegmentationOn, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['S_SegmentOnOffInhib']))
synapseCount += len(SurfaceSegmentationOff)
# SurfaceSegmentationOn/Off <-> Interneurons ; fliplr to use the connections in the way "target indexes --> source indexes"
sim.Projection(SurfaceSegmentationOn, SurfaceSegmentationOnInter1, MyConnector(ST), sim.StaticSynapse(weight=connections['S_SegmentSpreadExcite']))
sim.Projection(SurfaceSegmentationOnInter2, SurfaceSegmentationOn, MyConnector(numpy.fliplr(ST)), sim.StaticSynapse(weight=connections['S_SegmentSpreadExcite']))
sim.Projection(SurfaceSegmentationOff, SurfaceSegmentationOffInter1, MyConnector(ST), sim.StaticSynapse(weight=connections['S_SegmentSpreadExcite']))
sim.Projection(SurfaceSegmentationOffInter2, SurfaceSegmentationOff, MyConnector(numpy.fliplr(ST)), sim.StaticSynapse(weight=connections['S_SegmentSpreadExcite']))
synapseCount += 4*len(ST)
# SurfaceSegmentationOn/Off <-> Interneurons (flow out on interneuron 1 flow in on interneuron 2) ; fliplr to use the connections in the way "target indexes --> source indexes"
sim.Projection(SurfaceSegmentationOn, SurfaceSegmentationOnInter2, MyConnector(ST2), sim.StaticSynapse(weight=connections['S_SegmentSpreadExcite']))
sim.Projection(SurfaceSegmentationOnInter1, SurfaceSegmentationOn, MyConnector(numpy.fliplr(ST2)), sim.StaticSynapse(weight=connections['S_SegmentSpreadExcite']))
sim.Projection(SurfaceSegmentationOff, SurfaceSegmentationOffInter2, MyConnector(ST2), sim.StaticSynapse(weight=connections['S_SegmentSpreadExcite']))
sim.Projection(SurfaceSegmentationOffInter1, SurfaceSegmentationOff, MyConnector(numpy.fliplr(ST2)), sim.StaticSynapse(weight=connections['S_SegmentSpreadExcite']))
synapseCount += 4*len(ST2)
# V2Layer23 -> Segmentation Interneurons (all boundaries block except for orientation of flow)
sim.Projection(V2Layer23, SurfaceSegmentationOnInter1, MyConnector(ST3), sim.StaticSynapse(weight=connections['V2_BoundaryInhib']))
sim.Projection(V2Layer23, SurfaceSegmentationOnInter2, MyConnector(ST3), sim.StaticSynapse(weight=connections['V2_BoundaryInhib']))
sim.Projection(V2Layer23, SurfaceSegmentationOffInter1, MyConnector(ST3), sim.StaticSynapse(weight=connections['V2_BoundaryInhib']))
sim.Projection(V2Layer23, SurfaceSegmentationOffInter2, MyConnector(ST3), sim.StaticSynapse(weight=connections['V2_BoundaryInhib']))
synapseCount += 4*len(ST3)
# V2Layer23 -> V2Layer4 strong inhibition (CHECK WHY THIS CONNECTION IS THERE TWICE WITH THE SAME CONNECTION PATTERN)
# sim.Projection(V2Layer23, V2Layer4, MyConnector(ST4), sim.StaticSynapse(weight=connections['V2_SegmentInhib']))
# synapseCount += len(ST4)
# Segmentation -> V2Layer4 (gating) ; way for lower levels to be inhibited by higher ones : through segmentation network) SHOULDN'T IT BE ACTIVATORY????
sim.Projection(SurfaceSegmentationOn, V2Layer4, MyConnector(ST5), sim.StaticSynapse(weight=connections['S_SegmentGatingInhib']))
synapseCount += len(ST5)
########### Boundary segmentation network ############
if numSegmentationLayers>1 and useBoundarySegmentation==1:
sys.stdout.write('done. \nSetting up boundary segmentation network...')
sys.stdout.flush()
ST = []
ST2 = []
ST3 = []
ST4 = []
for h in range(0, numSegmentationLayers-1): # Num layers (not including baseline layer)
for i in range(0, ImageNumPixelRows): # Rows
for j in range(0, ImageNumPixelColumns): # Columns
for k in range(0, numFlows): # Flow directions
ST.append((h*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j,
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
i2 = flowFilter[k][0]
j2 = flowFilter[k][1]
if i+i2 >= 0 and i+i2 < ImageNumPixelRows and j+j2 >= 0 and j+j2 < ImageNumPixelColumns:
ST2.append((h*ImageNumPixelRows*ImageNumPixelColumns + (i+i2)*ImageNumPixelColumns + (j+j2),
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
for k2 in range(0, len(BoundaryBlockFilter[k])):
i2 = BoundaryBlockFilter[k][k2][1]
j2 = BoundaryBlockFilter[k][k2][2]
if i+i2 < numPixelRows and j+j2 < numPixelColumns:
for k3 in range(0, numOrientations):
for h2 in range(0, numSegmentationLayers): # draw boundaries from all segmentation layers
ST3.append((h2*numOrientations*numPixelRows*numPixelColumns + k3*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2),
h*numFlows*ImageNumPixelRows*ImageNumPixelColumns + k*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j))
for k2 in range(0, numOrientations):
for i2 in range(-2, 4): # offset by (1, 1) to reflect boundary grid is offset from surface grid
for j2 in range(-2, 4):
if i+i2 >= 0 and i+i2 < ImageNumPixelRows and j+j2 >= 0 and j+j2 < ImageNumPixelColumns:
for h2 in range(0, h+1):
ST4.append((h*ImageNumPixelRows*ImageNumPixelColumns + i*ImageNumPixelColumns + j,
h2*numOrientations*numPixelRows*numPixelColumns + k2*numPixelRows*numPixelColumns + (i+i2)*numPixelColumns + (j+j2)))
# BoundarySegmentationOn<->Interneurons (flow out on interneuron 1 flow in on interneuron 2)
sim.Projection(BoundarySegmentationOn, BoundarySegmentationOnInter1, MyConnector(ST), sim.StaticSynapse(weight=connections['B_SegmentSpreadExcite']))
sim.Projection(BoundarySegmentationOnInter2, BoundarySegmentationOn, MyConnector(numpy.fliplr(ST)), sim.StaticSynapse(weight=connections['B_SegmentSpreadExcite']))
synapseCount += 2*len(ST)
sim.Projection(BoundarySegmentationOn, BoundarySegmentationOnInter2, MyConnector(ST2), sim.StaticSynapse(weight=connections['B_SegmentSpreadExcite']))
sim.Projection(BoundarySegmentationOnInter1, BoundarySegmentationOn, MyConnector(numpy.fliplr(ST2)), sim.StaticSynapse(weight=connections['B_SegmentSpreadExcite']))
synapseCount += 2*len(ST2)
# Inhibition from third interneuron (itself inhibited by the presence of a boundary)
sim.Projection(BoundarySegmentationOnInter3, BoundarySegmentationOnInter1, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['B_SegmentTonicInhib']))
sim.Projection(BoundarySegmentationOnInter3, BoundarySegmentationOnInter2, sim.OneToOneConnector(), sim.StaticSynapse(weight=connections['B_SegmentTonicInhib']))
synapseCount += 2*len(BoundarySegmentationOnInter3)
# V2layer23 -> Segmentation Interneurons (all boundaries open flow by inhibiting third interneuron)
# BoundarySegmentationOnInter3.inject(sim.DCSource(amplitude=1000.0, start=0.0, stop=0.0))
sim.Projection(V2Layer23, BoundarySegmentationOnInter3, MyConnector(ST3), sim.StaticSynapse(weight=connections['B_SegmentOpenFlowInhib']))
synapseCount += len(ST3)
# BoundarySegmentation -> V2layer4 (gating)
sim.Projection(BoundarySegmentationOn, V2Layer4, MyConnector(ST4), sim.StaticSynapse(weight=connections['B_SegmentGatingInhib']))
synapseCount += len(ST4)
sys.stdout.write('done. \n'+str(synapseCount)+' network connections created.\n')
sys.stdout.flush()
# Return only the populations that need to be updated online during the simulation and that we want to make a gif of
fullNet = LGNBright + LGNDark \
+ V1Layer6P1 + V1Layer6P2 + V1Layer4P1 + V1Layer4P2 + V1Layer23 + V1Layer23Pool + V1Layer23Inter1 + V1Layer23Inter2 \
+ V2Layer6 + V2Layer4 + V2Layer23 + V2Layer23Pool + V2Layer23Inter1 + V2Layer23Inter2 \
+ V4Brightness + V4Darkness + V4InterBrightness1 + V4InterBrightness2 + V4InterDarkness1 + V4InterDarkness2
netToSend = LGNBright + LGNDark + fullNet.get_population("V1LayerToPlot") + fullNet.get_population("V2LayerToPlot") + V4Brightness + V4Darkness
if useSurfaceSegmentation:
fullNet += (SurfaceSegmentationOn + SurfaceSegmentationOnInter1 + SurfaceSegmentationOnInter2
+ SurfaceSegmentationOff + SurfaceSegmentationOffInter1 + SurfaceSegmentationOffInter2)
netToSend += (fullNet.get_population("SurfaceSegmentationOn") + fullNet.get_population("SurfaceSegmentationOff"))
if useBoundarySegmentation:
fullNet += (BoundarySegmentationOn + BoundarySegmentationOnInter1 + BoundarySegmentationOnInter2 + BoundarySegmentationOnInter3
+ BoundarySegmentationOff + BoundarySegmentationOffInter1 + BoundarySegmentationOffInter2)
netToSend += BoundarySegmentationOnInter3 + BoundarySegmentationOn + BoundarySegmentationOff
return netToSend
n_pre = 10000
n_post = 10000
params = copy.copy(sim.IF_curr_exp.default_parameters)
pre = sim.Population(n_pre, sim.IF_curr_exp, params, label='pre')
post = sim.Population(n_post, sim.IF_curr_exp, params, label='post')
dist_params = {'low': 0.0, 'high': 10.0}
dist = 'uniform'
rand_dist = RandomDistribution(dist, rng=rng, **dist_params)
var = 'weight'
on_device_init = bool(1)
p_conn = 0.3
n = 30 #int(n_post * p_conn)
conn = sim.FixedNumberPostConnector(n, rng=rng, with_replacement=True)
syn = sim.StaticSynapse(weight=rand_dist, delay=1) #rand_dist)
proj = sim.Projection(pre, post, conn, synapse_type=syn)
sim.run(10)
comp_var = np.asarray(proj.getWeights(format='array'))
shape = np.copy(comp_var.shape)
n_cols = []
for r in comp_var:
n_cols.append(len(np.where(~np.isnan(r))[0]))
connected = np.where(~np.isnan(comp_var))
comp_var = comp_var[connected]
num_active = comp_var.size
sim.end()
params = copy.copy(sim.IF_curr_exp.default_parameters)
pre = sim.Population(n_neurons, sim.SpikeSourceArray,
{'spike_times': [[1] for _ in range(n_neurons)]},
label='pre')
params['tau_syn_E'] = 5.
post = sim.Population(n_neurons, sim.IF_curr_exp, params,
label='post')
post.record('spikes')
dist_params = {'low': 0.0, 'high': 10.0}
dist = 'uniform'
rand_dist = RandomDistribution(dist, rng=rng, **dist_params)
var = 'weight'
on_device_init = bool(1)
conn = sim.AllToAllConnector()
syn = sim.StaticSynapse(weight=5./n_neurons, delay=1)#rand_dist)
proj = sim.Projection(pre, post, conn, synapse_type=syn, use_procedural=bool(0))
sim.run(2 * n_neurons)
data = post.get_data()
spikes = np.asarray(data.segments[0].spiketrains)
sim.end()
all_at_appr_time = 0
sum_spikes = 0
for i, times in enumerate(spikes):
sum_spikes += len(times)
if int(times[0]) == 9:
all_at_appr_time += 1
inh_cells = sim.Population(n_inh,
celltype(**cell_params),
label="Inhibitory_Cells")
if use_assembly:
# group the populations into an assembly
all_cells = exc_cells + inh_cells
if benchmark == "COBA":
ext_stim = sim.Population(20,
sim.SpikeSourcePoisson(rate=rate,
duration=stim_dur),
label="expoisson")
rconn = 0.01
ext_conn = sim.FixedProbabilityConnector(rconn)
ext_syn = sim.StaticSynapse(weight=0.1)
print("%s Initialising membrane potential to random values..." % node_id)
uniformDistr = RandomDistribution('uniform',
low=v_reset,
high=v_thresh,
rng=rng)
if use_views:
all_cells.initialize(v=uniformDistr)
else:
exc_cells.initialize(v=uniformDistr)
inh_cells.initialize(v=uniformDistr)
print("%s Connecting populations..." % node_id)
progress_bar = ProgressBar(width=20)
sim_time = 100.0
timestep = 1.0
sim.setup(timestep=timestep, min_delay=timestep, backend='SingleThreadedCPU')
post = sim.Population(n_neurons, neuron_class(**base_params))
post.record('spikes')
post.record('v_thresh_adapt')
post.record('v')
pre = sim.Population(
n_neurons,
sim.SpikeSourceArray(spike_times=[[10] for _ in range(n_neurons)]),
)
proj = sim.Projection(pre, post, sim.OneToOneConnector(),
sim.StaticSynapse(weight=3.2))
sim.run(sim_time)
data = post.get_data()
sim.end()
vthresh = data.segments[0].filter(name='v_thresh_adapt')
v = data.segments[0].filter(name='v')
np.savez_compressed("genn_spiking_behaviour.npz", spikes=data.segments[0])
plt.figure()
ax = plt.subplot()
plt.plot(v[0])
# print(trigger_t, pre_spike_times[0][0], dt)
# print("post - pre ", trigger_t - pre_spike_times[0][0])
# makes post population spike
trigger = sim.Population(
1, sim.SpikeSourceArray(**{'spike_times': trigger_spike_times}))
post = sim.Population(1, neuron_class(**base_params))
post.record('spikes')
pre = sim.Population(
1, sim.SpikeSourceArray(**{'spike_times': pre_spike_times}))
tr2post = sim.Projection(trigger,
post,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=2.0),
receptor_type='excitatory',
label='trigger connection')
tdep = __stdp__.MyTemporalDependence(**time_dep_vars)
wdep = __stdp__.MyWeightDependence(w_min=0, w_max=max_w)
syn = __stdp__.MySTDPMechanism(
timing_dependence=tdep,
weight_dependence=wdep,
weight=start_w,
delay=delay,
)
pre2post = sim.Projection(pre,
post,
sim.AllToAllConnector(),
synapse_type=syn,
]] # trigger_t + 1, trigger_t + 2, trigger_t + 3]]
trigger = sim.Population(
1, sim.SpikeSourceArray(**{'spike_times': trigger_spike_times}))
post = sim.Population(1, neuron_class(**base_params))
post.record('spikes')
post.record('v_thresh_adapt')
pre = sim.Population(1,
sim.SpikeSourceArray(**{'spike_times': pre_spike_times}))
tr2post = sim.Projection(trigger,
post,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=5.0, delay=0.1),
receptor_type='excitatory',
label='trigger connection')
time_dep_vars = {
"A_plus": 0.10,
"A_minus": 0.01,
"mean": 0.0,
"std": 4.0,
"displace": 0.01,
"maxDt": 50.0,
}
tdep = __stdp__.MyTemporalDependence(**time_dep_vars)
wdep = __stdp__.MyWeightDependence(w_min=0.0, w_max=max_w)
syn = __stdp__.MySTDPMechanism(
V2 = network.get_population("V2LayerToPlot")
V4Bright = network.get_population("V4Brightness")
V4Dark = network.get_population("V4Darkness")
LGNBright.record("spikes")
LGNDark.record("spikes")
V1.record("spikes")
V2.record("spikes")
V4Bright.record("spikes")
V4Dark.record("spikes")
if inputPoisson:
LGNBrightInput = sim.Population(ImageNumPixelRows * ImageNumPixelColumns,
sim.SpikeSourcePoisson())
LGNDarkInput = sim.Population(ImageNumPixelRows * ImageNumPixelColumns,
sim.SpikeSourcePoisson())
sim.Projection(LGNBrightInput, LGNBright, sim.OneToOneConnector(),
sim.StaticSynapse(weight=connections['brightInputToLGN']))
sim.Projection(LGNDarkInput, LGNDark, sim.OneToOneConnector(),
sim.StaticSynapse(weight=connections['darkInputToLGN']))
if numSegmentationLayers > 1:
if useSurfaceSegmentation:
SurfaceSegmentationOff = network.get_population(
"SurfaceSegmentationOff")
SurfaceSegmentationOn = network.get_population("SurfaceSegmentationOn")
if useBoundarySegmentation:
BoundarySegmentationOff = network.get_population(
"BoundarySegmentationOff")
BoundarySegmentationOn = network.get_population(
"BoundarySegmentationOn")
network.get_population("BoundarySegmentationOnInter3").inject(
sim.DCSource(amplitude=constantInput, start=0.0, stop=simTime))
label='output shunt',
)
postShunt.record(['v', 'spikes'])
postBoth = sim.Population(
n_neurons,
IF_curr_exp_i(**parameters),
label='output both',
)
postBoth.record(['v', 'spikes'])
eProjStd = sim.Projection(
preExc,
postStd,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=2.),
receptor_type='excitatory',
label='exc_proj_std',
)
eProjShunt = sim.Projection(
preExc,
postShunt,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=2.),
receptor_type='excitatory',
label='exc_proj_shunt',
)
eProjBoth = sim.Projection(
preExc,
postBoth,
sim.OneToOneConnector(),
dy=dy,
dz=0.0001 * (1. / n_z))
params = copy.copy(sim.IF_curr_exp.default_parameters)
pre = sim.Population(n_pre, sim.IF_curr_exp, params, label='pre')
post = sim.Population(n_post,
sim.IF_curr_exp,
params,
label='post',
structure=structure)
dist_params = {'low': 0.0, 'high': 10.0}
dist = 'uniform'
rand_dist = RandomDistribution(dist, rng=rng, **dist_params)
var = 'weight'
conn = MaxDistanceFixedProbabilityConnector(5., 0.5, rng=rng)
syn = sim.StaticSynapse(weight=3, delay=1)
proj = sim.Projection(
pre,
post,
conn,
synapse_type=syn,
# use_procedural=True
)
sim.run(10)
comp_var = np.asarray(proj.getWeights(format='array'))
shape = np.copy(comp_var.shape)
print(shape)
connected = np.where(~np.isnan(comp_var))
# print(connected)
max_w = 0.01
start_w = max_w / 2.0
min_delay = 0.1
sim.setup(timestep,
min_delay=min_delay,
backend='CUDA'
# backend='SingleThreadedCPU'
)
pre = sim.Population(10, sim.SpikeSourcePoisson(**{'rate': 10}))
post = sim.Population(100, neuron_class(**base_params))
# w = 1.0
w = sim.RandomDistribution('normal', [5.0, 1.0])
synapse = sim.StaticSynapse(weight=w)
prj = sim.Projection(
pre,
post,
sim.FixedProbabilityConnector(0.25),
# prj = sim.Projection(pre, post, sim.AllToAllConnector(),
# prj = sim.Projection(pre, post, sim.OneToOneConnector(),
synapse_type=synapse,
receptor_type='excitatory')
sim.run(100)
weights = prj.get('weight', format='array')
sim.end()
print(weights)
