def test_pynn_basic(self):
pass
"""
TODO figure out how to take machine name as a parameter
"""
print "test_pynn_basic setup....."
pynn.setup(**{'machine': 'spinn-7'})
n_atoms = 10
proj1_params = {
'source': None,
'delays': 1,
'weights': 1,
'target': 'excitatory'
}
proj2_params = {
'allow_self_connections': True,
'delays': 2,
'p_connect': 0.1,
'weights': 2,
'source': None,
'target': None
}
cell_params = {
'tau_m': 64,
'v_init': -75,
'i_offset': 0,
'v_rest': -75,
'v_reset': -95,
'v_thresh': -40,
'tau_syn_E': 15,
'tau_syn_I': 15,
'tau_refrac': 10
}
pop1 = pynn.Population(n_atoms,
pynn.IF_curr_exp,
cell_params,
label='pop1')
pop2 = pynn.Population(n_atoms * 2,
pynn.IF_curr_exp,
cell_params,
label='pop2')
proj1 = pynn.Projection(pop1,
pop2,
pynn.OneToOneConnector(weights=1, delays=1),
target='excitatory')
proj2 = pynn.Projection(
pop1, pop2,
pynn.FixedProbabilityConnector(weights=2, delays=2, p_connect=.1))
pynn.controller.map_model() # at this stage the model is mapped
print "checking vertices..."
self.assertEqual(pop1.vertex.parameters, cell_params)
self.assertEqual(pynn.controller.dao.vertices[1].parameters,
cell_params)
self.assertEqual(pop1.vertex.model,
pacman103.front.pynn.models.IF_curr_exp)
self.assertEqual(pynn.controller.dao.vertices[0].label, "pop1")
self.assertEqual(pynn.controller.dao.vertices[1].label, "pop2")
self.assertEqual(pop1.vertex.atoms, n_atoms)
self.assertEqual(pynn.controller.dao.vertices[1].atoms, n_atoms * 2)
print "checking edges..."
self.assertEqual(pynn.controller.dao.edges[0].model,
pacman103.front.pynn.connectors.OneToOneConnector)
self.assertEqual(
proj2.edge.model,
pacman103.front.pynn.connectors.FixedProbabilityConnector)
self.assertEqual(proj1.edge.parameters, proj1_params)
self.assertEqual(pynn.controller.dao.edges[1].parameters, proj2_params)
# testing the mapping phase
self.assertEqual(len(pynn.controller.dao.subedges), 2)
self.assertEqual(len(pynn.controller.dao.subvertices), 2)
self.assertEqual(len(pynn.controller.dao.routings), 2)
# pynn.run(100)
pynn.end()
delay = 17
loopConnections = list()
for i in range(0, nNeurons):
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay)
loopConnections.append(singleConnection)
injectionConnection = [(0, 0, weight_to_spike, 1)]
spikeArray = {'spike_times': [[0]]}
populations.append(
p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1'))
populations.append(
p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1'))
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(loopConnections)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injectionConnection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record(visualiser_mode=modes.RASTER)
p.run(5000)
v = None
gsyn = None
spikes = None
v = populations[0].get_v(compatible_output=True)
# Neuron populations
pre_pop = sim.Population(pop_size, model, cell_params)
post_pop = sim.Population(pop_size, model, cell_params)
# Stimulating populations
pre_stim = sim.Population(pop_size, sim.SpikeSourceArray, {'spike_times': [[i for i in range(0, sim_time, time_between_pairs)],]})
post_stim = sim.Population(pop_size, sim.SpikeSourceArray, {'spike_times': [[i for i in range(pairing_start_time, pairing_end_time, time_between_pairs)],]})
# +-------------------------------------------------------------------+
# | Creation of connections |
# +-------------------------------------------------------------------+
# Connection type between noise poisson generator and excitatory populations
ee_connector = sim.OneToOneConnector(weights=2)
sim.Projection(pre_stim, pre_pop, ee_connector, target='excitatory')
sim.Projection(post_stim, post_pop, ee_connector, target='excitatory')
# Plastic Connections between pre_pop and post_pop
stdp_model = sim.STDPMechanism(
timing_dependence = sim.SpikePairRule(tau_plus = 20.0, tau_minus = 50.0),
weight_dependence = sim.AdditiveWeightDependence(w_min = 0.1, w_max = 1, A_plus=0.02, A_minus = 0.02)
)
prepostpro = sim.Projection(pre_pop, post_pop, sim.OneToOneConnector(weights=1.0),
synapse_dynamics = sim.SynapseDynamics(slow= stdp_model)
)
# Record spikes
pre_pop.record()
post_pop.record()
#input_pol_2 = p.Population(128*128, p.ProxyNeuron, {'x_source':254, 'y_source':250}, label='input_pol2')
#input_pol_2.set_mapping_constraint({'x':1,'y':0}) # this is where the sensor is going to be actually mapped in the NN
subsampled = p.Population(
subsample_size * subsample_size, # size
p.IF_curr_exp, # Neuron Type
cell_params_subsample, # Neuron Parameters
label="Input") # Label
subsampled.initialize('v', -75)
subsampled.set_mapping_constraint({'x': 0, 'y': 1})
#subsampled.record() # sends spikes to the visualiser (use parameters = 32)
p1_up = p.Projection(input_pol_1_up,
subsampled,
p.FromListConnector(
retina_lib.subSamplerConnector2D(
128, subsample_size, .2, 1)),
label='subsampling projection')
p1_down = p.Projection(input_pol_1_down,
subsampled,
p.FromListConnector(
retina_lib.subSamplerConnector2D(
128, subsample_size, .2, 1)),
label='subsampling projection')
p2_up = p.Projection(input_pol_2_up,
subsampled,
p.FromListConnector(
retina_lib.subSamplerConnector2D(
128, subsample_size, .2, 1)),
label='subsampling projection')
p2_down = p.Projection(input_pol_2_down,
'duration': simtime
},
label="expoisson")
# +-------------------------------------------------------------------+
# | Creation of connections |
# +-------------------------------------------------------------------+
# Connection parameters
JEE = 3.
# Connection type between noise poisson generator and excitatory populations
ee_connector = sim.OneToOneConnector(weights=JEE * 0.05)
# Noise projections
sim.Projection(INoisePre, pre_pop, ee_connector, target='excitatory')
sim.Projection(INoisePost, post_pop, ee_connector, target='excitatory')
# Additional Inputs projections
for i in range(len(IAddPre)):
sim.Projection(IAddPre[i], pre_pop, ee_connector, target='excitatory')
for i in range(len(IAddPost)):
sim.Projection(IAddPost[i], post_pop, ee_connector, target='excitatory')
# Plastic Connections between pre_pop and post_pop
stdp_model = sim.STDPMechanism(
timing_dependence=sim.SpikePairRule(tau_plus=20.,
tau_minus=50.0,
nearest=True),
weight_dependence=sim.AdditiveWeightDependence(w_min=0,
w_max=0.9,
#!/usr/bin/python
import pacman103.front.pynn as p
import numpy, pylab
#set up pacman103
p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0)
#external stuff population requiremenets
connected_chip_coords = {'x': 0, 'y': 0}
virtual_chip_coords = {'x': 0, 'y': 5}
link = 4
populations = list()
projections = list()
populations.append(p.Population(1, p.SpikeSourcePoisson, {'rate': 10000}))
populations.append(
p.Population(1,
p.RobotMotorControl, {
'virtual_chip_coords': virtual_chip_coords,
'connected_chip_coords': connected_chip_coords,
'connected_chip_edge': link
},
label='External motor control'))
projections.append(
p.Projection(populations[0], populations[1], p.OneToOneConnector()))
p.run(10000)
rng=rng,
boundaries=[0.1, 9.9],
constrain='redraw')
inh_delay_distr = RandomDistribution('normal',
parameters=[0.75, 0.375],
rng=rng,
boundaries=[0.1, 9.9],
constrain='redraw')
delay_distr_recurrent = RandomDistribution('uniform', [2.0, 8.0], rng=rng)
weight_distr_ffwd = RandomDistribution('uniform', [0.5, 1.25], rng=rng)
weight_distr_recurrent = RandomDistribution('uniform', [0.1, 0.2], rng=rng)
projections.append(
p.Projection(populations[stimulus],
populations[excit],
p.AllToAllConnector(weights=baseline_excit_weight,
delays=1.0),
target='excitatory',
synapse_dynamics=p.SynapseDynamics(slow=stdp_model)))
projections.append(
p.Projection(populations[teacher],
populations[excit],
p.OneToOneConnector(weights=weight_to_force_firing,
delays=1.0),
target='excitatory'))
#projections.append(p.Projection(populations[stimulus], populations[inhib], p.FixedProbabilityConnector(p_connect=p_exc2inh, weights=baseline_excit_weight, delays=inh_delay_distr), target='excitatory'))
populations[stimulus].record(visualiser_mode=modes.RASTER)
#populations[inhib].record_v()
#populations[inhib].record(visualiser_mode=modes.RASTER)
populations.append(
p.Population(100, p.IF_curr_exp, cell_params_lif, label='pop_13'))
populations[12].set_mapping_constraint({'x': 0, 'y': 0})
populations.append(
p.Population(100, p.IF_curr_exp, cell_params_lif, label='pop_14'))
populations[13].set_mapping_constraint({'x': 0, 'y': 0})
populations.append(
p.Population(100, p.IF_curr_exp, cell_params_lif, label='pop_15'))
populations[14].set_mapping_constraint({'x': 0, 'y': 0})
populations.append(
p.Population(100, p.IF_curr_exp, cell_params_lif, label='pop_16'))
populations[15].set_mapping_constraint({'x': 4, 'y': 3})
projections.append(
p.Projection(populations[0], populations[15],
p.FromListConnector(injectionConnection)))
projections.append(
p.Projection(populations[1], populations[15],
p.FromListConnector(injectionConnection)))
projections.append(
p.Projection(populations[2], populations[15],
p.FromListConnector(injectionConnection)))
projections.append(
p.Projection(populations[3], populations[15],
p.FromListConnector(injectionConnection)))
projections.append(
p.Projection(populations[4], populations[15],
p.FromListConnector(injectionConnection)))
projections.append(
p.Projection(populations[5], populations[15],
p.FromListConnector(injectionConnection)))
'tau_refrac' : 100,
'i_offset' : 1
}
cell_params_lif = { 'tau_m' : 32,
'cm' : 0.35, # added to make PACMAN103 work
'v_init' : -80,
'v_rest' : -70,
'v_reset' : -95,
'v_thresh' : -55,
'tau_syn_E' : 5,
'tau_syn_I' : 10,
'tau_refrac' : 5,
'i_offset' : 0
}
populations = list()
projections = list()
populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif_in, label='pop_0'))
populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1'))
projections.append(p.Projection(populations[0], populations[1], p.OneToOneConnector(weights=8, delays=16)))
populations[0].set_mapping_constraint({'x':7, 'y':7})
populations[1].set_mapping_constraint({'x':3, 'y':4})
p.run(3000)
'connected_chip_coords': connected_chip_coords,
'connected_chip_edge': link,
'polarity': p.ExternalFPGARetinaDevice.DOWN_POLARITY},
label='External retina'))
'''
#loopConnections = list()
#for i in range(0, 1):
# singleConnection = (i, ((i + 1) % 1), 1, 1)
# loopConnections.append(singleConnection)
populations.append(
p.Population(1024, p.IF_curr_exp, cell_params_lif, label='pop_1'))
projections.append(
p.Projection(
populations[0], populations[2],
p.FromListConnector(retina_lib.subSamplerConnector2D(128, 32, .2, 1))))
projections.append(
p.Projection(
populations[1], populations[2],
p.FromListConnector(retina_lib.subSamplerConnector2D(128, 32, .2, 1))))
populations[0].record(visualiser_mode=modes.TOPOLOGICAL,
visualiser_2d_dimension={
'x': 128,
'y': 128
})
populations[1].record(visualiser_mode=modes.TOPOLOGICAL,
visualiser_2d_dimension={
'x': 128,
'y': 128
