mbon_spikes = None NUM_STIM = 100 while model.timestep < (single_example_timesteps * NUM_STIM): # Calculate the timestep within the presentation timestep_in_example = model.timestep % single_example_timesteps example = int(model.timestep // single_example_timesteps) # If this is the first timestep of the presentation if timestep_in_example == 0: # Get image input_vector = training_images[example] # Normalize pn_input_current_view[:] = input_vector * INPUT_SCALE model.push_var_to_device("pn_input", "magnitude") pn_refrac_time_view[:] = 0.0 model.push_var_to_device("pn", "RefracTime") # Otherwise, if this timestep is the start of the resting period elif timestep_in_example == NUM_PRESENT_TIMESTEPS: pn_input_current_view[:] = 0.0 model.push_var_to_device("pn_input", "magnitude") model.step_time() if plot: model.pull_current_spikes_from_device("pn") pn_spikes = record_current_spikes(pn, pn_spikes, model.t)
# If this is the first timestep of presenting the example if timestep_in_example == 0: print("Example: " + str(example)) layer_spikes = [(np.empty(0), np.empty(0)) for _ in enumerate(neuron_layers)] # calculate the correct spiking rates for all populations digit = X[example, :].flatten() digit = np.divide(digit, np.amax(digit)) active_pixels = np.count_nonzero(digit) inh_rate[:] = INH_V * active_pixels / NUM_INPUT model.push_var_to_device("inh", "rate") input_rate[:] = (digit * (INPUT_STIM - INPUT_UNSTIM)) + INPUT_UNSTIM model.push_var_to_device("inp", "rate") out_voltage[:] = 0.0 model.push_var_to_device('out', "V") output_spike_count[:] = 0 model.push_var_to_device("out", "SpikeCount") # Advance simulation model.step_time() for idx, layer in enumerate(neuron_layers): # Download spikes
layer_spikes = [(np.empty(0), np.empty(0)) for _ in enumerate(neuron_layers)] # layer_spikes = np.empty(0) # if example % 10 == 0: # print("Example: " + str(example)) print("Example: " + str(example)) # calculate the correct spiking rates for all populations digit = X[example, :].flatten() digit = np.divide(digit, np.amax(digit)) active_pixels = np.count_nonzero(digit) inh_rate[:] = INH_V * active_pixels / NUM_INPUT model.push_var_to_device("inh", "rate") input_rate[:] = (digit * (INPUT_STIM - INPUT_UNSTIM)) + INPUT_UNSTIM model.push_var_to_device("inp", "rate") # one_hot = np.zeros(neurons_count["teacher"]) one_hot = np.full(neurons_count["teacher"], TEACHER_UNSTIM_V) chosen_class = y[example] one_hot[chosen_class * TEACHER_NUM:(chosen_class + 1) * TEACHER_NUM] = TEACHER_V teacher_rate[:] = one_hot model.push_var_to_device("teacher", "rate") out_voltage[:] = 0.0 model.push_var_to_device('out', "V")
# Simulate # ---------------------------------------------------------------------------- # Load testing data testing_images = np.load("testing_images.npy") testing_labels = np.load("testing_labels.npy") # Check dimensions match network assert testing_images.shape[1] == weights[0].shape[0] assert np.max(testing_labels) == (weights[1].shape[1] - 1) # Set current input by scaling first image current_input.vars[ "magnitude"].view[:] = testing_images[0] * INPUT_CURRENT_SCALE # Upload model.push_var_to_device("current_input", "magnitude") # Simulate layer_spikes = [(np.empty(0), np.empty(0)) for _ in enumerate(neuron_layers)] while model.timestep < PRESENT_TIMESTEPS: # Advance simulation model.step_time() # Loop through neuron layers for i, l in enumerate(neuron_layers): # Download spikes model.pull_current_spikes_from_device(l.name) # Add to data structure spike_times = np.ones_like(l.current_spikes) * model.t layer_spikes[i] = (np.hstack((layer_spikes[i][0], l.current_spikes)),
current_input_magnitude = current_input.vars["magnitude"].view output_spike_count = neuron_layers[-1].vars["SpikeCount"].view layer_voltages = [l.vars["V"].view for l in neuron_layers] # Simulate num_correct = 0 while model.timestep < (PRESENT_TIMESTEPS * testing_images.shape[0]): # Calculate the timestep within the presentation timestep_in_example = model.timestep % PRESENT_TIMESTEPS example = int(model.timestep // PRESENT_TIMESTEPS) # If this is the first timestep of presenting the example if timestep_in_example == 0: current_input_magnitude[:] = testing_images[ example] * INPUT_CURRENT_SCALE model.push_var_to_device("current_input", "magnitude") # Loop through all layers and their corresponding voltage views for l, v in zip(neuron_layers, layer_voltages): # Manually 'reset' voltage v[:] = 0.0 # Upload model.push_var_to_device(l.name, "V") # Zero spike count output_spike_count[:] = 0 model.push_var_to_device(neuron_layers[-1].name, "SpikeCount") # Advance simulation model.step_time()
# init a data structure for plotting the raster plots for this example layer_spikes = [(np.empty(0), np.empty(0)) for _ in enumerate(neuron_layers)] # synapse_weights = [np.array([]) for _ in enumerate(synapses)] # layer_currents = [np.array([]) for _ in enumerate(neuron_layers)] if example % 1000 == 0: print("Example: " + str(example)) current_input_magnitude[:] = X[ example, :].flatten() * INPUT_CURRENT_SCALE one_hot = np.zeros((NUM_CLASSES)) one_hot[y[example]] = 1 current_output_magnitude[:] = one_hot.flatten() * OUTPUT_CURRENT_SCALE model.push_var_to_device("current_input", "magnitude") model.push_var_to_device("current_output", "magnitude") # Loop through all layers and their corresponding voltage views for l, v in zip(neuron_layers, layer_voltages): # Manually 'reset' voltage v[:] = 0.0 # Upload model.push_var_to_device(l.name, "V") # Zero spike count # output_spike_count[:] = 0 # model.push_var_to_device(neuron_layers[-1].name, "SpikeCount") # Advance simulation