def printModelConfigurationSummary(
params, populationsInput, populationsNoiseSource, populationsRN, populationsPN, populationsAN
):
totalPops = (
len(populationsInput)
+ len(populationsNoiseSource)
+ len(populationsRN)
+ len(populationsPN)
+ len(populationsAN)
)
stdMaxNeuronsPerCore = params["MAX_NEURONS_PER_CORE"]
stdpMaxNeuronsPerCore = params["MAX_STDP_NEURONS_PER_CORE"]
inputCores = utils.coresRequired(populationsInput, stdMaxNeuronsPerCore)
noiseCores = utils.coresRequired(populationsNoiseSource, stdMaxNeuronsPerCore)
rnCores = utils.coresRequired(populationsRN, stdMaxNeuronsPerCore)
pnCores = utils.coresRequired(populationsPN, stdMaxNeuronsPerCore)
anCores = utils.coresRequired(populationsAN, stdpMaxNeuronsPerCore)
utils.printSeparator()
print "Population(Cores) Summary"
utils.printSeparator()
print "Input: ", len(populationsInput), "(", inputCores, " cores)"
print "Noise: ", len(populationsNoiseSource), "(", noiseCores, " cores)"
print "RN: ", len(populationsRN), "(", rnCores, " cores)"
print "PN: ", len(populationsPN), "(", pnCores, " cores)"
print "AN: ", len(populationsAN), "(", anCores, " cores)"
print "TOTAL: ", totalPops, "(", inputCores + noiseCores + rnCores + pnCores + anCores, " cores)"
utils.printSeparator()
def printModelConfigurationSummary(params, populationsInput,
populationsNoiseSource, populationsRN,
populationsPN, populationsAN):
totalPops = len(populationsInput) + len(populationsNoiseSource) + \
len(populationsRN) + len(populationsPN) + len(populationsAN)
stdMaxNeuronsPerCore = params['MAX_NEURONS_PER_CORE']
stdpMaxNeuronsPerCore = params['MAX_STDP_NEURONS_PER_CORE']
inputCores = utils.coresRequired(populationsInput, stdMaxNeuronsPerCore)
noiseCores = utils.coresRequired(populationsNoiseSource,
stdMaxNeuronsPerCore)
rnCores = utils.coresRequired(populationsRN, stdMaxNeuronsPerCore)
pnCores = utils.coresRequired(populationsPN, stdMaxNeuronsPerCore)
anCores = utils.coresRequired(populationsAN, stdpMaxNeuronsPerCore)
utils.printSeparator()
print 'Population(Cores) Summary'
utils.printSeparator()
print 'Input: ', len(populationsInput), '(', inputCores, ' cores)'
print 'Noise: ', len(populationsNoiseSource), '(', noiseCores, ' cores)'
print 'RN: ', len(populationsRN), '(', rnCores, ' cores)'
print 'PN: ', len(populationsPN), '(', pnCores, ' cores)'
print 'AN: ', len(populationsAN), '(', anCores, ' cores)'
print 'TOTAL: ', totalPops, '(', inputCores + noiseCores + rnCores + \
pnCores + anCores, ' cores)'
utils.printSeparator()
def printModelConfigurationSummary(params, populationsInput, populationsNoiseSource, populationsRN, populationsPN, populationsAN):
totalPops = len(populationsInput) + len(populationsNoiseSource) + len(populationsRN) + len(populationsPN) + len(populationsAN)
stdMaxNeuronsPerCore = params['MAX_NEURONS_PER_CORE']
stdpMaxNeuronsPerCore = params['MAX_STDP_NEURONS_PER_CORE']
inputCores = utils.coresRequired(populationsInput, stdMaxNeuronsPerCore)
noiseCores = utils.coresRequired(populationsNoiseSource, stdMaxNeuronsPerCore)
rnCores = utils.coresRequired(populationsRN, stdMaxNeuronsPerCore)
pnCores = utils.coresRequired(populationsPN, stdMaxNeuronsPerCore)
anCores = utils.coresRequired(populationsAN, stdpMaxNeuronsPerCore)
utils.printSeparator()
print 'Population(Cores) Summary'
utils.printSeparator()
print 'Input: ', len(populationsInput), '(', inputCores, ' cores)'
print 'Noise: ', len(populationsNoiseSource), '(', noiseCores, ' cores)'
print 'RN: ', len(populationsRN), '(', rnCores, ' cores)'
print 'PN: ', len(populationsPN), '(', pnCores, ' cores)'
print 'AN: ', len(populationsAN), '(', anCores, ' cores)'
print 'TOTAL: ', totalPops, '(', inputCores + noiseCores + rnCores + pnCores + anCores, ' cores)'
utils.printSeparator()
def setupLayerPN(params, neuronModel, cell_params, populationsRN, populationsPN):
# create a projection neuron PN cluster population per VR
# this will be fed by the equivalent RN population and will laterally
# inhibit between clusters
numVR = int(params["NUM_VR"])
# print 'PN layer, no. VR: ' , numVR
pnClusterSize = int(params["CLUSTER_SIZE"] * params["NETWORK_SCALE"])
maxNeuronsPerCore = int(params["MAX_NEURONS_PER_CORE"])
maxVrPerPop = maxNeuronsPerCore / pnClusterSize
# how many cores were needed to accomodate RN layer (1 pynn pop in this case)
numCoresRN = utils.coresRequired(populationsRN, maxNeuronsPerCore)
# print 'The RN layer is taking up ', numCoresRN, ' cores'
coresAvailablePN = int(
params["CORES_ON_BOARD"] - params["NUM_CLASSES"] - numCoresRN - 3
) # 2 x input, 1 x noise source
# print 'PN layer, no. cores available:' , coresAvailablePN
vrPerPop = int(ceil(float(numVR) / float(coresAvailablePN)))
if vrPerPop > maxVrPerPop:
print "The number of VR and/or cluster size stipulated for \
this model are too a large for the capacity of this board."
quit
# print 'PN layer, no. VRs per population will be: ', vrPerPop
pnPopSize = pnClusterSize * vrPerPop
# print 'PN layer, neurons per population will be: ', pnPopSize
numPopPN = int(ceil(float(numVR) / float(vrPerPop)))
# print 'PN layer, number of populations(cores) used will be: ', numPopPN
# print 'PN layer, spare (unused) cores : ', coresAvailablePN - numPopPN
weightPNPN = float(params["WEIGHT_WTA_PN_PN"])
delayPNPN = int(params["DELAY_WTA_PN_PN"])
connectivityPNPN = float(params["CONNECTIVITY_WTA_PN_PN"])
for p in range(numPopPN):
popName = "popPN_" + str(p)
popPN = spynnaker.Population(pnPopSize, neuronModel, cell_params, label=popName)
# print 'created population ', popName
populationsPN.append(popPN)
# create a FromList to feed each PN neuron in this popn from its
# corresponding RN neuron in the single monolithic RN popn
weightRNPN = float(params["WEIGHT_RN_PN"])
delayRNPN = int(params["DELAY_RN_PN"])
rnStartIdx = p * pnPopSize
rnEndIdx = rnStartIdx + pnPopSize - 1
# The last PN popn will often have unneeded 'ghost' clusters at
# the end due to imperfect dstribution of VRs among cores
# As there is no RN cluster that feeds these (RN is one pop of the
# correct total size) so the connections must stop at the end of RN
rnMaxIdx = populationsRN[0]._size - 1
if rnEndIdx > rnMaxIdx:
rnEndIdx = rnMaxIdx # clamp to the end of the RN population
pnEndIdx = rnEndIdx - rnStartIdx
connections = utils.fromList_OneToOne_fromRangeToRange(
rnStartIdx, rnEndIdx, 0, pnEndIdx, weightRNPN, delayRNPN, delayRNPN
)
projClusterRNToClusterPN = spynnaker.Projection(
populationsRN[0], popPN, spynnaker.FromListConnector(connections), target="excitatory"
)
# within this popn only, connect each PN sub-population VR
# "cluster" to inhibit every other
if vrPerPop > 1:
utils.createIntraPopulationWTA(popPN, vrPerPop, weightPNPN, delayPNPN, connectivityPNPN, True)
# Also connect each PN cluster to inhibit every other cluster
utils.createInterPopulationWTA(populationsPN, weightPNPN, delayPNPN, connectivityPNPN)
def setupLayerPN(params, neuronModel, cell_params, populationsRN,
populationsPN):
#create a projection neuron PN cluster population per VR
#this will be fed by the equivalent RN population and will laterally
#inhibit between clusters
numVR = int(params['NUM_VR'])
#print 'PN layer, no. VR: ' , numVR
pnClusterSize = int(params['CLUSTER_SIZE'] * params['NETWORK_SCALE'])
maxNeuronsPerCore = int(params['MAX_NEURONS_PER_CORE'])
maxVrPerPop = maxNeuronsPerCore / pnClusterSize
#how many cores were needed to accomodate RN layer (1 pynn pop in this case)
numCoresRN = utils.coresRequired(populationsRN, maxNeuronsPerCore)
#print 'The RN layer is taking up ', numCoresRN, ' cores'
coresAvailablePN = int(params['CORES_ON_BOARD'] - params['NUM_CLASSES'] -
numCoresRN - 3) # 2 x input, 1 x noise source
#print 'PN layer, no. cores available:' , coresAvailablePN
vrPerPop = int(ceil(float(numVR) / float(coresAvailablePN)))
if vrPerPop > maxVrPerPop:
print 'The number of VR and/or cluster size stipulated for \
this model are too a large for the capacity of this board.'
quit
#print 'PN layer, no. VRs per population will be: ', vrPerPop
pnPopSize = pnClusterSize * vrPerPop
#print 'PN layer, neurons per population will be: ', pnPopSize
numPopPN = int(ceil(float(numVR) / float(vrPerPop)))
#print 'PN layer, number of populations(cores) used will be: ', numPopPN
#print 'PN layer, spare (unused) cores : ', coresAvailablePN - numPopPN
weightPNPN = float(params['WEIGHT_WTA_PN_PN'])
delayPNPN = int(params['DELAY_WTA_PN_PN'])
connectivityPNPN = float(params['CONNECTIVITY_WTA_PN_PN'])
for p in range(numPopPN):
popName = 'popPN_' + str(p)
popPN = spynnaker.Population(pnPopSize,
neuronModel,
cell_params,
label=popName)
#print 'created population ', popName
populationsPN.append(popPN)
#create a FromList to feed each PN neuron in this popn from its
#corresponding RN neuron in the single monolithic RN popn
weightRNPN = float(params['WEIGHT_RN_PN'])
delayRNPN = int(params['DELAY_RN_PN'])
rnStartIdx = p * pnPopSize
rnEndIdx = rnStartIdx + pnPopSize - 1
# The last PN popn will often have unneeded 'ghost' clusters at
#the end due to imperfect dstribution of VRs among cores
# As there is no RN cluster that feeds these (RN is one pop of the
#correct total size) so the connections must stop at the end of RN
rnMaxIdx = populationsRN[0]._size - 1
if rnEndIdx > rnMaxIdx:
rnEndIdx = rnMaxIdx #clamp to the end of the RN population
pnEndIdx = rnEndIdx - rnStartIdx
connections = utils.fromList_OneToOne_fromRangeToRange(
rnStartIdx, rnEndIdx, 0, pnEndIdx, weightRNPN, delayRNPN,
delayRNPN)
projClusterRNToClusterPN = spynnaker.Projection(
populationsRN[0],
popPN,
spynnaker.FromListConnector(connections),
target='excitatory')
#within this popn only, connect each PN sub-population VR
#"cluster" to inhibit every other
if vrPerPop > 1:
utils.createIntraPopulationWTA(popPN, vrPerPop, weightPNPN,
delayPNPN, connectivityPNPN, True)
#Also connect each PN cluster to inhibit every other cluster
utils.createInterPopulationWTA(populationsPN, weightPNPN, delayPNPN,
connectivityPNPN)