def buildNeurons(net,N,matrix):
model = nef.Network('model')
# IN router
inputs = model.add(routing.twoDimsRouter('inputs')); # TODO: general IO dimensions
# spiking ANN
model.make('ANN', neurons=N, dimensions=INdim, mode='spike',
encoders = ([1,0], [0,1]), intercept= (ii, ii), max_rate = (mr,mr))
# OUT router
outputt = model.add(routing.sumatorFive('outputt')); # TODO: general IO dimensions
hiddenW = matrix.getW();
inputW = matrix.getInW();
outputW = matrix.getOutW();
# FUZZY OR
orModule = model.add(modules.mmisoOR('Fuzzy_OR_module'));
model.connect(inputs.getOrigin('out'),orModule.getTermination('inputs0')) # 2D from input to OR (must be 2x2)
model.connect(inputs.getOrigin('out'),orModule.getTermination('inputs1')) # 2D from input to OR (must be 2x2)
zeroOrIN = [inputW[0][0],inputW[0][1]];
orModule.swt_inputs_0(zeroOrIN);
firstOrIN = [inputW[1][0],inputW[1][1]];
orModule.swt_inputs_1(firstOrIN);
model.connect(orModule.getOrigin('output'),orModule.getTermination('inputs_10'))# recurrent 1
orModule.swt_inputs_10(hiddenW[0][2]);
model.connect(orModule.getOrigin('output'),orModule.getTermination('inputs_11'))# recurrent 2
orModule.swt_inputs_11(hiddenW[0][1]);
model.connect(orModule.getOrigin('output'),outputt.getTermination('in_4')) # directly to OUT
outputt.swt_in_4(outputW[0][0]);
outputt.swt_in_2(0); # unused inputs..
outputt.swt_in_3(0);
# wire it:
model.connect('ANN','ANN',weight_func=setReccurent); # recurrent conencitons
# for each input, make one neuron and connect it
for d in range(N):
# INPUT_i
fts = floattospike.lif(model, maxrate=mr,num=d);
actualIn=d;
model.connect(inputs.getOrigin('out'),'FloatToSpike_%d'%d,transform=[[abs(d),abs(d-1)]]) # 2D IN to spikes
model.connect(fts, 'ANN', index_post=d) # spiking input_i to ANN (neuron_i)
# OUTPUT_i - integrator
stf = spiketofloat.convertor(model,mr,d);
#model.connect('ANN',stf, transform=[1,0]) # ANN to spikes
#
model.connect('ANN',stf, index_pre=d,index_post=0) # ANN to spikes
model.connect('SpikeToFloatInt_%d'%d, outputt.getTermination('in_%d'%d)) # Spikes to OUT
result = getattr(outputt, 'swt_in_%d'%d)(d)
# wire OR module
model.connect(orModule.getOrigin('output'),'FloatToSpike_%d'%d,transform=[[1]]) # OR to neuron
model.connect('SpikeToFloatInt_%d'%d,orModule.getTermination('inputs_%d0'%(d+2))) # neuron to OR1
result = getattr(orModule, 'swt_inputs_%d0'%(d+2))(10)
model.connect('SpikeToFloatInt_%d'%d,orModule.getTermination('inputs_%d1'%(d+2))) # neuron to OR2
result = getattr(orModule, 'swt_inputs_%d1'%(d+2))(10)
return model;
def buildNeurons(net,N):
model = nef.Network('model')
# IN router
inputs = model.add(routing.twoDimsRouter('inputs')); # TODO: general IO dimensions
# spiking ANN
model.make('ANN', neurons=N, dimensions=INdim, mode='spike',
encoders = ([1,0], [0,1]), intercept= (ii, ii), max_rate = (mr,mr))
# OUT router
outputt = model.add(routing.sumatorFive('outputt')); # TODO: general IO dimensions
# FUZZY OR
orModule = model.add(modules.mmisoOR('Fuzzy_OR_module'));
# orModulee = model.add(modules.OR('TEST'));
# model.connect(inputs.getOrigin('out'),orModule.getTermination('inputs')) # 2D from input to OR
model.connect(inputs.getOrigin('out'),orModule.getTermination('inputs0')) # 2D from input to OR
orModule.swt_inputs_0([1,1]);
model.connect(orModule.getOrigin('output'),orModule.getTermination('inputs_10'))# recurrent 1
orModule.swt_inputs_10(0);
model.connect(orModule.getOrigin('output'),orModule.getTermination('inputs_11'))# recurrent 2
orModule.swt_inputs_11(0);
model.connect(orModule.getOrigin('output'),outputt.getTermination('in_4')) # directly to OUT
outputt.swt_in_4(1);
orModule.swt_inputs_20(0);
orModule.swt_inputs_21(0);
orModule.swt_inputs_30(0);
orModule.swt_inputs_31(0);
outputt.swt_in_2(1); # unused inputs..
outputt.swt_in_3(1);
# wire it:
model.connect('ANN','ANN',weight_func=setReccurent); # recurrent conencitons
# for each input, make one neuron and connect it
for d in range(N):
# INPUT_i
fts = floattospike.lif(model, maxrate=mr,num=d);
actualIn=d;
model.connect(inputs.getOrigin('out'),'FloatToSpike_%d'%d,transform=[[abs(d),abs(d-1)]]) # 2D IN to spikes
connectNo=d;
#model.connect(fts, 'ANN', weight_func=connectOnlyOne) # spiking input_i to ANN
model.connect(fts, 'ANN', index_post=d) # spiking input_i to ANN (neuron_i)
# OUTPUT_i - integrator
stf = spiketofloat.convertor(model,mr,connectNo);
model.connect('ANN',stf, transform=[1,0]) # so not modify
# connect outputs of particular neurons to the main output
model.connect('SpikeToFloatInt_%d'%d, outputt.getTermination('in_%d'%d))
result = getattr(outputt, 'swt_in_%d'%d)(d) # call method specified by string, cool
# name = 'swt_in_%d'%d;
# outputt.name(1);
# wire OR module
#model.connect(orModule.getOrigin('output'),'FloatToSpike_%d'%d,transform=[[d]])
#model.connect('SpikeToFloatInt_%d'%d,orModule.getTermination('inputs_%d0'%(d+2))) #TODO w
#model.connect('SpikeToFloatInt_%d'%d,orModule.getTermination('inputs_%d1'%(d+2))) #TODO w
return model;
def buildNeurons(net,N):
model = nef.Network('model')
# input
inputs = model.add(routing.twoDimsRouter('inputs')); # TODO: general IO dimensions
# spiking ANN
model.make('ANN', neurons=N, dimensions=INdim, mode='spike',
encoders = ([1,0], [0,1]), intercept= (ii, ii), max_rate = (mr,mr))
# main output
outputt = model.add(routing.sumatorFive('outputt')); # TODO: general IO dimensions
# the first neural module used in neuroevolution is..
orModule = model.add(modules.mmisoOR('Fuzzy_OR_module'));
model.connect(orModule.getOrigin('output'),outputt.getTermination('in_4'))#,weight=0.4)# TODO weight
model.connect(orModule.getOrigin('output'),orModule.getTermination('inputs_10')) #,weight=0.4)# TODO weight
model.connect(orModule.getOrigin('output'),orModule.getTermination('inputs_11')) #,weight=0.4)# TODO weight
model.connect(inputs.getOrigin('out'),orModule.getTermination('inputs_0')) #,weight=0.4)# TODO weight
#
# wire it:
model.connect('ANN','ANN',weight_func=setReccurent); # recurrent conencitons
# for each input, make one neuron and connect it
for d in range(N):
# each neuron has its own float-based INPUT
fts = floattospike.lif(model, maxrate=mr,num=d);
connectNo=d;
model.connect(fts, 'ANN', weight_func=connectOnlyOne)
# connect common input to particular neuron
actualIn=d;
model.connect(inputs.getOrigin('out'),'FloatToSpike_%d'%d,transform=[[0.131,1.3]]) #TODO weight
print d
# each neuron has also its own OUTPUT (integration of spikes)
stf = spiketofloat.convertor(model,mr,connectNo);
model.connect('ANN',stf, transform=[1,0])
# connect outputs of particular neurons to the main output
model.connect('SpikeToFloatInt_%d'%d, outputt.getTermination('in_%d'%d),weight=1)# TODO w here
# wire OR module
model.connect(orModule.getOrigin('output'),'FloatToSpike_%d'%d,transform=[[d]])
model.connect('SpikeToFloatInt_%d'%d,orModule.getTermination('inputs_%d0'%(d+2))) #TODO w
model.connect('SpikeToFloatInt_%d'%d,orModule.getTermination('inputs_%d1'%(d+2))) #TODO w
return model;
def buildNeurons(net, N, matrix):
model = nef.Network('model')
# IN router
inputs = model.add(routing.twoDimsRouter('inputs'))
# TODO: general IO dimensions
# spiking ANN
model.make('ANN',
neurons=N,
dimensions=INdim,
mode='spike',
encoders=([1, 0], [0, 1]),
intercept=(ii, ii),
max_rate=(mr, mr))
# OUT router
outputt = model.add(routing.sumatorFive('outputt'))
# TODO: general IO dimensions
hiddenW = matrix.getW()
inputW = matrix.getInW()
outputW = matrix.getOutW()
# FUZZY OR
orModule = model.add(modules.mmisoOR('Fuzzy_OR_module'))
model.connect(inputs.getOrigin('out'), orModule.getTermination(
'inputs0')) # 2D from input to OR (must be 2x2)
model.connect(inputs.getOrigin('out'), orModule.getTermination(
'inputs1')) # 2D from input to OR (must be 2x2)
zeroOrIN = [inputW[0][0], inputW[0][1]]
orModule.swt_inputs_0(zeroOrIN)
firstOrIN = [inputW[1][0], inputW[1][1]]
orModule.swt_inputs_1(firstOrIN)
model.connect(orModule.getOrigin('output'),
orModule.getTermination('inputs_10')) # recurrent 1
orModule.swt_inputs_10(hiddenW[0][2])
model.connect(orModule.getOrigin('output'),
orModule.getTermination('inputs_11')) # recurrent 2
orModule.swt_inputs_11(hiddenW[0][1])
model.connect(orModule.getOrigin('output'),
outputt.getTermination('in_4')) # directly to OUT
outputt.swt_in_4(outputW[0][0])
outputt.swt_in_2(0)
# unused inputs..
outputt.swt_in_3(0)
# wire it:
model.connect('ANN', 'ANN', weight_func=setReccurent)
# recurrent conencitons
# for each input, make one neuron and connect it
for d in range(N):
# INPUT_i
fts = floattospike.lif(model, maxrate=mr, num=d)
actualIn = d
inToD = [inputW[d + 2][0], inputW[d + 2][1]]
model.connect(inputs.getOrigin('out'),
'FloatToSpike_%d' % d,
transform=[inToD]) # 2D IN to spikes
model.connect(fts, 'ANN',
index_post=d) # spiking input_i to ANN (neuron_i)
# OUTPUT_i - integrator
stf = spiketofloat.convertor(model, mr, d)
model.connect('ANN', stf, index_pre=d, index_post=0) # ANN to spikes
model.connect('SpikeToFloatInt_%d' % d,
outputt.getTermination('in_%d' % d)) # Spikes to OUT
result = getattr(outputt, 'swt_in_%d' % d)(outputW[d + 1][0])
if d == 0:
otn = hiddenW[3][0]
nto1 = hiddenW[4][0]
nto2 = hiddenW[4][1]
else:
otn = hiddenW[5][0]
nto1 = hiddenW[6][0]
nto2 = hiddenW[6][1]
# wire OR module
model.connect(orModule.getOrigin('output'),
'FloatToSpike_%d' % d,
transform=[[otn]]) # OR to neuron
model.connect('SpikeToFloatInt_%d' % d,
orModule.getTermination('inputs_%d0' %
(d + 2))) # neuron to OR1
result = getattr(orModule, 'swt_inputs_%d0' % (d + 2))(nto1)
model.connect('SpikeToFloatInt_%d' % d,
orModule.getTermination('inputs_%d1' %
(d + 2))) # neuron to OR2
result = getattr(orModule, 'swt_inputs_%d1' % (d + 2))(nto2)
return model
