def _get_weight_maximum(self, weights, n_connections, synapse_info): """ Get the maximum of the weights. :param weights: :type weights: ~numpy.ndarray or ~pyNN.random.NumpyRNG or int or float or list(int) or list(float) :param int n_connections: :rtype: float """ if isinstance(weights, RandomDistribution): mean_weight = utility_calls.get_mean(weights) if mean_weight < 0: min_weight = utility_calls.get_minimum_probable_value( weights, n_connections) low = utility_calls.low(weights) if low is None: return abs(min_weight) return abs(max(min_weight, low)) else: max_weight = utility_calls.get_maximum_probable_value( weights, n_connections) high = utility_calls.high(weights) if high is None: return abs(max_weight) return abs(min(max_weight, high)) elif isinstance(weights, str): d = self._get_distances(weights, synapse_info) return numpy.max(_expr_context.eval(weights, d=d)) elif numpy.isscalar(weights): return abs(weights) elif hasattr(weights, "__getitem__"): return numpy.amax(numpy.abs(weights)) raise SpynnakerException("Unrecognised weight format")
def update_weight(self, graph_mapper): pre_vertex = graph_mapper.get_application_vertex(self.pre_vertex) pre_slice_index = graph_mapper.get_machine_vertex_index( self.pre_vertex) pre_vertex_slice = graph_mapper.get_slice(self.pre_vertex) pre_slices = graph_mapper.get_slices(pre_vertex) post_vertex = graph_mapper.get_application_vertex(self.post_vertex) post_slice_index = graph_mapper.get_machine_vertex_index( self.post_vertex) post_vertex_slice = graph_mapper.get_slice(self.post_vertex) post_slices = graph_mapper.get_slices(post_vertex) weight = 0 for synapse_info in self._synapse_information: new_weight = synapse_info.connector.\ get_n_connections_to_post_vertex_maximum( pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) new_weight *= pre_vertex_slice.n_atoms if hasattr(pre_vertex, "rate"): rate = pre_vertex.rate if hasattr(rate, "__getitem__"): rate = max(rate) elif globals_variables.get_simulator().is_a_pynn_random(rate): rate = utility_calls.get_maximum_probable_value( rate, pre_vertex_slice.n_atoms) new_weight *= rate elif hasattr(pre_vertex, "spikes_per_second"): new_weight *= pre_vertex.spikes_per_second weight += new_weight self._traffic_weight = weight
def _get_weight_maximum(weights, n_connections, connection_slices): """ Get the maximum of the weights """ if isinstance(weights, RandomDistribution): mean_weight = utility_calls.get_mean(weights) if mean_weight < 0: min_weight = utility_calls.get_minimum_probable_value( weights, n_connections) if weights.boundaries is not None: return abs(max(min_weight, min(weights.boundaries))) return abs(min_weight) else: max_weight = utility_calls.get_maximum_probable_value( weights, n_connections) if weights.boundaries is not None: return abs(min(max_weight, max(weights.boundaries))) return abs(max_weight) elif numpy.isscalar(weights): return weights elif hasattr(weights, "__getitem__"): return numpy.amax([ weights[connection_slice] for connection_slice in connection_slices ]) raise Exception("Unrecognised weight format")
def _get_weight_maximum(self, weights, n_connections): """ Get the maximum of the weights. """ if get_simulator().is_a_pynn_random(weights): mean_weight = utility_calls.get_mean(weights) if mean_weight < 0: min_weight = utility_calls.get_minimum_probable_value( weights, n_connections) low = utility_calls.low(weights) if low is None: return abs(min_weight) return abs(max(min_weight, low)) else: max_weight = utility_calls.get_maximum_probable_value( weights, n_connections) high = utility_calls.high(weights) if high is None: return abs(max_weight) return abs(min(max_weight, high)) elif numpy.isscalar(weights): return abs(weights) elif hasattr(weights, "__getitem__"): return numpy.amax(numpy.abs(weights)) raise Exception("Unrecognised weight format")
def update_weight(self, graph_mapper): pre_vertex = graph_mapper.get_vertex_from_subvertex( self._pre_subvertex) pre_slice_index = graph_mapper.get_subvertex_index(self._pre_subvertex) pre_vertex_slice = graph_mapper.get_subvertex_slice( self._pre_subvertex) pre_slices = graph_mapper.get_subvertex_slices(pre_vertex) post_vertex = graph_mapper.get_vertex_from_subvertex( self._post_subvertex) post_slice_index = graph_mapper.get_subvertex_index( self._post_subvertex) post_vertex_slice = graph_mapper.get_subvertex_slice( self._post_subvertex) post_slices = graph_mapper.get_subvertex_slices(post_vertex) weight = 0 for synapse_info in self._synapse_information: new_weight = synapse_info.connector.\ get_n_connections_to_post_vertex_maximum( pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) new_weight *= pre_vertex_slice.n_atoms if hasattr(pre_vertex, "rate"): rate = pre_vertex.rate if hasattr(rate, "__getitem__"): rate = max(rate) elif isinstance(rate, RandomDistribution): rate = utility_calls.get_maximum_probable_value( rate, pre_vertex_slice.n_atoms) new_weight *= rate elif hasattr(pre_vertex, "spikes_per_second"): new_weight *= pre_vertex.spikes_per_second weight += new_weight self._weight = weight
def _get_weight_maximum(weights, n_connections, connection_slices): """ Get the maximum of the weights """ if globals_variables.get_simulator().is_a_pynn_random(weights): mean_weight = utility_calls.get_mean(weights) if mean_weight < 0: min_weight = utility_calls.get_minimum_probable_value( weights, n_connections) if weights.boundaries is not None: return abs(max(min_weight, min(weights.boundaries))) return abs(min_weight) else: max_weight = utility_calls.get_maximum_probable_value( weights, n_connections) if weights.boundaries is not None: return abs(min(max_weight, max(weights.boundaries))) return abs(max_weight) elif numpy.isscalar(weights): return abs(weights) elif hasattr(weights, "__getitem__"): return numpy.amax([ numpy.abs(weights[connection_slice]) for connection_slice in connection_slices ]) raise Exception("Unrecognised weight format")
def update_weight(self, graph_mapper): pre_vertex = graph_mapper.get_vertex_from_subvertex( self._pre_subvertex) pre_slice_index = graph_mapper.get_subvertex_index(self._pre_subvertex) pre_vertex_slice = graph_mapper.get_subvertex_slice( self._pre_subvertex) pre_slices = graph_mapper.get_subvertex_slices(pre_vertex) post_vertex = graph_mapper.get_vertex_from_subvertex( self._post_subvertex) post_slice_index = graph_mapper.get_subvertex_index( self._post_subvertex) post_vertex_slice = graph_mapper.get_subvertex_slice( self._post_subvertex) post_slices = graph_mapper.get_subvertex_slices(post_vertex) weight = 0 for synapse_info in self._synapse_information: new_weight = synapse_info.connector.\ get_n_connections_to_post_vertex_maximum( pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) new_weight *= pre_vertex_slice.n_atoms if hasattr(pre_vertex, "rate"): rate = pre_vertex.rate if hasattr(rate, "__getitem__"): rate = max(rate) elif isinstance(rate, RandomDistribution): rate = utility_calls.get_maximum_probable_value( rate, pre_vertex_slice.n_atoms) new_weight *= rate elif hasattr(pre_vertex, "spikes_per_second"): new_weight *= pre_vertex.spikes_per_second weight += new_weight self._weight = weight
def _get_delay_maximum(self, delays, n_connections, synapse_info): """ Get the maximum delay given a float, RandomDistribution or list of\ delays. :param delays: :type delays: ~numpy.ndarray or ~pyNN.random.NumpyRNG or int or float or list(int) or list(float) :param int n_connections: """ if isinstance(delays, RandomDistribution): max_estimated_delay = utility_calls.get_maximum_probable_value( delays, n_connections) high = utility_calls.high(delays) if high is None: return max_estimated_delay # The maximum is the minimum of the possible maximums return min(max_estimated_delay, high) elif isinstance(delays, str): d = self._get_distances(delays, synapse_info) return numpy.max(_expr_context.eval(delays, d=d)) elif numpy.isscalar(delays): return delays elif hasattr(delays, "__getitem__"): return numpy.max(delays) raise SpynnakerException("Unrecognised delay format: {:s}".format( type(delays)))
def _get_weight_maximum(weights, n_connections, connection_slices): """ Get the maximum of the weights """ if isinstance(weights, RandomDistribution): mean_weight = utility_calls.get_mean(weights) if mean_weight < 0: min_weight = utility_calls.get_minimum_probable_value( weights, n_connections) if weights.boundaries is not None: return abs(max(min_weight, min(weights.boundaries))) return abs(min_weight) else: max_weight = utility_calls.get_maximum_probable_value( weights, n_connections) if weights.boundaries is not None: return abs(min(max_weight, max(weights.boundaries))) return abs(max_weight) elif numpy.isscalar(weights): return abs(weights) elif hasattr(weights, "__getitem__"): return numpy.amax([ numpy.abs(weights[connection_slice]) for connection_slice in connection_slices]) raise Exception("Unrecognised weight format")
def _get_weight_maximum(self, weights, n_connections): """ Get the maximum of the weights. """ if get_simulator().is_a_pynn_random(weights): mean_weight = utility_calls.get_mean(weights) if mean_weight < 0: min_weight = utility_calls.get_minimum_probable_value( weights, n_connections) low = utility_calls.low(weights) if low is None: return abs(min_weight) return abs(max(min_weight, low)) else: max_weight = utility_calls.get_maximum_probable_value( weights, n_connections) high = utility_calls.high(weights) if high is None: return abs(max_weight) return abs(min(max_weight, high)) elif numpy.isscalar(weights): return abs(weights) elif hasattr(weights, "__getitem__"): return numpy.amax(numpy.abs(weights)) raise Exception("Unrecognised weight format")
def _get_delay_maximum(delays, n_connections): """ Get the maximum delay given a float, RandomDistribution or list of\ delays """ if isinstance(delays, RandomDistribution): max_estimated_delay = utility_calls.get_maximum_probable_value( delays, n_connections) if delays.boundaries is not None: return min(max(delays.boundaries), max_estimated_delay) return max_estimated_delay elif numpy.isscalar(delays): return delays elif hasattr(delays, "__getitem__"): return max(delays) raise Exception("Unrecognised delay format")
def _get_delay_maximum(delays, n_connections): """ Get the maximum delay given a float, RandomDistribution or list of\ delays """ if isinstance(delays, RandomDistribution): max_estimated_delay = utility_calls.get_maximum_probable_value( delays, n_connections) if delays.boundaries is not None: return min(max(delays.boundaries), max_estimated_delay) return max_estimated_delay elif numpy.isscalar(delays): return delays elif hasattr(delays, "__getitem__"): return max(delays) raise Exception("Unrecognised delay format")
def _get_delay_maximum(self, delays, n_connections): """ Get the maximum delay given a float, RandomDistribution or list of\ delays. """ if get_simulator().is_a_pynn_random(delays): max_estimated_delay = utility_calls.get_maximum_probable_value( delays, n_connections) high = utility_calls.high(delays) if high is None: return max_estimated_delay # The maximum is the minimum of the possible maximums return min(max_estimated_delay, high) elif numpy.isscalar(delays): return delays elif hasattr(delays, "__getitem__"): return numpy.max(delays) raise Exception("Unrecognised delay format: {:s}".format(type(delays)))
def _get_delay_maximum(self, delays, n_connections): """ Get the maximum delay given a float, RandomDistribution or list of\ delays. """ if get_simulator().is_a_pynn_random(delays): max_estimated_delay = utility_calls.get_maximum_probable_value( delays, n_connections) high = utility_calls.high(delays) if high is None: return max_estimated_delay # The maximum is the minimum of the possible maximums return min(max_estimated_delay, high) elif numpy.isscalar(delays): return delays elif hasattr(delays, "__getitem__"): return numpy.max(delays) raise Exception("Unrecognised delay format: {:s}".format( type(delays)))
def _get_delay_maximum(delays, n_connections): """ Get the maximum delay given a float, RandomDistribution or list of\ delays """ if globals_variables.get_simulator().is_a_pynn_random(delays): max_estimated_delay = utility_calls.get_maximum_probable_value( delays, n_connections) if hasattr(delays, "boundaries"): if delays.boundaries is not None: return min(max(delays.boundaries), max_estimated_delay) elif isinstance(delays.parameters, dict): if "max" in delays.parameters: return delays.parameters['max'] return max_estimated_delay elif numpy.isscalar(delays): return delays elif hasattr(delays, "__getitem__"): return max(delays) raise Exception("Unrecognised delay format")
def update_weight(self): pre_vertex = self.pre_vertex.app_vertex pre_vertex_slice = self.pre_vertex.vertex_slice weight = 0 for synapse_info in self.__synapse_information: new_weight = synapse_info.connector.\ get_n_connections_to_post_vertex_maximum(synapse_info) new_weight *= pre_vertex_slice.n_atoms if hasattr(pre_vertex, "rate"): rate = pre_vertex.rate if hasattr(rate, "__getitem__"): rate = max(rate) elif isinstance(rate, RandomDistribution): rate = utility_calls.get_maximum_probable_value( rate, pre_vertex_slice.n_atoms) new_weight *= rate elif hasattr(pre_vertex, "spikes_per_second"): new_weight *= pre_vertex.spikes_per_second weight += new_weight self._traffic_weight = weight
def update_weight(self, graph_mapper): pre_vertex = graph_mapper.get_application_vertex( self.pre_vertex) pre_vertex_slice = graph_mapper.get_slice( self.pre_vertex) weight = 0 for synapse_info in self._synapse_information: new_weight = synapse_info.connector.\ get_n_connections_to_post_vertex_maximum() new_weight *= pre_vertex_slice.n_atoms if hasattr(pre_vertex, "rate"): rate = pre_vertex.rate if hasattr(rate, "__getitem__"): rate = max(rate) elif globals_variables.get_simulator().is_a_pynn_random(rate): rate = utility_calls.get_maximum_probable_value( rate, pre_vertex_slice.n_atoms) new_weight *= rate elif hasattr(pre_vertex, "spikes_per_second"): new_weight *= pre_vertex.spikes_per_second weight += new_weight self._traffic_weight = weight
def _get_ring_buffer_to_input_left_shifts(self, machine_vertex, machine_graph, graph_mapper, post_slices, post_slice_index, post_vertex_slice, machine_timestep, weight_scale): """ Get the scaling of the ring buffer to provide as much accuracy as\ possible without too much overflow """ weight_scale_squared = weight_scale * weight_scale n_synapse_types = self._synapse_type.get_n_synapse_types() running_totals = [RunningStats() for _ in range(n_synapse_types)] delay_running_totals = [RunningStats() for _ in range(n_synapse_types)] total_weights = numpy.zeros(n_synapse_types) biggest_weight = numpy.zeros(n_synapse_types) weights_signed = False rate_stats = [RunningStats() for _ in range(n_synapse_types)] steps_per_second = 1000000.0 / machine_timestep for m_edge in machine_graph.get_edges_ending_at_vertex(machine_vertex): pre_vertex_slice = graph_mapper.get_slice(m_edge.pre_vertex) app_edge = graph_mapper.get_application_edge(m_edge) pre_slices = [ graph_mapper.get_slice(internal_machine_vertex) for internal_machine_vertex in graph_mapper.get_machine_vertices(app_edge.pre_vertex) ] pre_slice_index = pre_slices.index(pre_vertex_slice) if isinstance(app_edge, ProjectionApplicationEdge): for synapse_info in app_edge.synapse_information: synapse_type = synapse_info.synapse_type synapse_dynamics = synapse_info.synapse_dynamics connector = synapse_info.connector weight_mean = abs( synapse_dynamics.get_weight_mean( connector, pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) * weight_scale) n_connections = \ connector.get_n_connections_to_post_vertex_maximum( pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) weight_variance = abs( synapse_dynamics.get_weight_variance( connector, pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) * weight_scale_squared) running_totals[synapse_type].add_items( weight_mean, weight_variance, n_connections) delay_variance = synapse_dynamics.get_delay_variance( connector, pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) delay_running_totals[synapse_type].add_items( 0.0, delay_variance, n_connections) weight_max = (synapse_dynamics.get_weight_maximum( connector, pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) * weight_scale) biggest_weight[synapse_type] = max( biggest_weight[synapse_type], weight_max) spikes_per_tick = max( 1.0, self._spikes_per_second / steps_per_second) spikes_per_second = self._spikes_per_second if isinstance(app_edge.pre_vertex, SpikeSourcePoisson): spikes_per_second = app_edge.pre_vertex.rate if hasattr(spikes_per_second, "__getitem__"): spikes_per_second = max(spikes_per_second) elif get_simulator().is_a_pynn_random( spikes_per_second): spikes_per_second = get_maximum_probable_value( spikes_per_second, pre_vertex_slice.n_atoms) prob = 1.0 - ((1.0 / 100.0) / pre_vertex_slice.n_atoms) spikes_per_tick = spikes_per_second / steps_per_second spikes_per_tick = scipy.stats.poisson.ppf( prob, spikes_per_tick) rate_stats[synapse_type].add_items(spikes_per_second, 0, n_connections) total_weights[synapse_type] += spikes_per_tick * ( weight_max * n_connections) if synapse_dynamics.are_weights_signed(): weights_signed = True max_weights = numpy.zeros(n_synapse_types) for synapse_type in range(n_synapse_types): stats = running_totals[synapse_type] rates = rate_stats[synapse_type] if delay_running_totals[synapse_type].variance == 0.0: max_weights[synapse_type] = max(total_weights[synapse_type], biggest_weight[synapse_type]) else: max_weights[synapse_type] = min( self._ring_buffer_expected_upper_bound( stats.mean, stats.standard_deviation, rates.mean, machine_timestep, stats.n_items, self._ring_buffer_sigma), total_weights[synapse_type]) max_weights[synapse_type] = max(max_weights[synapse_type], biggest_weight[synapse_type]) # Convert these to powers max_weight_powers = (0 if w <= 0 else int( math.ceil(max(0, math.log(w, 2)))) for w in max_weights) # If 2^max_weight_power equals the max weight, we have to add another # power, as range is 0 - (just under 2^max_weight_power)! max_weight_powers = (w + 1 if (2**w) <= a else w for w, a in zip(max_weight_powers, max_weights)) # If we have synapse dynamics that uses signed weights, # Add another bit of shift to prevent overflows if weights_signed: max_weight_powers = (m + 1 for m in max_weight_powers) return list(max_weight_powers)
def _get_ring_buffer_to_input_left_shifts( self, subvertex, sub_graph, graph_mapper, post_slices, post_slice_index, post_vertex_slice, machine_timestep, weight_scale): """ Get the scaling of the ring buffer to provide as much accuracy as\ possible without too much overflow """ weight_scale_squared = weight_scale * weight_scale n_synapse_types = self._synapse_type.get_n_synapse_types() running_totals = [RunningStats() for _ in range(n_synapse_types)] delay_running_totals = [RunningStats() for _ in range(n_synapse_types)] total_weights = numpy.zeros(n_synapse_types) biggest_weight = numpy.zeros(n_synapse_types) weights_signed = False rate_stats = [RunningStats() for _ in range(n_synapse_types)] for subedge in sub_graph.incoming_subedges_from_subvertex(subvertex): pre_vertex_slice = graph_mapper.get_subvertex_slice( subedge.pre_subvertex) edge = graph_mapper.get_partitionable_edge_from_partitioned_edge( subedge) pre_slices = [ graph_mapper.get_subvertex_slice(subv) for subv in graph_mapper.get_subvertices_from_vertex( edge.pre_vertex)] pre_slice_index = pre_slices.index(pre_vertex_slice) if isinstance(edge, ProjectionPartitionableEdge): for synapse_info in edge.synapse_information: synapse_type = synapse_info.synapse_type synapse_dynamics = synapse_info.synapse_dynamics connector = synapse_info.connector weight_mean = abs(synapse_dynamics.get_weight_mean( connector, pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) * weight_scale) n_connections = \ connector.get_n_connections_to_post_vertex_maximum( pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) weight_variance = abs(synapse_dynamics.get_weight_variance( connector, pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) * weight_scale_squared) running_totals[synapse_type].add_items( weight_mean, weight_variance, n_connections) delay_variance = synapse_dynamics.get_delay_variance( connector, pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) delay_running_totals[synapse_type].add_items( 0.0, delay_variance, n_connections) weight_max = (synapse_dynamics.get_weight_maximum( connector, pre_slices, pre_slice_index, post_slices, post_slice_index, pre_vertex_slice, post_vertex_slice) * weight_scale) biggest_weight[synapse_type] = max( biggest_weight[synapse_type], weight_max) spikes_per_tick = self._spikes_per_tick spikes_per_second = self._spikes_per_second if isinstance(edge.pre_vertex, SpikeSourcePoisson): spikes_per_second = edge.pre_vertex.rate if hasattr(spikes_per_second, "__getitem__"): spikes_per_second = max(spikes_per_second) elif isinstance(spikes_per_second, RandomDistribution): spikes_per_second = \ utility_calls.get_maximum_probable_value( spikes_per_second, pre_vertex_slice.n_atoms) prob = 1.0 - ((1.0 / 100.0) / pre_vertex_slice.n_atoms) spikes_per_tick = ( spikes_per_second / (1000000.0 / float(self._machine_time_step))) spikes_per_tick = scipy.stats.poisson.ppf( prob, spikes_per_tick) rate_stats[synapse_type].add_items( spikes_per_second, 0, n_connections) total_weights[synapse_type] += spikes_per_tick * ( weight_max * n_connections) if synapse_dynamics.are_weights_signed(): weights_signed = True max_weights = numpy.zeros(n_synapse_types) for synapse_type in range(n_synapse_types): stats = running_totals[synapse_type] rates = rate_stats[synapse_type] if delay_running_totals[synapse_type].variance == 0.0: max_weights[synapse_type] = total_weights[synapse_type] else: max_weights[synapse_type] = min( self._ring_buffer_expected_upper_bound( stats.mean, stats.standard_deviation, rates.mean, machine_timestep, stats.n_items, self._ring_buffer_sigma), total_weights[synapse_type]) max_weights[synapse_type] = max( max_weights[synapse_type], biggest_weight[synapse_type]) # Convert these to powers max_weight_powers = [0 if w <= 0 else int(math.ceil(max(0, math.log(w, 2)))) for w in max_weights] # If 2^max_weight_power equals the max weight, we have to add another # power, as range is 0 - (just under 2^max_weight_power)! max_weight_powers = [w + 1 if (2 ** w) <= a else w for w, a in zip(max_weight_powers, max_weights)] # If we have synapse dynamics that uses signed weights, # Add another bit of shift to prevent overflows if weights_signed: max_weight_powers = [m + 1 for m in max_weight_powers] return max_weight_powers