def test(learnt_weights, learnt_biases):
# SpiNNaker setup
sim.setup(timestep=1.0,
min_delay=1.0,
max_delay=10.0,
spinnaker_hostname="192.168.1.1")
# Generate testing stimuli patters
testing_stimuli_rates = [
[MAX_FREQUENCY, MIN_FREQUENCY, MAX_FREQUENCY, MIN_FREQUENCY],
[MIN_FREQUENCY, MAX_FREQUENCY, MAX_FREQUENCY, MIN_FREQUENCY],
]
# Generate uncertain class stimuli pattern
uncertain_stimuli_rates = [
[MAX_FREQUENCY * 0.5],
[MAX_FREQUENCY * 0.5],
]
# Build basic network
input_populations, class_populations = build_basic_network(
testing_stimuli_rates, TESTING_STIMULUS_TIME, uncertain_stimuli_rates,
TESTING_TIME, True, learnt_biases, False, sim)
# Create BCPNN model with weights disabled
bcpnn_synapse = bcpnn.BCPNNSynapse(tau_zi=BCPNN_TAU_PRIMARY,
tau_zj=BCPNN_TAU_PRIMARY,
tau_p=BCPNN_TAU_ELIGIBILITY,
f_max=MAX_FREQUENCY,
w_max=BCPNN_MAX_WEIGHT,
weights_enabled=True,
plasticity_enabled=False)
for ((i, c),
w) in zip(itertools.product(input_populations, class_populations),
learnt_weights):
# Convert learnt weight matrix into a connection list
connections = convert_weights_to_list(w, 1.0, 7.0)
# Create projections
sim.Projection(i,
c,
sim.FromListConnector(connections),
bcpnn_synapse,
receptor_type="excitatory",
label="%s-%s" % (i.label, c.label))
# Run simulation
sim.run(TESTING_TIME)
# Read spikes from input and class populations
input_data = [i.get_data() for i in input_populations]
class_data = [c.get_data() for c in class_populations]
# End simulation on SpiNNaker
sim.end()
# Return spikes
return input_data, class_data
def train(sepal_length, sepal_length_unit_mean_sd,
sepal_width, sepal_width_unit_mean_sd,
petal_length, petal_length_unit_mean_sd,
petal_width, petal_width_unit_mean_sd,
unique_species, species):
# SpiNNaker setup
sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0,
spinnaker_hostname="192.168.1.1")
# Calculate input rates
input_rates = []
calculate_stim_rates(sepal_length, sepal_length_unit_mean_sd, input_rates, MAX_FREQUENCY)
calculate_stim_rates(sepal_width, sepal_width_unit_mean_sd, input_rates, MAX_FREQUENCY)
calculate_stim_rates(petal_length, petal_length_unit_mean_sd, input_rates, MAX_FREQUENCY)
calculate_stim_rates(petal_width, petal_width_unit_mean_sd, input_rates, MAX_FREQUENCY)
# Calculate class rates
class_rates = []
for u, _ in enumerate(unique_species):
class_rates.append(list((species == u) * MAX_FREQUENCY))
# Build basic network with orthogonal stimulation of both populations
input_populations, class_populations = build_basic_network(input_rates, STIMULUS_TIME,
class_rates, STIMULUS_TIME,
False, 0.0, True, sim)
# Create BCPNN model with weights disabled
bcpnn_synapse = bcpnn.BCPNNSynapse(
tau_zi=BCPNN_TAU_PRIMARY,
tau_zj=BCPNN_TAU_PRIMARY,
tau_p=BCPNN_TAU_ELIGIBILITY,
f_max=MAX_FREQUENCY,
w_max=BCPNN_MAX_WEIGHT,
weights_enabled=False,
plasticity_enabled=True,
weight=0.0)
# Create all-to-all connector to connect inputs to classes
input_class_connector = sim.AllToAllConnector()
# Loop through all pairs of input populations and classes
plastic_connections = []
for (i, c) in itertools.product(input_populations, class_populations):
# Connect input to class with all-to-all plastic synapse
connection = sim.Projection(i, c, input_class_connector, bcpnn_synapse,
receptor_type="excitatory", label="%s-%s" % (i.label, c.label))
plastic_connections.append(connection)
# Run simulation
sim.run(STIMULUS_TIME * len(sepal_length))
# Read biases
# **HACK** investigate where out by 1000 comes from!
learnt_biases = [c.get_data().segments[0].filter(name="bias")[0][-1,:] * 0.001
for c in class_populations]
# Read plastic weights
learnt_weights = [p.get("weight", format="array") for p in plastic_connections]
return learnt_biases, learnt_weights
def test_discrete(connection_weight_filenames, hcu_biases,
ampa_gain, nmda_gain, tau_ca2, i_alpha,
stim_minicolumns, testing_simtime, delay_model,
num_hcu, num_mcu_per_hcu, num_mcu_neurons, record_membrane, **setup_kwargs):
assert len(hcu_biases) == num_hcu, "An array of biases must be provided for each HCU"
assert len(connection_weight_filenames) == (num_hcu ** 2), "A tuple of weight matrix filenames must be provided for each HCU->HCU product"
# Scale parameters to obtain HCU size and synaptic stringth
num_excitatory, num_inhibitory, JE, JI = scale_parameters(num_mcu_per_hcu, num_mcu_neurons)
# Setup simulator and seed RNG
sim.setup(timestep=dt, min_delay=dt, max_delay=7.0 * dt, **setup_kwargs)
rng = NumpyRNG(seed=1)
# Calculate mean firing rate
e_cell_mean_firing_rate = (num_mcu_neurons / num_excitatory) * 20.0
# Build HCUs configured for testing
hcus = [HCU.testing_adaptive(name="%u" % i, sim=sim, rng=rng,
num_excitatory=num_excitatory, num_inhibitory=num_inhibitory, JE=JE, JI=JI,
bias=bias, tau_ca2=tau_ca2, i_alpha=i_alpha,
e_cell_mean_firing_rate=e_cell_mean_firing_rate,
simtime=testing_simtime, record_membrane=record_membrane,
stim_spike_times=generate_discrete_hcu_stimuli(stim_minicolumns, num_excitatory, num_mcu_per_hcu)) for i, bias in enumerate(hcu_biases)]
# **HACK** not actually plastic - just used to force signed weights
bcpnn_synapse = bcpnn.BCPNNSynapse(
tau_zi=tau_syn_ampa_gaba,
tau_zj=tau_syn_ampa_gaba,
tau_p=1000.0,
f_max=20.0,
w_max=JE,
weights_enabled=True,
plasticity_enabled=False)
# Loop through all hcu products and their corresponding connection weight
for connection_weight_filename, ((i_pre, hcu_pre), (i_post, hcu_post)) in zip(connection_weight_filenames, itertools.product(enumerate(hcus), repeat=2)):
# Use delay model to calculate delay
hcu_delay = delay_model(i_pre, i_post)
logger.info("Connecting HCU %u->%u with delay %ums" % (i_pre, i_post, hcu_delay))
# Build connections
HCUConnection.testing(
sim=sim,
pre_hcu=hcu_pre, post_hcu=hcu_post,
ampa_gain=ampa_gain, nmda_gain=nmda_gain,
ampa_synapse=bcpnn_synapse, nmda_synapse=bcpnn_synapse,
connection_weight_filename=connection_weight_filename, delay=hcu_delay)
# Run simulation
sim.run(testing_simtime)
# Read results from HCUs
results = [hcu.read_results() for hcu in hcus]
return results, sim.end
def test(sepal_length, sepal_length_unit_mean_sd,
sepal_width, sepal_width_unit_mean_sd,
petal_length, petal_length_unit_mean_sd,
petal_width, petal_width_unit_mean_sd,
num_species,
learnt_biases, learnt_weights):
# SpiNNaker setup
sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0,
spinnaker_hostname="192.168.1.1")
# Calculate input rates
input_rates = []
calculate_stim_rates(sepal_length, sepal_length_unit_mean_sd, input_rates, MAX_FREQUENCY)
calculate_stim_rates(sepal_width, sepal_width_unit_mean_sd, input_rates, MAX_FREQUENCY)
calculate_stim_rates(petal_length, petal_length_unit_mean_sd, input_rates, MAX_FREQUENCY)
calculate_stim_rates(petal_width, petal_width_unit_mean_sd, input_rates, MAX_FREQUENCY)
# Generate uncertain class pattern
uncertain_class_rates = [[MAX_FREQUENCY * (1.0 / num_species)]
for s in range(num_species)]
# Build basic network
testing_time = STIMULUS_TIME * len(sepal_length)
input_populations, class_populations = build_basic_network(input_rates, STIMULUS_TIME,
uncertain_class_rates, testing_time,
True, learnt_biases, False, sim)
# Create BCPNN model with weights disabled
bcpnn_synapse = bcpnn.BCPNNSynapse(
tau_zi=BCPNN_TAU_PRIMARY,
tau_zj=BCPNN_TAU_PRIMARY,
tau_p=BCPNN_TAU_ELIGIBILITY,
f_max=MAX_FREQUENCY,
w_max=BCPNN_MAX_WEIGHT,
weights_enabled=True,
plasticity_enabled=False)
for ((i, c), w) in zip(itertools.product(input_populations, class_populations), learnt_weights):
# Convert learnt weight matrix into a connection list
connections = convert_weights_to_list(w, 1.0, 7.0 * (30.0 / float(CLASS_POP_SIZE)))
# Create projections
sim.Projection(i, c, sim.FromListConnector(connections), bcpnn_synapse,
receptor_type="excitatory", label="%s-%s" % (i.label, c.label))
# Run simulation
sim.run(testing_time)
# Read spikes from input and class populations
input_data = [i.get_data() for i in input_populations]
class_data = [c.get_data() for c in class_populations]
# End simulation on SpiNNaker
sim.end()
# Return spikes
return input_data, class_data
def test(learnt_weights, learnt_biases):
# SpiNNaker setup
sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0, spinnaker_hostname="192.168.1.1")
# Generate testing stimuli patters
testing_stimuli_rates = [
[MAX_FREQUENCY, MIN_FREQUENCY, MAX_FREQUENCY, MIN_FREQUENCY],
[MIN_FREQUENCY, MAX_FREQUENCY, MAX_FREQUENCY, MIN_FREQUENCY],
]
# Generate uncertain class stimuli pattern
uncertain_stimuli_rates = [
[MAX_FREQUENCY * 0.5],
[MAX_FREQUENCY * 0.5],
]
# Build basic network
input_populations, class_populations = build_basic_network(testing_stimuli_rates, TESTING_STIMULUS_TIME,
uncertain_stimuli_rates, TESTING_TIME,
True, learnt_biases, False, sim)
# Create BCPNN model with weights disabled
bcpnn_synapse = bcpnn.BCPNNSynapse(
tau_zi=BCPNN_TAU_PRIMARY,
tau_zj=BCPNN_TAU_PRIMARY,
tau_p=BCPNN_TAU_ELIGIBILITY,
f_max=MAX_FREQUENCY,
w_max=BCPNN_MAX_WEIGHT,
weights_enabled=True,
plasticity_enabled=False)
for ((i, c), w) in zip(itertools.product(input_populations, class_populations), learnt_weights):
# Convert learnt weight matrix into a connection list
connections = convert_weights_to_list(w, 1.0, 7.0)
# Create projections
sim.Projection(i, c, sim.FromListConnector(connections), bcpnn_synapse,
receptor_type="excitatory", label="%s-%s" % (i.label, c.label))
# Run simulation
sim.run(TESTING_TIME)
# Read spikes from input and class populations
input_data = [i.get_data() for i in input_populations]
class_data = [c.get_data() for c in class_populations]
# End simulation on SpiNNaker
sim.end()
# Return spikes
return input_data, class_data
'''
# Create connector
proj = sim.Projection(neurons, neurons, sim.FromListConnector(conn_list),
stdp_model,
receptor_type="excitatory")
# Stimulate stim neuron
stim = sim.Population(1, sim.SpikeSourceArray(spike_times=[2.0]), label="stim")
sim.Projection(stim, neurons,
sim.FromListConnector([(0, get_neuron_index(stim_x, stim_y, cost_image.shape[1]),
instant_spike_weight, 1.0)]),
sim.StaticSynapse())
# Run network
sim.run(duration)
# Read data
data = neurons.get_data()
weights = proj.get("weight", format="list", with_address=True)
sim.end()
# Create weight graph with each neuron marked
weight_graph = graphviz.Digraph(engine="neato", format="svg")
spacing = 2.0
for n in range(num_neurons):
neuron_x, neuron_y = get_neuron_x_y(n, cost_image.shape[1])
weight_graph.node(str(n), label="%u, %u" % (neuron_x, neuron_y),
pos="%f,-%f!" % (neuron_x * spacing, neuron_y * spacing))
def train_discrete(ampa_tau_zi, ampa_tau_zj, nmda_tau_zi, nmda_tau_zj, tau_p,
stim_minicolumns, training_simtime, delay_model,
num_hcu, num_mcu_per_hcu, num_mcu_neurons, **setup_kwargs):
# Scale parameters to obtain HCU size and synaptic stringth
num_excitatory, num_inhibitory, JE, JI = scale_parameters(num_mcu_per_hcu, num_mcu_neurons)
# Setup simulator and seed RNG
sim.setup(timestep=dt, min_delay=dt, max_delay=7.0 * dt, **setup_kwargs)
rng = NumpyRNG(seed=1)
# Calculate mean firing rate
e_cell_mean_firing_rate = 4.0#(float(num_mcu_neurons) / float(num_excitatory)) * 20.0
# Build HCUs configured for training
hcus = [HCU.training(name="%u" % h, sim=sim, rng=rng, simtime=training_simtime,
num_excitatory=num_excitatory, num_inhibitory=num_inhibitory, JE=JE, JI=JI,
intrinsic_tau_z=ampa_tau_zj, intrinsic_tau_p=tau_p,
e_cell_mean_firing_rate=e_cell_mean_firing_rate,
stim_spike_times=generate_discrete_hcu_stimuli(stim_minicolumns, num_excitatory, num_mcu_per_hcu)) for h in range(num_hcu)]
# Loop through all hcu products
connections = []
for (i_pre, hcu_pre), (i_post, hcu_post) in itertools.product(enumerate(hcus), repeat=2):
# Use delay model to calculate delay
hcu_delay = delay_model(i_pre, i_post)
# Build BCPNN models
ampa_synapse = bcpnn.BCPNNSynapse(
tau_zi=ampa_tau_zi,
tau_zj=ampa_tau_zj,
tau_p=tau_p,
f_max=20.0,
w_max=JE,
weights_enabled=False,
plasticity_enabled=True,
weight=0.0,
delay=hcu_delay)
nmda_synapse = bcpnn.BCPNNSynapse(
tau_zi=nmda_tau_zi,
tau_zj=nmda_tau_zj,
tau_p=tau_p,
f_max=20.0,
w_max=JE,
weights_enabled=False,
plasticity_enabled=True,
weight=0.0,
delay=hcu_delay)
logger.info("Connecting HCU %u->%u with delay %ums" % (i_pre, i_post, hcu_delay))
connections.append(HCUConnection.training(
sim=sim, pre_hcu=hcu_pre, post_hcu=hcu_post,
ampa_synapse=ampa_synapse, nmda_synapse=nmda_synapse, rng=rng))
# Run simulation
sim.run(training_simtime)
# Read results from HCUs
hcu_results = [hcu.read_results() for hcu in hcus]
# Read results from inter-hcu connections
connection_results = [c.read_results() for c in connections]
return hcu_results, connection_results, sim.end
def train_discrete(ampa_tau_zi, ampa_tau_zj, nmda_tau_zi, nmda_tau_zj, tau_p,
minicolumn_indices, training_stim_time, training_interval_time,
delay_model, num_hcu, num_mcu_neurons, timer, **setup_kwargs):
# Setup simulator and seed RNG
sim.setup(timestep=dt, min_delay=dt, max_delay=7.0 * dt, **setup_kwargs)
rng = sim.NativeRNG(host_rng=NumpyRNG(seed=1))
# Determine length of each epoch
epoch_duration = training_stim_time + training_interval_time
# Stimulate minicolumns in sequence
stim_minicolumns = [(m, float(i * epoch_duration), 20.0, training_stim_time)
for i, m in enumerate(minicolumn_indices)]
# Calculate length of training required
training_duration = float(len(stim_minicolumns)) * epoch_duration
# Calculate mean firing rate
e_cell_mean_firing_rate = (float(num_mcu_neurons) / float(NE)) * 20.0
# Build HCUs configured for training
hcus = [HCU.training(name="%u" % h, sim=sim, rng=rng, simtime=training_duration,
intrinsic_tau_z=ampa_tau_zj, intrinsic_tau_p=tau_p,
e_cell_mean_firing_rate=e_cell_mean_firing_rate,
stim_spike_times=generate_discrete_hcu_stimuli(stim_minicolumns, num_mcu_neurons)) for h in range(num_hcu)]
# Loop through all hcu products
connections = []
for (i_pre, hcu_pre), (i_post, hcu_post) in itertools.product(enumerate(hcus), repeat=2):
# Use delay model to calculate delay
hcu_delay = delay_model(i_pre, i_post)
# Build BCPNN models
ampa_synapse = bcpnn.BCPNNSynapse(
tau_zi=ampa_tau_zi,
tau_zj=ampa_tau_zj,
tau_p=tau_p,
f_max=20.0,
w_max=JE,
weights_enabled=False,
plasticity_enabled=True,
weight=0.0,
delay=hcu_delay)
nmda_synapse = bcpnn.BCPNNSynapse(
tau_zi=nmda_tau_zi,
tau_zj=nmda_tau_zj,
tau_p=tau_p,
f_max=20.0,
w_max=JE,
weights_enabled=False,
plasticity_enabled=True,
weight=0.0,
delay=hcu_delay)
logger.info("Connecting HCU %u->%u with delay %ums" % (i_pre, i_post, hcu_delay))
connections.append(HCUConnection.training(
sim=sim, pre_hcu=hcu_pre, post_hcu=hcu_post,
ampa_synapse=ampa_synapse, nmda_synapse=nmda_synapse, rng=rng))
logger.info("Build time %gs", timer.diff())
# Run simulation
sim.run(training_duration)
logger.info("Load and run time %gs", timer.diff())
# Read results from HCUs
hcu_results = [hcu.read_results() for hcu in hcus]
# Read results from inter-hcu connections
connection_results = [c.read_results() for c in connections]
return hcu_results, connection_results, sim.end
cell = sim.Population(N, IF_curr_ca2_adaptive_exp(tau_m=20.0, cm=0.5,
v_rest=-70.0, v_reset=-60.0,
v_thresh=-54.0, i_alpha=0.1,
tau_ca2=50.0))
# Create poisson spike source
spike_source = sim.Population(N, sim.SpikeSourcePoisson(rate=2500.0))
sim.Projection(spike_source, cell,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.1, delay=dt),
receptor_type="excitatory")
cell.record("spikes")
sim.run(T)
data = cell.get_data()
# Calculate isis and pair these with bin index of last spike time in pair
# **NOTE** using first spike time in pair leads to a dip at the
# end as the end of long pairs goes off the end of the simulation
binned_isis = numpy.hstack([
numpy.vstack(
(t[1:] - t[:-1],
numpy.digitize(t[1:], numpy.arange(T)) - 1))
for t in data.segments[0].spiketrains])
# Split ISIs into seperate array for each time bin
time_binned_isis = [binned_isis[0, binned_isis[1] == t] for t in range(T)]
sim.StaticSynapse(weight=2.0),
receptor_type="excitatory")
# Plastic Connections between pre_pop and post_pop
bcpnn_synapse = bcpnn.BCPNNSynapse(
tau_zi=10.0, # ms
tau_zj=10.0, # ms
tau_p=1000.0, # ms
f_max=50.0, # Hz
w_max=1.0, # nA / uS for conductance
weights_enabled=False,
plasticity_enabled=True)
proj = sim.Projection(pre_pop, post_pop, sim.OneToOneConnector(), bcpnn_synapse)
# Run simulation
# **TODO** run for 10ms, get weights, rinse and repeat
sim.run(sim_time)
post_data = post_pop.get_data().segments[0].filter(name="bias")[0]
weight_data = proj.get("weight", format="list", with_address=False)
print "Weight:", weight_data
figure, axis = pylab.subplots()
axis.plot(numpy.arange(sim_time), post_data)
pylab.show()
# End simulation
sim.end()
cell_params = {'tau_m' : 20.0, 'cm' : 1.0, 'i_offset' : 0.0, 'tau_refrac' : 3.0,
'v_rest' : -65.0, 'v_thresh' : -51.0, 'tau_syn_E' : 5.0, 'tau_syn_E2' : 100.0,
'tau_syn_I': 5.0, 'v_reset' : -70.0}
cells = [sim.Population(1, IF_curr_dual_exp(**cell_params)),
sim.Population(1, IF_curr_dual_exp(**cell_params))]
spike_sourceE = sim.Population(1, sim.SpikeSourceArray(spike_times=[i for i in range(50, 200, 20)]), label="spike_sourceE")
spike_sourceE2 = sim.Population(1, sim.SpikeSourceArray(spike_times=[i for i in range(100, 200, 100)]), label='spike_sourceE2')
synapse = sim.StaticSynapse(weight=0.5)
sim.Projection(spike_sourceE, cells[0], sim.OneToOneConnector(), synapse, receptor_type='excitatory', label="Excitatory - 0")
sim.Projection(spike_sourceE, cells[1], sim.OneToOneConnector(), synapse, receptor_type='excitatory', label="Excitatory - 1")
sim.Projection(spike_sourceE2, cells[1], sim.OneToOneConnector(), synapse, receptor_type='excitatory2', label="Excitatory2 - 1")
# Record all cells
for cell in cells:
cell.record("v")
# Run simulation
sim.run(200.0)
# Build panels showing membrane potential
panels = [Panel(cell.get_data().segments[0].filter(name="v")[0], ylabel="%s membrane potential (mV)" % cell.label)
for cell in cells]
Figure(*panels, title="Membrane voltages")
plt.show()
sim.end()
r.RecurrentSTDPSynapse(w_min=0.0, w_max=16.0, A_plus=0.3, A_minus=0.3,
accumulator_increase=1.0 / 2.0, accumulator_decrease=1.0 / 6.0,
lambda_pre=10.0, lambda_post=10.0,
tau_a=3000.0,
weight=baseline_excit_weight, delay=1.0),
receptor_type='excitatory')
p.Projection(teaching_pop, excit_pop,
p.OneToOneConnector(),
p.StaticSynapse(weight=weight_to_force_firing, delay=1.0),
receptor_type='excitatory')
excit_pop.record("v")
excit_pop.record("spikes")
p.run(runTime)
final_weights = plastic_connection.get("weight", format="list", with_address=False)
print "Final weights: ", final_weights
excit_data = excit_pop.get_data().segments[0]
p.end()
excit_v = excit_data.filter(name="v")[0]
Figure(
Panel(excit_v, ylabel="Membrane potential (mV)", yticks=True),
Panel(excit_data.spiketrains, xlabel="Time (ms)", xticks=True)
)
def train():
# SpiNNaker setup
sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0, spinnaker_hostname="192.168.1.1")
# Generate orthogonal input stimuli
orthogonal_stimuli_rates = []
num_inputs = len(INPUT_NAMES)
for i in range(num_inputs):
input_stimuli = []
for s in range(TRAINING_TIME / TRAINING_STIMULUS_TIME):
input_stimuli.append(MIN_FREQUENCY if (s % num_inputs) == i else MAX_FREQUENCY)
orthogonal_stimuli_rates.append(input_stimuli)
# Build basic network with orthogonal stimulation of both populations
input_populations, class_populations = build_basic_network(orthogonal_stimuli_rates, TRAINING_STIMULUS_TIME,
orthogonal_stimuli_rates, TRAINING_STIMULUS_TIME,
False, 0.0, True, sim)
# Create BCPNN model with weights disabled
bcpnn_synapse = bcpnn.BCPNNSynapse(
tau_zi=BCPNN_TAU_PRIMARY,
tau_zj=BCPNN_TAU_PRIMARY,
tau_p=BCPNN_TAU_ELIGIBILITY,
f_max=MAX_FREQUENCY,
w_max=BCPNN_MAX_WEIGHT,
weights_enabled=False,
plasticity_enabled=True,
weight=0.0)
# Create all-to-all conector to connect inputs to classes
input_class_connector = sim.AllToAllConnector()
# Loop through all pairs of input populations and classes
plastic_connections = []
for (i, c) in itertools.product(input_populations, class_populations):
# Connect input to class with all-to-all plastic synapse
connection = sim.Projection(i, c, input_class_connector, bcpnn_synapse,
receptor_type="excitatory", label="%s-%s" % (i.label, c.label))
plastic_connections.append(connection)
# Run simulation
sim.run(TRAINING_TIME)
# Plot bias evolution
num_classes = len(CLASS_NAMES)
#bias_figure, bias_axes = pylab.subplots()
# **HACK** Extract learnt biases from gsyn channel
learnt_biases = []
plotting_times = range(TRAINING_TIME)
for i, c in enumerate(class_populations):
# Read bias from class
bias = c.get_data().segments[0].filter(name="bias")[0]
'''
# Loop through plotting times to get mean biases
mean_pj = []
for t in plotting_times:
# Slice out the rows for all neurons at this time
time_rows = gsyn[t::TRAINING_TIME]
time_bias = zip(*time_rows)[2]
mean_pj.append(numpy.average(numpy.exp(numpy.divide(time_bias,BCPNN_PHI))))
bias_axes.plot(plotting_times, mean_pj, label=c.label)
'''
# Add final bias column to list
# **HACK** investigate where out by 1000 comes from!
learnt_biases.append(bias[-1,:] * 0.001)
'''
bias_axes.set_title("Mean final bias")
bias_axes.set_ylim((0.0, 1.0))
bias_axes.set_ylabel("Pj")
bias_axes.set_xlabel("Time/ms")
bias_axes.legend()
'''
# Plot weights
weight_figure, weight_axes = pylab.subplots(num_inputs, num_classes)
# Loop through plastic connections
learnt_weights = []
for i, c in enumerate(plastic_connections):
# Extract weights and calculate mean
weights = c.get("weight", format="array")
mean_weight = numpy.average(weights)
# Add weights to list
learnt_weights.append(weights)
# Plot mean weight in each panel
axis = weight_axes[i % num_inputs][i / num_classes]
axis.matshow([[mean_weight]], cmap=pylab.cm.gray)
#axis.set_title("%s: %fuS" % (c.label, mean_weight))
axis.set_title("%u->%u: %f" % (i % num_inputs, i / num_classes, mean_weight))
axis.get_xaxis().set_visible(False)
axis.get_yaxis().set_visible(False)
# Show figures
pylab.show()
# End simulation on SpiNNaker
sim.end()
# Return learnt weights
return learnt_weights, learnt_biases
def train():
# SpiNNaker setup
sim.setup(timestep=1.0,
min_delay=1.0,
max_delay=10.0,
spinnaker_hostname="192.168.1.1")
# Generate orthogonal input stimuli
orthogonal_stimuli_rates = []
num_inputs = len(INPUT_NAMES)
for i in range(num_inputs):
input_stimuli = []
for s in range(TRAINING_TIME / TRAINING_STIMULUS_TIME):
input_stimuli.append(MIN_FREQUENCY if (
s % num_inputs) == i else MAX_FREQUENCY)
orthogonal_stimuli_rates.append(input_stimuli)
# Build basic network with orthogonal stimulation of both populations
input_populations, class_populations = build_basic_network(
orthogonal_stimuli_rates, TRAINING_STIMULUS_TIME,
orthogonal_stimuli_rates, TRAINING_STIMULUS_TIME, False, 0.0, True,
sim)
# Create BCPNN model with weights disabled
bcpnn_synapse = bcpnn.BCPNNSynapse(tau_zi=BCPNN_TAU_PRIMARY,
tau_zj=BCPNN_TAU_PRIMARY,
tau_p=BCPNN_TAU_ELIGIBILITY,
f_max=MAX_FREQUENCY,
w_max=BCPNN_MAX_WEIGHT,
weights_enabled=False,
plasticity_enabled=True,
weight=0.0)
# Create all-to-all conector to connect inputs to classes
input_class_connector = sim.AllToAllConnector()
# Loop through all pairs of input populations and classes
plastic_connections = []
for (i, c) in itertools.product(input_populations, class_populations):
# Connect input to class with all-to-all plastic synapse
connection = sim.Projection(i,
c,
input_class_connector,
bcpnn_synapse,
receptor_type="excitatory",
label="%s-%s" % (i.label, c.label))
plastic_connections.append(connection)
# Run simulation
sim.run(TRAINING_TIME)
# Plot bias evolution
num_classes = len(CLASS_NAMES)
#bias_figure, bias_axes = pylab.subplots()
# **HACK** Extract learnt biases from gsyn channel
learnt_biases = []
plotting_times = range(TRAINING_TIME)
for i, c in enumerate(class_populations):
# Read bias from class
bias = c.get_data().segments[0].filter(name="bias")[0]
'''
# Loop through plotting times to get mean biases
mean_pj = []
for t in plotting_times:
# Slice out the rows for all neurons at this time
time_rows = gsyn[t::TRAINING_TIME]
time_bias = zip(*time_rows)[2]
mean_pj.append(numpy.average(numpy.exp(numpy.divide(time_bias,BCPNN_PHI))))
bias_axes.plot(plotting_times, mean_pj, label=c.label)
'''
# Add final bias column to list
# **HACK** investigate where out by 1000 comes from!
learnt_biases.append(bias[-1, :] * 0.001)
'''
bias_axes.set_title("Mean final bias")
bias_axes.set_ylim((0.0, 1.0))
bias_axes.set_ylabel("Pj")
bias_axes.set_xlabel("Time/ms")
bias_axes.legend()
'''
# Plot weights
weight_figure, weight_axes = pylab.subplots(num_inputs, num_classes)
# Loop through plastic connections
learnt_weights = []
for i, c in enumerate(plastic_connections):
# Extract weights and calculate mean
weights = c.get("weight", format="array")
mean_weight = numpy.average(weights)
# Add weights to list
learnt_weights.append(weights)
# Plot mean weight in each panel
axis = weight_axes[i % num_inputs][i / num_classes]
axis.matshow([[mean_weight]], cmap=pylab.cm.gray)
#axis.set_title("%s: %fuS" % (c.label, mean_weight))
axis.set_title("%u->%u: %f" %
(i % num_inputs, i / num_classes, mean_weight))
axis.get_xaxis().set_visible(False)
axis.get_yaxis().set_visible(False)
# Show figures
pylab.show()
# End simulation on SpiNNaker
sim.end()
# Return learnt weights
return learnt_weights, learnt_biases
neurons,
sim.FromListConnector(conn_list),
stdp_model,
receptor_type="excitatory")
# Stimulate stim neuron
stim = sim.Population(1, sim.SpikeSourceArray(spike_times=[2.0]), label="stim")
sim.Projection(
stim, neurons,
sim.FromListConnector([
(0, get_neuron_index(stim_x, stim_y,
cost_image.shape[1]), instant_spike_weight, 1.0)
]), sim.StaticSynapse())
# Run network
sim.run(duration)
# Read data
data = neurons.get_data()
weights = proj.get("weight", format="list", with_address=True)
sim.end()
# Create weight graph with each neuron marked
weight_graph = graphviz.Digraph(engine="neato", format="svg")
spacing = 2.0
for n in range(num_neurons):
neuron_x, neuron_y = get_neuron_x_y(n, cost_image.shape[1])
weight_graph.node(str(n),
label="%u, %u" % (neuron_x, neuron_y),
pos="%f,-%f!" % (neuron_x * spacing, neuron_y * spacing))
