def create_default_population(setup,chipname='seq',N=10,*args,**kwargs):
'''
Creates a default population
'''
test_pops = pyNCS.Population('default', 'Default Population')
test_pops.populate_by_number(setup, chipname, 'excitatory', N, *args, **kwargs)
return test_pops
def __init__(self, inputpop):
self.chippop = inputpop
self.setup = inputpop.setup
self.mapper = self.setup.mapper
#### TODO: these parameters need to be loaded from the XML file setupfile
self.mem_offset_mn256r1 = 400
self.mem_offset_usb = 500
self.bioamp_up_address = 305
self.bioamp_dn_address = 300
self.bioamp_pulse_address = 310
self.mem_offset_bioamp_up = 600
self.mem_offset_bioamp_dn = 700
self.mem_offset_bioamp_pulse = 800
self.in_bit = 22 #defined in the xml setupfile
self.possible_interfaces = 8
self.usb_interface = 1
self.mn256r1_interface = 0
self.bioamp_up_interface = 3
self.bioamp_dn_interface = 4
self.bioamp_pulse_interface = 5
self.matrix_w = np.zeros([256, 256])
self.pop_broadcast = pyNCS.Population("", "")
self.pop_broadcast.populate_all(self.setup, 'mn256r1', 'excitatory')
self.matrix_learning_rec = np.zeros([256, 256])
self.matrix_learning_pot = np.zeros([256, 256])
self.matrix_programmable_rec = np.zeros([256, 256])
self.matrix_programmable_w = np.zeros([256, 256])
self.matrix_programmable_exc_inh = np.zeros([256, 256])
def testIFSLWTAPopulationFunctions(self):
N=5
test_pops1=create_default_population(self.nsetup,'ifslwta',N)
test_pops2=create_default_population(self.nsetup,'ifslwta',2*N,offset=N)
pop=pyNCS.Population()
pop.init(self.nsetup, 'ifslwta', 'excitatory')
pop.union(test_pops1)
pop.union(test_pops2)
testaddr = np.concatenate([test_pops1.soma.paddr,test_pops2.soma.paddr])
for a in testaddr:
self.assertTrue(a in pop.soma.paddr)
def __init__(self, inputpop):
self.setup = inputpop.setup
self.mapper = self.setup.mapper
#### TODO: these parameters need to be loaded from the XML file setupfile
self.mem_offset_mn256r1 = 200
self.mem_offset_usb = 500
self.mem_offset_retina = 600
self.in_bit = 22 #defined in the xml setupfile
self.possible_interfaces = 8
self.usb_interface = 1
self.mn256r1_interface = 0
self.retina_interface = 2
self.matrix_w = np.zeros([256, 256])
self.pop_broadcast = pyNCS.Population("", "")
self.pop_broadcast.populate_all(self.setup, 'mn256r1', 'excitatory')
#### end parameters
self.fd = []
self.pop_dest = inputpop
self.retina_map = np.zeros([128, 128])
self.dest_map = np.zeros([
len(np.unique(inputpop.synapses['learning'].addr['neu'])) +
len(np.unique(inputpop.synapses['programmable'].addr['neu'])),
len(inputpop.soma.addr)
])
#dest_map_learning = np.zeros([len(np.unique(inputpop.synapses['learning'].addr['neu'])),len(np.unique(inputpop.soma.addr['neu']))])
#dest_map_programmable = np.zeros([len(np.unique(inputpop.synapses['programmable'].addr['neu'])),len(np.unique(inputpop.soma.addr['neu']))])
self.dest_map_learning_flat = inputpop.synapses['learning'].paddr
self.dest_map_programmable_flat = inputpop.synapses[
'programmable'].paddr
self.dest_map[
np.min(np.unique(inputpop.synapses['programmable'].addr['syntype'])
) -
1:np.max(
np.unique(inputpop.synapses['programmable'].addr['syntype'])
), :] = np.reshape(self.dest_map_programmable_flat, [
len(np.unique(inputpop.synapses['programmable'].addr)) /
len(np.unique(inputpop.synapses['programmable'].addr['neu'])),
len(np.unique(inputpop.soma.addr['neu']))
])
self.dest_map[
np.min(np.unique(inputpop.synapses['learning'].addr['syntype'])):np
.max(np.unique(inputpop.synapses['learning'].addr['syntype'])) +
1, :] = np.reshape(self.dest_map_learning_flat, [
len(np.unique(inputpop.synapses['learning'].addr)) /
len(np.unique(inputpop.synapses['learning'].addr['neu'])),
len(np.unique(inputpop.soma.addr['neu']))
])
def __init__(self, population, syntype='learning', shape=None):
"""
"""
addrgroup = population.synapses[syntype]
self.neurons = population
self.syntype = syntype
self.setup = population.setup
if shape is None:
# guess the shape (x = neuron, y = synapse)
field0 = addrgroup.dtype.descr[0][0]
self.x_dim = len(np.unique(addrgroup.addr[field0]))
self.state = np.zeros(len(addrgroup)).reshape(self.x_dim, -1)
self.y_dim = self.state.shape[1]
self.pop_broadcast = pyNCS.Population("","")
self.pop_broadcast.populate_all(self.setup, 'mn256r1', 'excitatory')
self.out_mon = pyNCS.monitors.SpikeMonitor(self.pop_broadcast.soma)
self.setup.monitors.import_monitors([self.out_mon])
def __init__(self, chippop, cee=1, cei=1, n_segments=1, n_neu_osc=4):
# resources
self.available_neus = range(256)
self.matrix_learning_rec = np.zeros([256, 256])
self.matrix_learning_pot = np.zeros([256, 256])
self.matrix_programmable_rec = np.zeros([256, 256])
self.matrix_programmable_w = np.zeros([256, 256])
self.matrix_programmable_exc_inh = np.zeros([256, 256])
self.setup = chippop.setup
self.mapper = self.setup.mapper
#end resources
# network parameters
self.cee = cee
self.cei = cei
self.n_segments = n_segments
self.n_neu_osc = n_neu_osc
self.chippop = chippop
self.npop = 10
self.nneuinpop = 5
self.cpg = [pyNCS.Population() for i in range(self.npop)]
for i in range(self.npop):
self.cpg[i].populate_by_id(
self.setup, 'mn256r1', 'excitatory',
np.linspace(i * 5, (((i + 1) * 5) - 1), 5))
#population = [pyNCS.Population() for i in range(npop)]
#population[0] = population.populate_by_id(nsetup,'mn256r1', 'excitatory', np.linspace(0,))
#
#end parameters
self.popsosc = np.array([])
self.popsnosc1 = np.array([])
self.pop_mn_d = np.array([])
self.pop_mn_s = np.array([])
self.pop_ein_s = np.array([])
self.pop_ein_d = np.array([])
self.pop_lin_d = np.array([])
self.pop_lin_s = np.array([])
self.pop_cn_s = np.array([])
self.pop_cn_d = np.array([])
self._populate_chip()
self._connect_populations()
self._connect_populations_oscillator()
self._input_oscillator()
ncol_retina_sync = 5
npops = len(neuron_ids)
#setup
prefix = '../'
setuptype = '../setupfiles/mc_final_mn256r1.xml'
setupfile = '../setupfiles/final_mn256r1_retina_monster.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
nsetup.mapper._init_fpga_mapper()
chip = nsetup.chips['mn256r1']
chip.configurator._set_multiplexer(0)
#populate neurons
rcnpop = pyNCS.Population('neurons', 'for fun')
rcnpop.populate_by_id(nsetup, 'mn256r1', 'excitatory', neuron_ids)
#init liquid state machine
print "################# init onchip recurrent connections... [reservoir] "
liquid = L.Lsm(rcnpop, cee=0.7, cii=0.3)
#c = 0.2
#dim = np.round(np.sqrt(len(liquid.rcn.synapses['virtual_exc'].addr)*c))
use_retina_projections = (liquid.matrix_programmable_rec != 1)
liquid.matrix_programmable_exc_inh[
use_retina_projections] = np.random.choice(
[0, 1], size=np.sum(use_retina_projections))
liquid.matrix_programmable_w[use_retina_projections] = np.random.choice(
[0, 1, 2, 3], size=np.sum(use_retina_projections))
sys.path.append('../api/retina/')
sys.path.append('../api/wij/')
sys.path.append('../api/rcn/')
#from wij import SynapsesLearning
from retina import Retina
#just do some recordings
record = 1
prefix='../'
setuptype = '../setupfiles/mc_final_mn256r1.xml'
setupfile = '../setupfiles/final_mn256r1_retina_monster.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = nsetup.chips['mn256r1']
nsetup.mapper._init_fpga_mapper()
p = pyNCS.Population('', '')
p.populate_all(nsetup, 'mn256r1', 'excitatory')
# we use the first 128 neurons to receive input from the retina
inputpop = pyNCS.Population('','')
inputpop.populate_by_id(nsetup,'mn256r1', 'excitatory', np.linspace(0,255,256))
#reset multiplexer
chip.configurator._set_multiplexer(0)
#init class synapses learning
#sl = SynapsesLearning(p, 'learning')
#matrix_learning = np.ones([256,256])
#init retina
ret = Retina(inputpop)
#program all excitatory synapses for the programmable syn
matrix_exc = np.ones([256,256])
#!/usr/env/python
import numpy as np
from pylab import *
import pyNCS
import sys
sys.path.append('../../api/retina/')
sys.path.append('../../api/wij/')
from wij import SynapsesLearning
prefix = '../../'
setuptype = '../../setupfiles/mc_final_mn256r1.xml'
setupfile = '../../setupfiles/final_mn256r1_retina_monster.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = nsetup.chips['mn256r1']
p = pyNCS.Population('', '')
p.populate_all(nsetup, 'mn256r1', 'excitatory')
sl = SynapsesLearning(p, 'learning')
nsync = 255
ncol_retina_sync = 5
npops = len(neuron_ids)
#setup
prefix = '../'
setuptype = '../setupfiles/mc_final_mn256r1.xml'
setupfile = '../setupfiles/final_mn256r1_retina_monster.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
nsetup.mapper._init_fpga_mapper()
chip = nsetup.chips['mn256r1']
chip.configurator._set_multiplexer(0)
#populate neurons
rcnpop = pyNCS.Population('neurons', 'for fun')
rcnpop.populate_by_id(nsetup, 'mn256r1', 'excitatory', neuron_ids)
#init liquid state machine
print "################# init onchip recurrent connections... [reservoir] "
res = L.Reservoir(rcnpop, cee=0.6, cii=0.35)
#c = 0.2
#dim = np.round(np.sqrt(len(liquid.rcn.synapses['virtual_exc'].addr)*c))
chip.load_parameters('biases/biases_reservoir_amplitude.biases')
# do config only once
is_configured = True
c = 0.013
duration = 250
def _populate_chip(self):
self.popsosc = (self.cpg[0].soma.addr['neu'])
self.popsosc1 = (self.cpg[1].soma.addr['neu'])
self.pop_mn_d = (self.cpg[2].soma.addr['neu'])
self.pop_mn_s = (self.cpg[3].soma.addr['neu'])
self.pop_ein_s = (self.cpg[8].soma.addr['neu'])
self.pop_ein_d = (self.cpg[9].soma.addr['neu'])
self.pop_lin_d = (self.cpg[7].soma.addr['neu'])
self.pop_lin_s = (self.cpg[6].soma.addr['neu'])
self.pop_cn_s = (self.cpg[4].soma.addr['neu'])
self.pop_cn_d = (self.cpg[5].soma.addr['neu'])
# chip population
#oscillator population
pop_osc = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_osc[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.popsosc))
for i in range(self.n_segments)
]
pop_osc1 = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_osc1[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.popsosc1))
for i in range(self.n_segments)
]
#mn population dx
pop_mn_dx = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_mn_dx[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.pop_mn_d))
for i in range(self.n_segments)
]
#mn population sx
pop_mn_sx = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_mn_sx[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.pop_mn_s))
for i in range(self.n_segments)
]
#ein population sx
pop_ein_sx = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_ein_sx[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.pop_ein_s))
for i in range(self.n_segments)
]
#ein population dx
pop_ein_dx = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_ein_dx[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.pop_ein_d))
for i in range(self.n_segments)
]
#lin population dx
pop_lin_dx = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_lin_dx[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.pop_lin_d))
for i in range(self.n_segments)
]
#lin population sx
pop_lin_sx = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_lin_sx[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.pop_lin_s))
for i in range(self.n_segments)
]
#cn population sx
pop_cn_sx = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_cn_sx[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.pop_cn_s))
for i in range(self.n_segments)
]
#cn population dx
pop_cn_dx = [
pyNCS.Population('neurons', 'oscillator input')
for i in range(self.n_segments)
]
[
pop_cn_dx[i].populate_by_id(self.setup, 'mn256r1', 'excitatory',
np.array(self.pop_cn_d))
for i in range(self.n_segments)
]
pass
def build_setup(setupfile='test.xml'):
nsetup = NeuroSetup('setupfiles/test_setuptype.xml',
'setupfiles/' + setupfile,
offline=False)
set_default_biases(nsetup=nsetup, biases_dir='biases/')
return nsetup
if __name__ == '__main__':
nsetup = build_setup()
nsetup.chips['ifslwta'].set_parameter('pinj', 2.82)
seq_pop = pyNCS.Population('default', 'Default Population')
seq_pop.populate_by_number(nsetup, 'seq', 'excitatory', 60)
seq_pop1 = seq_pop[:30]
seq_pop2 = seq_pop[30:]
exc_pop = pyNCS.Population('default', 'Default Population')
exc_pop.populate_by_number(nsetup, 'ifslwta', 'excitatory', 60)
exc_pop1 = exc_pop[:30]
exc_pop2 = exc_pop[30:]
mon = nsetup.monitors.import_monitors_otf([exc_pop1, exc_pop2])
c1 = pyNCS.PConnection(seq_pop1, exc_pop1, 'excitatory0', 'random_all2all',
{'p': 1.0})
def _populate_chip(self):
self.popsne = self._populate_neurons(len(self.rcn.soma.addr))
# chip population
self.mypop_e = pyNCS.Population('neurons', 'for fun')
self.mypop_e.populate_by_id(self.setup,'mn256r1','excitatory',np.array(self.popsne))
load_config = True
config_dir = 'data_reservoir/ee03-ii02_b4/'
wavefile = 'Hackenelektrodenableitung_mecopoda_elongata_chirper_2.wav'
if use_chip:
##########################################
# INIT PYNCS and CHIP
########################################
prefix = '/home/federico/projects/work/trunk/code/python/mn256r1_ncs/'
setuptype = '/home/federico/projects/work/trunk/code/python/mn256r1_ncs/setupfiles/mc_final_mn256r1_adcs.xml'
setupfile = '/home/federico/projects/work/trunk/code/python/mn256r1_ncs/setupfiles/final_mn256r1_adcs.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = nsetup.chips['mn256r1']
p = pyNCS.Population('', '')
p.populate_all(nsetup, 'mn256r1', 'excitatory')
inputpop = pyNCS.Population('', '')
inputpop.populate_by_id(nsetup, 'mn256r1', 'excitatory',
np.linspace(0, 255, 256))
#reset multiplexer
bioamp = Bioamp(inputpop)
bioamp._init_fpga_mapper()
#######################################################3
#### RESERVOIR
########################################################
rcnpop = pyNCS.Population('neurons', 'for fun')
################################
import pyNCS
from pyNCS.neurosetup import NeuroSetup
import sys
# Define file paths
prefix = './chipfiles/'
setuptype = 'setupfiles/mc_final_mn256r1.xml'
setupfile = 'setupfiles/final_mn256r1.xml'
#Create Chip objects
setup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = setup.chips['mn256r1']
#chip population
mypop_e = [pyNCS.Population('neurons', 'for fun') for i in range(len(popsne))]
[
mypop_e[i].populate_by_id(setup, 'mn256r1', 'excitatory',
np.array(popsne[i])) for i in range(len(popsne))
]
#chip population
mypop_i = [pyNCS.Population('neurons', 'for fun') for i in range(len(popsne))]
[
mypop_i[i].populate_by_id(setup, 'mn256r1', 'excitatory',
np.array(popsni[i])) for i in range(len(popsni))
]
#all neurons
noise_in = pyNCS.Population('neurons', 'for fun')
noise_in.populate_by_id(setup, 'mn256r1', 'excitatory',
import time
import scipy.signal
import subprocess
from pyNCS.pyST import SpikeList
res = L.Reservoir() #reservoir without configuring the chip
ion()
figs = figure()
prefix = '../'
setuptype = '../setupfiles/mc_final_mn256r1_adcs.xml'
setupfile = '../setupfiles/final_mn256r1_adcs.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = nsetup.chips['mn256r1']
p = pyNCS.Population('', '')
p.populate_all(nsetup, 'mn256r1', 'excitatory')
inputpop = pyNCS.Population('', '')
inputpop.populate_by_id(nsetup, 'mn256r1', 'excitatory',
np.linspace(0, 255, 256))
#then load bioamp biases on top of these
rcnpop = pyNCS.Population('neurons', 'for fun')
rcnpop.populate_all(nsetup, 'mn256r1', 'excitatory')
broadcast_pop = pyNCS.Population('', '')
broadcast_pop.populate_all(nsetup, 'mn256r1', 'excitatory')
perceptron_pops = pyNCS.Population("", "")
perceptron_pops.populate_by_id(nsetup, 'mn256r1', 'excitatory',
np.linspace(0, 5, 6))
out_perc = pyNCS.monitors.SpikeMonitor(perceptron_pops.soma)
################################
import pyNCS
from pyNCS.neurosetup import NeuroSetup
neurons = np.linspace(0, 255, 256)
# Define file paths
prefix = './chipfiles/'
setuptype = 'setupfiles/mc_final_mn256r1_adcs.xml'
setupfile = 'setupfiles/final_mn256r1_adcs.xml'
#Create Chip objects
setup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = setup.chips['mn256r1']
chip_pop = pyNCS.Population('neurons', 'target ')
chip_pop.populate_by_number(setup, 'mn256r1', 'excitatory', 256)
pulse_neu = pyNCS.Population('neurons', 'monitoring ')
pulse_neu.populate_by_id(setup, 'mn256r1', 'adcs', [310])
up_neu = pyNCS.Population('neurons', 'monitoring ')
up_neu.populate_by_id(setup, 'mn256r1', 'adcs', [305])
dn_neu = pyNCS.Population('neurons', 'monitoring ')
dn_neu.populate_by_id(setup, 'mn256r1', 'adcs', [300])
#ad_mon = pyNCS.Population('neurons', 'monitoring ')
#ad_mon.populate_by_number(setup,'mn256r1','adcs',(2**16-257))
#monitors
# Define file paths
prefix = './chipfiles/'
setuptype = 'setupfiles/mc_final_mn256r1.xml'
setupfile = 'setupfiles/final_mn256r1.xml'
#Create Chip objects
setup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = setup.chips['mn256r1']
neu_to_stim = [np.random.randint(256) for i in range(16)]
neu_to_stim = np.sort(np.unique(neu_to_stim))
neu_back_ground = np.linspace(0, 255, 256)
neu_back_ground = np.delete(neu_back_ground, neu_to_stim)
#all neurons
all_neu = pyNCS.Population('neurons', 'for fun')
all_neu.populate_by_id(setup, 'mn256r1', 'excitatory',
np.linspace(0, 255, 256))
stim_neu = pyNCS.Population('neurons', 'for fun')
stim_neu.populate_by_id(setup, 'mn256r1', 'excitatory', neu_to_stim)
back_neu = pyNCS.Population('neurons', 'for fun')
back_neu.populate_by_id(setup, 'mn256r1', 'excitatory', neu_back_ground)
#switch on monitors
mon_all = pyNCS.monitors.SpikeMonitor(all_neu.soma)
mon_stim = pyNCS.monitors.SpikeMonitor(stim_neu.soma)
mon_back = pyNCS.monitors.SpikeMonitor(back_neu.soma)
setup.monitors.import_monitors([mon_all, mon_stim, mon_back])
import sys
sys.path.append('../api/wij/')
from wij import SynapsesLearning
import time
import scipy.signal
import subprocess
from pyNCS.pyST import SpikeList
ion()
#setup definitions
prefix = '../'
setuptype = '../setupfiles/mc_final_mn256r1_adcs.xml'
setupfile = '../setupfiles/final_mn256r1_adcs.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = nsetup.chips['mn256r1']
inputpop = pyNCS.Population('', '')
inputpop.populate_by_id(nsetup, 'mn256r1', 'excitatory',
np.linspace(0, 255, 256))
broadcast_pop = pyNCS.Population('', '')
broadcast_pop.populate_all(nsetup, 'mn256r1', 'excitatory')
nsetup.mapper._program_detail_mapping(2**0)
#init class synapses learning
sl = SynapsesLearning(inputpop, 'learning')
def init_chip():
#remove recurrent connection and load learning biases
nsetup.chips['mn256r1'].load_parameters(
'biases/biases_wijlearning_tbiocas15.biases')
from wij import SynapsesLearning
import time
import scipy.signal
import subprocess
from pyNCS.pyST import SpikeList
ion()
#setup definitions
prefix = '../'
setuptype = '../setupfiles/mc_final_mn256r1_adcs.xml'
setupfile = '../setupfiles/final_mn256r1_adcs.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = nsetup.chips['mn256r1']
inputpop = pyNCS.Population('', '')
inputpop.populate_by_id(nsetup, 'mn256r1', 'excitatory',
np.linspace(0, 255, 256))
broadcast_pop = pyNCS.Population('', '')
broadcast_pop.populate_all(nsetup, 'mn256r1', 'excitatory')
nsetup.mapper._program_detail_mapping(2**0)
#init class synapses learning
sl = SynapsesLearning(inputpop, 'learning')
def build_stimulus_virtual(neu, freq, duration=1000, t_start=0):
index_neu = inputpop.synapses['virtual_exc'].addr['neu'] == neu
syn_teaching_this_neu = inputpop.synapses['virtual_exc'][index_neu]
stimulus_teach = syn_teaching_this_neu.spiketrains_poisson(
plot_planes = False
connect_retina = True
measure_scope = False
read_syn_matrix = False
do_learning_exp = False
if (is_configured == False):
prefix = '../'
setuptype = '../setupfiles/mc_final_mn256r1.xml'
setupfile = '../setupfiles/final_mn256r1_retina_monster.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = nsetup.chips['mn256r1']
nsetup.mapper._init_fpga_mapper()
p = pyNCS.Population('', '')
p.populate_all(nsetup, 'mn256r1', 'excitatory')
#reset multiplexer
chip.configurator._set_multiplexer(0)
nsetup.chips['mn256r1'].load_parameters('biases/biases_default.biases')
#init class synapses learning
sl = SynapsesLearning(p, 'learning')
if (plot_planes):
n_trial_per_point = 1
tot_ltp = []
tot_ltd = []
tot_freqs = []
#populations divisible by 2 for encoders
neuron_ids = [np.linspace(0, 127, 128), np.linspace(128, 255, 128)]
npops = len(neuron_ids)
#setup
prefix = '../'
setuptype = '../setupfiles/mc_final_mn256r1.xml'
setupfile = '../setupfiles/final_mn256r1_retina_monster.xml'
nsetup = pyNCS.NeuroSetup(setuptype, setupfile, prefix=prefix)
chip = nsetup.chips['mn256r1']
#nsetup.mapper._init_fpga_mapper()
chip.configurator._set_multiplexer(0)
#populate neurons
nefpops = [
pyNCS.Population('neurons', 'for fun') for i in range(len(neuron_ids))
]
for this_pop in range(npops):
nefpops[this_pop].populate_by_id(nsetup, 'mn256r1', 'excitatory',
neuron_ids[this_pop])
#populate broadcast pop
b_nefpop = pyNCS.Population('neurons', 'for fun')
b_nefpop.populate_by_id(nsetup, 'mn256r1', 'excitatory',
np.linspace(0, 255,
256)) #good luck in understanding this...
#encoders
encoders = [np.zeros(len(neuron_ids[i])) for i in range(npops)]
for this_pop in range(npops):
encoders[this_pop] = np.concatenate([
np.ones(len(neuron_ids[this_pop]) / 2) * -1,
