Weight scale

neural_modelling/makefiles/neuron/IF_cond_exp_stdp_mad_nearest_pair_additive_structural_last_neuron_distance_weight/Makefile

@@ -17,7 +17,7 @@ APP = $(notdir $(CURDIR))
 NEURON_MODEL = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.c
 NEURON_MODEL_H = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.h
 INPUT_TYPE_H = $(NEURON_DIR)/neuron/input_types/input_type_conductance.h
-CURRENT_SOURCE_H = $(NEURON_DIR)/neuron/current_sources/current_source_stepnoisy_impl.h
+CURRENT_SOURCE_H = $(NEURON_DIR)/neuron/current_sources/current_source_step_only_impl.h
 NEURON_IMPL_H = $(NEURON_DIR)/neuron/implementations/neuron_impl_standard.h
 THRESHOLD_TYPE_H = $(NEURON_DIR)/neuron/threshold_types/threshold_type_static.h
 SYNAPSE_TYPE_H = $(NEURON_DIR)/neuron/synapse_types/synapse_types_exponential_impl.h

neural_modelling/makefiles/neuron/IF_cond_exp_stdp_mad_nearest_pair_additive_structural_random_distance_weight/Makefile

@@ -17,7 +17,7 @@ APP = $(notdir $(CURDIR))
 NEURON_MODEL = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.c
 NEURON_MODEL_H = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.h
 INPUT_TYPE_H = $(NEURON_DIR)/neuron/input_types/input_type_conductance.h
-CURRENT_SOURCE_H = $(NEURON_DIR)/neuron/current_sources/current_source_ac_only_impl.h
+CURRENT_SOURCE_H = $(NEURON_DIR)/neuron/current_sources/current_source_step_only_impl.h
 NEURON_IMPL_H = $(NEURON_DIR)/neuron/implementations/neuron_impl_standard.h
 THRESHOLD_TYPE_H = $(NEURON_DIR)/neuron/threshold_types/threshold_type_static.h
 SYNAPSE_TYPE_H = $(NEURON_DIR)/neuron/synapse_types/synapse_types_exponential_impl.h

neural_modelling/makefiles/neuron/IF_cond_exp_stdp_mad_pair_additive_structural_last_neuron_distance_weight/Makefile

@@ -17,7 +17,7 @@ APP = $(notdir $(CURDIR))
 NEURON_MODEL = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.c
 NEURON_MODEL_H = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.h
 INPUT_TYPE_H = $(NEURON_DIR)/neuron/input_types/input_type_conductance.h
-CURRENT_SOURCE_H = $(NEURON_DIR)/neuron/current_sources/current_source_dc_only_impl.h
+CURRENT_SOURCE_H = $(NEURON_DIR)/neuron/current_sources/current_source_step_only_impl.h
 NEURON_IMPL_H = $(NEURON_DIR)/neuron/implementations/neuron_impl_standard.h
 THRESHOLD_TYPE_H = $(NEURON_DIR)/neuron/threshold_types/threshold_type_static.h
 SYNAPSE_TYPE_H = $(NEURON_DIR)/neuron/synapse_types/synapse_types_exponential_impl.h

neural_modelling/makefiles/neuron/IF_curr_exp_stdp_mad_pair_additive_structural_random_distance_weight/Makefile

@@ -17,7 +17,7 @@ APP = $(notdir $(CURDIR))
 NEURON_MODEL = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.c
 NEURON_MODEL_H = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.h
 INPUT_TYPE_H = $(NEURON_DIR)/neuron/input_types/input_type_current.h
-CURRENT_SOURCE_H = $(NEURON_DIR)/neuron/current_sources/current_source_noisy_only_impl.h
+CURRENT_SOURCE_H = $(NEURON_DIR)/neuron/current_sources/current_source_dc_only_impl.h
 NEURON_IMPL_H = $(NEURON_DIR)/neuron/implementations/neuron_impl_standard.h
 THRESHOLD_TYPE_H = $(NEURON_DIR)/neuron/threshold_types/threshold_type_static.h
 SYNAPSE_TYPE_H = $(NEURON_DIR)/neuron/synapse_types/synapse_types_exponential_impl.h

neural_modelling/src/neuron/c_main_synapse_common.h

@@ -100,13 +100,12 @@ static inline bool initialise_synapse_regions(
         bool *clear_input_buffer_of_late_packets,
         uint32_t *n_recording_regions_used) {
     // Set up the synapses
-    uint32_t *ring_buffer_to_input_buffer_left_shifts;
+    REAL *min_weights;
     uint32_t n_neurons;
     uint32_t n_synapse_types;
     if (!synapses_initialise(
             data_specification_get_region(regions.synapse_params, ds_regions),
-            &n_neurons, &n_synapse_types, ring_buffers,
-            &ring_buffer_to_input_buffer_left_shifts,
+            &n_neurons, &n_synapse_types, ring_buffers, &min_weights,
             clear_input_buffer_of_late_packets,
             incoming_spike_buffer_size)) {
         return false;
@@ -130,7 +129,7 @@ static inline bool initialise_synapse_regions(
     // Set up the synapse dynamics
     if (!synapse_dynamics_initialise(
             data_specification_get_region(regions.synapse_dynamics, ds_regions),
-            n_neurons, n_synapse_types, ring_buffer_to_input_buffer_left_shifts)) {
+            n_neurons, n_synapse_types, min_weights)) {
         return false;
     }
 

neural_modelling/src/neuron/neuron.c

@@ -49,8 +49,11 @@ static uint32_t n_neurons_peak;
 //! The number of synapse types
 static uint32_t n_synapse_types;
 
-//! Amount to left shift the ring buffer by to make it an input
-static uint32_t *ring_buffer_to_input_left_shifts;
+////! Amount to left shift the ring buffer by to make it an input
+//static uint32_t *ring_buffer_to_input_left_shifts;
+
+//! Minimum weight value
+static REAL *min_weights;
 
 //! The address where the actual neuron parameters start
 static address_t saved_params_address;
@@ -65,7 +68,7 @@ struct neuron_parameters {
     uint32_t n_neurons_to_simulate;
     uint32_t n_neurons_peak;
     uint32_t n_synapse_types;
-    uint32_t ring_buffer_shifts[];
+    REAL min_weights[];
 };
 
 //! \brief does the memory copy for the neuron parameters
@@ -124,20 +127,18 @@ bool neuron_initialise(
     n_synapse_types = params->n_synapse_types;
 
     // Set up ring buffer left shifts
-    uint32_t ring_buffer_bytes = n_synapse_types * sizeof(uint32_t);
-    ring_buffer_to_input_left_shifts = spin1_malloc(ring_buffer_bytes);
-    if (ring_buffer_to_input_left_shifts == NULL) {
-        log_error("Not enough memory to allocate ring buffer");
+    uint32_t min_weights_bytes = n_synapse_types * sizeof(REAL);
+    min_weights = spin1_malloc(min_weights_bytes);
+    if (min_weights == NULL) {
+        log_error("Not enough memory to allocate min_weights");
         return false;
     }
 
-    // read in ring buffer to input left shifts
-    spin1_memcpy(
-            ring_buffer_to_input_left_shifts, params->ring_buffer_shifts,
-            ring_buffer_bytes);
+    // read in min_weights
+    spin1_memcpy(min_weights, params->min_weights, min_weights_bytes);
 
     // Store where the actual neuron parameters start
-    saved_params_address = &params->ring_buffer_shifts[n_synapse_types];
+    saved_params_address = (address_t) &(params->min_weights[n_synapse_types]);
     current_source_address = cs_address;
 
     log_info("\t n_neurons = %u, peak %u, n_synapse_types %u",
@@ -198,7 +199,7 @@ void neuron_transfer(weight_t *syns) { // EXPORTED
     uint32_t synapse_index = 0;
     uint32_t ring_buffer_index = 0;
     for (uint32_t s_i = n_synapse_types; s_i > 0; s_i--) {
-        uint32_t rb_shift = ring_buffer_to_input_left_shifts[synapse_index];
+        REAL min_weight = min_weights[synapse_index];
         uint32_t neuron_index = 0;
         for (uint32_t n_i = n_neurons_peak; n_i > 0; n_i--) {
             weight_t value = syns[ring_buffer_index];
@@ -208,7 +209,7 @@ void neuron_transfer(weight_t *syns) { // EXPORTED
                     rt_error(RTE_SWERR);
                 }
                 input_t val_to_add = synapse_row_convert_weight_to_input(
-                        value, rb_shift);
+                        value, min_weight);
                 neuron_impl_add_inputs(synapse_index, neuron_index, val_to_add);
             }
             syns[ring_buffer_index] = 0;

neural_modelling/src/neuron/plasticity/stdp/synapse_dynamics_stdp_common.h

@@ -113,7 +113,7 @@ static uint32_t plastic_saturation_count = 0;
 
 static inline bool synapse_dynamics_stdp_init(
         address_t *address, stdp_params *params, uint32_t n_synapse_types,
-        uint32_t *ring_buffer_to_input_buffer_left_shifts) {
+        REAL *min_weights) {
 
     // Load parameters
     stdp_params *sdram_params = (stdp_params *) *address;
@@ -128,8 +128,7 @@ static inline bool synapse_dynamics_stdp_init(
 
     // Load weight dependence data
     address_t weight_result = weight_initialise(
-            weight_region_address, n_synapse_types,
-            ring_buffer_to_input_buffer_left_shifts);
+            weight_region_address, n_synapse_types, min_weights);
     if (weight_result == NULL) {
         return false;
     }
@@ -145,10 +144,10 @@ static inline bool synapse_dynamics_stdp_init(
 void synapse_dynamics_print_plastic_synapses(
         synapse_row_plastic_data_t *plastic_region_data,
         synapse_row_fixed_part_t *fixed_region,
-        uint32_t *ring_buffer_to_input_buffer_left_shifts) {
+        accum *min_weights) {
     __use(plastic_region_data);
     __use(fixed_region);
-    __use(ring_buffer_to_input_buffer_left_shifts);
+    __use(min_weights);
 
 #if LOG_LEVEL >= LOG_DEBUG
     // Extract separate arrays of weights (from plastic region),
@@ -175,7 +174,7 @@ void synapse_dynamics_print_plastic_synapses(
 
         log_debug("%08x [%3d: (w: %5u (=", control_word, i, weight);
         synapses_print_weight(
-                weight, ring_buffer_to_input_buffer_left_shifts[synapse_type]);
+                weight, min_weights[synapse_type]);
         log_debug("nA) d: %2u, %s, n = %3u)] - {%08x %08x}\n",
                 synapse_row_sparse_delay(control_word, synapse_type_index_bits, synapse_delay_mask),
                 synapse_types_get_type_char(synapse_type),

neural_modelling/src/neuron/plasticity/stdp/synapse_dynamics_stdp_izhikevich_neuromodulation.c

@@ -34,7 +34,7 @@ typedef struct neuromodulated_synapse_t {
 
 typedef struct nm_update_state_t {
     accum weight;
-    uint32_t weight_shift;
+    REAL min_weight;
     update_state_t eligibility_state;
 } nm_update_state_t;
 
@@ -75,7 +75,7 @@ static int16_lut *tau_c_lookup;
 
 static int16_lut *tau_d_lookup;
 
-static uint32_t *nm_weight_shift;
+static REAL *nm_min_weight;
 
 #define DECAY_LOOKUP_TAU_C(time) \
     maths_lut_exponential_decay(time, tau_c_lookup)
@@ -84,10 +84,13 @@ static uint32_t *nm_weight_shift;
 
 static inline nm_update_state_t get_nm_update_state(
         neuromodulated_synapse_t synapse, index_t synapse_type) {
-    accum s1615_weight = kbits(synapse.weight << nm_weight_shift[synapse_type]);
+    uint64_t mw = (uint64_t) bitsk(nm_min_weight[synapse_type]);
+    uint64_t w = (uint64_t) (synapse.weight);
+
+    accum s1615_weight = kbits((int_k_t) mw * w);
     nm_update_state_t update_state = {
         .weight=s1615_weight,
-        .weight_shift=nm_weight_shift[synapse_type],
+        .min_weight=nm_min_weight[synapse_type],
         .eligibility_state=synapse_structure_get_update_state(
                 synapse.eligibility_synapse, synapse_type)
     };
@@ -101,7 +104,7 @@ static inline nm_final_state_t get_nm_final_state(
     update_state.weight = kbits(MIN(bitsk(update_state.weight),
             bitsk(nm_params.max_weight)));
     nm_final_state_t final_state = {
-        .weight=(weight_t) (bitsk(update_state.weight) >> update_state.weight_shift),
+        .weight=(weight_t) (bitsk(update_state.weight) / bitsk(update_state.min_weight)),
         .final_state=synapse_structure_get_final_state(
                 update_state.eligibility_state)
     };
@@ -274,10 +277,10 @@ static inline nm_final_state_t izhikevich_neuromodulation_plasticity_update_syna
 
 bool synapse_dynamics_initialise(
         address_t address, uint32_t n_neurons, uint32_t n_synapse_types,
-        uint32_t *ring_buffer_to_input_buffer_left_shifts) {
+        REAL *min_weights) {
 
-    if (!synapse_dynamics_stdp_init(&address, &params, n_synapse_types,
-                ring_buffer_to_input_buffer_left_shifts)) {
+    if (!synapse_dynamics_stdp_init(
+            &address, &params, n_synapse_types, min_weights)) {
         return false;
     }
 
@@ -299,15 +302,15 @@ bool synapse_dynamics_initialise(
     tau_c_lookup = maths_copy_int16_lut(&lut_address);
     tau_d_lookup = maths_copy_int16_lut(&lut_address);
 
-    // Store weight shifts
-    nm_weight_shift = spin1_malloc(sizeof(uint32_t) * n_synapse_types);
-    if (nm_weight_shift == NULL) {
-        log_error("Could not initialise weight region data");
+    // Store min weights
+    nm_min_weight = spin1_malloc(sizeof(REAL) * n_synapse_types);
+    if (nm_min_weight == NULL) {
+        log_error("Could not initialise min weight region data");
         return NULL;
     }
     for (uint32_t s = 0; s < n_synapse_types; s++) {
-        nm_weight_shift[s] = ring_buffer_to_input_buffer_left_shifts[s];
-        log_info("Weight shift %u = %u", s, nm_weight_shift[s]);
+        nm_min_weight[s] = min_weights[s];
+        log_info("Min weight %u = %k", s, nm_min_weight[s]);
     }
 
     return true;

neural_modelling/src/neuron/plasticity/stdp/synapse_dynamics_stdp_mad_impl.c

@@ -103,10 +103,10 @@ static inline final_state_t plasticity_update_synapse(
 
 bool synapse_dynamics_initialise(
         address_t address, uint32_t n_neurons, uint32_t n_synapse_types,
-        uint32_t *ring_buffer_to_input_buffer_left_shifts) {
+        REAL *min_weights) {
 
-    if (!synapse_dynamics_stdp_init(&address, &params, n_synapse_types,
-                ring_buffer_to_input_buffer_left_shifts)) {
+    if (!synapse_dynamics_stdp_init(
+            &address, &params, n_synapse_types, min_weights)) {
         return false;
     }
 
@@ -132,7 +132,6 @@ static inline index_t sparse_axonal_delay(uint32_t x) {
 #endif
 }
 
-//---------------------------------------
 void synapse_dynamics_process_post_synaptic_event(
         uint32_t time, index_t neuron_index) {
     log_debug("Adding post-synaptic event to trace at time:%u", time);

neural_modelling/src/neuron/plasticity/stdp/weight_dependence/weight.h

@@ -42,14 +42,11 @@
  * \param[in] address: the absolute address in SRAM where the weight parameters
  *      are stored.
  * \param[in] n_synapse_types: The number of synapse types
- * \param[in] ring_buffer_to_input_buffer_left_shifts: how much a value needs
- *      to be shifted in the left direction to support comprises with fixed
- *      point arithmetic
+ * \param[in] min_weights: The value of the weight of the LSB of the weight
  * \return the end of the weight region as an absolute SDRAM memory address.
  */
 address_t weight_initialise(
-        address_t address, uint32_t n_synapse_types,
-        uint32_t *ring_buffer_to_input_buffer_left_shifts);
+        address_t address, uint32_t n_synapse_types, REAL *min_weights);
 
 /*!
  * \brief Gets the initial weight state.

neural_modelling/src/neuron/plasticity/stdp/weight_dependence/weight_additive_one_term_impl.c

@@ -25,8 +25,8 @@
 //! Global plasticity parameter data
 plasticity_weight_region_data_t *plasticity_weight_region_data;
 
-//! Plasticity multiply shift array, in DTCM
-uint32_t *weight_shift;
+//! Plasticity min_weight array, in DTCM
+REAL *min_weight;
 
 //! \brief How the configuration data for additive_one_term is laid out in
 //!     SDRAM. The layout is an array of these.
@@ -41,8 +41,7 @@ typedef struct {
 // Functions
 //---------------------------------------
 address_t weight_initialise(
-        address_t address, uint32_t n_synapse_types,
-        UNUSED uint32_t *ring_buffer_to_input_buffer_left_shifts) {
+        address_t address, uint32_t n_synapse_types, REAL *min_weights) {
     log_debug("weight_initialise: starting");
     log_debug("\tSTDP additive one-term weight dependence");
 
@@ -57,8 +56,8 @@ address_t weight_initialise(
         return NULL;
     }
 
-    weight_shift = spin1_malloc(sizeof(uint32_t) * n_synapse_types);
-    if (weight_shift == NULL) {
+    min_weight = spin1_malloc(sizeof(REAL) * n_synapse_types);
+    if (min_weight == NULL) {
         log_error("Could not initialise weight region data");
         return NULL;
     }
@@ -69,12 +68,11 @@ address_t weight_initialise(
         dtcm_copy[s].a2_plus = config->a2_plus;
         dtcm_copy[s].a2_minus = config->a2_minus;
 
-        // Copy weight shift
-        weight_shift[s] = ring_buffer_to_input_buffer_left_shifts[s];
+        min_weight[s] = min_weights[s];
 
-        log_debug("\tSynapse type %u: Min weight:%k, Max weight:%k, A2+:%k, A2-:%k",
+        log_info("\tSynapse type %u: Min weight:%k, Max weight:%k, A2+:%k, A2-:%k min_weight %k",
                 s, dtcm_copy[s].min_weight, dtcm_copy[s].max_weight,
-                dtcm_copy[s].a2_plus, dtcm_copy[s].a2_minus);
+                dtcm_copy[s].a2_plus, dtcm_copy[s].a2_minus, min_weight[s]);
     }
     log_debug("weight_initialise: completed successfully");
 

neural_modelling/src/neuron/plasticity/stdp/weight_dependence/weight_additive_one_term_impl.h

@@ -43,7 +43,7 @@ typedef struct {
 typedef struct {
     accum weight; //!< The starting weight
 
-    uint32_t weight_shift; //!< Weight shift to S1615 version
+    REAL min_weight; //!< Min weight
 
     //! Reference to the configuration data
     const plasticity_weight_region_data_t *weight_region;
@@ -60,15 +60,18 @@ typedef struct {
  * \param[in] synapse_type: The type of synapse involved
  * \return The initial weight state.
  */
-static inline weight_state_t weight_get_initial(
-        weight_t weight, index_t synapse_type) {
+static inline weight_state_t weight_get_initial(weight_t weight, index_t synapse_type) {
     extern plasticity_weight_region_data_t *plasticity_weight_region_data;
-    extern uint32_t *weight_shift;
+    extern REAL *min_weight;
+
+    uint64_t mw = (uint64_t) bitsk(min_weight[synapse_type]);
+    uint64_t w = (uint64_t) (weight);
+
+    accum s1615_weight = kbits((int_k_t) mw * w);
 
-    accum s1615_weight = kbits(weight << weight_shift[synapse_type]);
     return (weight_state_t) {
         .weight = s1615_weight,
-        .weight_shift = weight_shift[synapse_type],
+        .min_weight = min_weight[synapse_type],
         .weight_region = &plasticity_weight_region_data[synapse_type]
     };
 }
@@ -104,7 +107,7 @@ static inline weight_state_t weight_one_term_apply_potentiation(
  * \return The new weight.
  */
 static inline weight_t weight_get_final(weight_state_t state) {
-    return (weight_t) (bitsk(state.weight) >> state.weight_shift);
+    return (weight_t) (bitsk(state.weight) / bitsk(state.min_weight));
 }
 
 static inline void weight_decay(weight_state_t *state, int32_t decay) {