def run_sim(self):
"""
Sets up and runs the simulation
"""
num_neurons = 1471 # total neurons in network
num_inputs = 14 # number of neurons considered inputs
num_runs = 1 # number of times to loop the learning
num_samples = 1 # number of samples to learn`
sim_time = 1000.0 # time to run sim for`
inhibitory_split = 0.2
connection_probability_factor = 0.02
plot_spikes = True
save_figures = True
show_figures = True
sim_start_time = strftime("%Y-%m-%d_%H:%M")
cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 10.0, 'tau_refrac': 2.0, 'tau_syn_E': 3.0,
'tau_syn_I': 3.0, 'v_reset': -65.0, 'v_rest': -65.0, 'v_thresh': -50.0}
# Create the 3d structure of the NeuCube based on the user's given structure file
network_structure = NetworkStructure()
network_structure.load_structure_file()
network_structure.load_input_location_file()
# Calculate the inter-neuron distance to be used in the small world connections
network_structure.calculate_distances()
# Generate two connection matrices for excitatory and inhibitory neurons based on your defined split
network_structure.calculate_connection_matrix(inhibitory_split, connection_probability_factor)
# Get these lists to be used when connecting the neurons later
excitatory_connection_list = network_structure.get_excitatory_connection_list()
inhibitory_connection_list = network_structure.get_inhibitory_connection_list()
# Choose the correct neurons to connect them to, based on your a-priori knowledge of the data source -- eg, EEG
# to 10-20 locations, fMRI to voxel locations, etc.
input_neuron_indexes = network_structure.find_input_neurons()
# Make the input connections based on this new list
input_weight = 4.0
input_connection_list = []
for index, input_neuron_index in enumerate(input_neuron_indexes):
input_connection_list.append((index, input_neuron_index, input_weight, 0))
for run_number in xrange(num_runs):
excitatory_weights = []
inhibitory_weights = []
for sample_number in xrange(num_samples):
# At the moment with the limitations of the SpiNNaker hardware we have to reinstantiate EVERYTHING
# each run. In future there will be some form of repetition added, where the structure stays in memory
# on the SpiNNaker and only the input spikes need to be updated.
data_prefix = sim_start_time + "_r" + str(run_number + 1) + "-s" + str(sample_number + 1)
# Set up the hardware - min_delay should never be less than the timestep.
# Timestep should = 1.0 (ms) for normal realtime applications
p.setup(timestep=1.0, min_delay=1.0)
p.set_number_of_neurons_per_core("IF_curr_exp", 100)
# Create a population of neurons for the reservoir
neurons = p.Population(num_neurons, p.IF_curr_exp, cell_params_lif, label="Reservoir")
# Setup excitatory STDP
timing_rule_ex = p.SpikePairRule(tau_plus=20.0, tau_minus=20.0)
weight_rule_ex = p.AdditiveWeightDependence(w_min=0.1, w_max=1.0, A_plus=0.02, A_minus=0.02)
stdp_model_ex = p.STDPMechanism(timing_dependence=timing_rule_ex, weight_dependence=weight_rule_ex)
# Setup inhibitory STDP
timing_rule_inh = p.SpikePairRule(tau_plus=20.0, tau_minus=20.0)
weight_rule_inh = p.AdditiveWeightDependence(w_min=0.0, w_max=0.6, A_plus=0.02, A_minus=0.02)
stdp_model_inh = p.STDPMechanism(timing_dependence=timing_rule_inh, weight_dependence=weight_rule_inh)
# record the spikes from that population
neurons.record('spikes')
# Generate a population of SpikeSourceArrays containing the encoded input spike data
# eg. spike_sources = p.Population(14, p.SpikeSourceArray, {'spike_times': [[]]})
# for the moment I'm going to cheat and just use poisson trains as I don't have data with me
spike_sources = p.Population(num_inputs, p.SpikeSourcePoisson, {'rate': rand.randint(20, 80)},
label="Poisson_pop_E")
# Connect the input spike sources with the "input" neurons
connected_inputs = p.Projection(spike_sources, neurons, p.FromListConnector(input_connection_list))
# If we have weights saved/recorded from a previous run of this network, load them into the structure
# population.set(weights=weights_list) and population.setWeights(weight_list) are not supported in
# SpiNNaker at the moment so we have to do this manually.
if excitatory_weights and inhibitory_weights:
for index, ex_connection in enumerate(excitatory_connection_list):
ex_connection[2] = excitatory_weights[index]
for index, in_connection in enumerate(inhibitory_connection_list):
in_connection[2] = inhibitory_weights[index]
# Setup the connectors
excitatory_connector = p.FromListConnector(excitatory_connection_list)
inhibitory_connector = p.FromListConnector(inhibitory_connection_list)
# Connect the excitatory and inhibitory neuron populations
connected_excitatory_neurons = p.Projection(neurons, neurons, excitatory_connector,
synapse_dynamics=p.SynapseDynamics(slow=stdp_model_ex),
target="excitatory")
connected_inhibitory_neurons = p.Projection(neurons, neurons, inhibitory_connector,
synapse_dynamics=p.SynapseDynamics(slow=stdp_model_inh),
target="inhibitory")
# Set up recording the spike trains of all the neurons
neurons.record()
spike_sources.record()
# Run the actual simulation
p.run(sim_time)
# Save the output spikes
spikes_out = neurons.getSpikes(compatible_output=True)
input_spikes_out = spike_sources.getSpikes(compatible_output=True)
# Get the synaptic weights of all the neurons
excitatory_weights = connected_excitatory_neurons.getWeights()
inhibitory_weights = connected_inhibitory_neurons.getWeights()
# when we're all done, clean up
p.end()
# Make some plots, save them if required. Check if you need to either save or show them, because if not,
# there's no point wasting time plotting things nobody will ever see.
if plot_spikes and (save_figures or show_figures):
plot = Plot(save_figures, data_prefix)
# Plot the 3D structure of the network
plot.plot_structure(network_structure.get_positions(), figure_number=0)
# Plot the spikes
plot.plot_spike_raster(spikes_out, sim_time, num_neurons, figure_number=1)
# Plot the weights
plot.plot_both_weights(excitatory_weights, inhibitory_weights, figure_number=2)
# If we want to show the figures, show them now, otherwise ignore and move on
if show_figures:
# Show them all at once
plot.show_plots()
plot.clear_figures()
plot = None
