def _get_n_connections_from_pre_vertex_with_delay_maximum(
self, delays, n_total_connections, n_connections,
min_delay, max_delay):
""" Get the expected number of delays that will fall within min_delay\
and max_delay given given a float, RandomDistribution or list of\
delays.
"""
# pylint: disable=too-many-arguments
if get_simulator().is_a_pynn_random(delays):
prob_in_range = utility_calls.get_probability_within_range(
delays, min_delay, max_delay)
return int(math.ceil(utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_in_range)))
elif numpy.isscalar(delays):
if min_delay <= delays <= max_delay:
return int(math.ceil(n_connections))
return 0
elif hasattr(delays, "__getitem__"):
n_delayed = sum([len([
delay for delay in delays
if min_delay <= delay <= max_delay])])
if n_delayed == 0:
return 0
n_total = len(delays)
prob_delayed = float(n_delayed) / float(n_total)
return int(math.ceil(utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_delayed)))
raise Exception("Unrecognised delay format")
def _get_n_connections_from_pre_vertex_with_delay_maximum(
delays, n_total_connections, n_connections, connection_slices,
min_delay, max_delay):
""" Gets the expected number of delays that will fall within min_delay\
and max_delay given given a float, RandomDistribution or list of\
delays
"""
if globals_variables.get_simulator().is_a_pynn_random(delays):
prob_in_range = utility_calls.get_probability_within_range(
delays, min_delay, max_delay)
return int(
math.ceil(
utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_in_range)))
elif numpy.isscalar(delays):
if min_delay <= delays <= max_delay:
return int(math.ceil(n_connections))
return 0
elif hasattr(delays, "__getitem__"):
n_delayed = sum([
len([
delay for delay in delays[connection_slice]
if min_delay <= delay <= max_delay
]) for connection_slice in connection_slices
])
n_total = sum([
len(delays[connection_slice])
for connection_slice in connection_slices
])
prob_delayed = float(n_delayed) / float(n_total)
return int(
math.ceil(
utility_calls.get_probable_maximum_selected(
n_total_connections, n_delayed, prob_delayed)))
raise Exception("Unrecognised delay format")
def get_n_connections_from_pre_vertex_maximum(self,
post_vertex_slice,
synapse_info,
min_delay=None,
max_delay=None):
# pylint: disable=too-many-arguments
prob_selection = 1.0 / float(synapse_info.n_pre_neurons)
n_connections_total = utility_calls.get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
self.__n_pre * synapse_info.n_post_neurons,
prob_selection,
chance=1.0 / 10000.0)
prob_in_slice = min(
float(post_vertex_slice.n_atoms) /
float(synapse_info.n_post_neurons), 1.0)
n_connections = utility_calls.get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
n_connections_total,
prob_in_slice,
chance=1.0 / 100000.0)
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
synapse_info.delays,
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
n_connections, min_delay, max_delay)
def _get_n_connections_from_pre_vertex_with_delay_maximum(
self, delays, n_total_connections, n_connections, min_delay,
max_delay):
""" Get the expected number of delays that will fall within min_delay\
and max_delay given given a float, RandomDistribution or list of\
delays.
"""
# pylint: disable=too-many-arguments
if get_simulator().is_a_pynn_random(delays):
prob_in_range = utility_calls.get_probability_within_range(
delays, min_delay, max_delay)
return int(
math.ceil(
utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_in_range)))
elif numpy.isscalar(delays):
if min_delay <= delays <= max_delay:
return int(math.ceil(n_connections))
return 0
elif hasattr(delays, "__getitem__"):
n_delayed = sum([
len([
delay for delay in delays
if min_delay <= delay <= max_delay
])
])
if n_delayed == 0:
return 0
n_total = len(delays)
prob_delayed = float(n_delayed) / float(n_total)
return int(
math.ceil(
utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_delayed)))
raise Exception("Unrecognised delay format")
def _get_n_connections_from_pre_vertex_with_delay_maximum(
delays, n_total_connections, n_connections, connection_slices,
min_delay, max_delay):
""" Gets the expected number of delays that will fall within min_delay\
and max_delay given given a float, RandomDistribution or list of\
delays
"""
if isinstance(delays, RandomDistribution):
prob_in_range = utility_calls.get_probability_within_range(
delays, min_delay, max_delay)
return int(math.ceil(utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_in_range)))
elif numpy.isscalar(delays):
if min_delay <= delays <= max_delay:
return int(math.ceil(n_connections))
return 0
elif hasattr(delays, "__getitem__"):
n_delayed = sum([len([
delay for delay in delays[connection_slice]
if min_delay <= delay <= max_delay])
for connection_slice in connection_slices])
n_total = sum([
len(delays[connection_slice])
for connection_slice in connection_slices])
prob_delayed = float(n_delayed) / float(n_total)
return int(math.ceil(utility_calls.get_probable_maximum_selected(
n_total_connections, n_delayed, prob_delayed)))
raise Exception("Unrecognised delay format")
def _get_n_connections_from_pre_vertex_with_delay_maximum(
self, delays, n_total_connections, n_connections, min_delay,
max_delay, synapse_info):
""" Get the expected number of delays that will fall within min_delay
and max_delay given 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_total_connections:
:param int n_connections:
:param float min_delay:
:param float max_delay:
:rtype: float
"""
if isinstance(delays, RandomDistribution):
prob_in_range = utility_calls.get_probability_within_range(
delays, min_delay, max_delay)
return int(
math.ceil(
utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_in_range)))
elif isinstance(delays, str):
d = self._get_distances(delays, synapse_info)
delays = _expr_context.eval(delays, d=d)
n_delayed = sum([
len([
delay for delay in delays
if min_delay <= delay <= max_delay
])
])
if n_delayed == 0:
return 0
n_total = len(delays)
prob_delayed = float(n_delayed) / float(n_total)
return int(
math.ceil(
utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_delayed)))
elif numpy.isscalar(delays):
if min_delay <= delays <= max_delay:
return int(math.ceil(n_connections))
return 0
elif hasattr(delays, "__getitem__"):
n_delayed = sum([
len([
delay for delay in delays
if min_delay <= delay <= max_delay
])
])
if n_delayed == 0:
return 0
n_total = len(delays)
prob_delayed = float(n_delayed) / float(n_total)
return int(
math.ceil(
utility_calls.get_probable_maximum_selected(
n_total_connections, n_connections, prob_delayed)))
raise SpynnakerException("Unrecognised delay format")
def get_delay_maximum(self, delays):
return self._get_delay_maximum(
delays,
utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons,
numpy.amax(self._probs)))
def get_delay_maximum(self, synapse_info):
self._update_probs_from_index_expression(synapse_info)
n_connections = utility_calls.get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
numpy.amax(self.__probs))
return self._get_delay_maximum(synapse_info.delays, n_connections)
def get_delay_maximum(self, synapse_info):
return self._get_delay_maximum(
synapse_info.delays,
get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
numpy.amax(self.__probs)), synapse_info)
def get_n_connections_to_post_vertex_maximum(self, synapse_info):
# pylint: disable=too-many-arguments
n_connections = utility_calls.get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_pre_neurons, self._p_connect,
chance=1.0/10000.0)
return n_connections
def get_delay_maximum(self, delays):
return self._get_delay_maximum(
delays,
utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons,
numpy.amax(self.__probs)))
def get_weight_maximum(self, weights):
self._update_probs_from_index_expression()
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons,
numpy.amax(self._probs))
return self._get_weight_maximum(weights, n_connections)
def get_weight_maximum(self, synapse_info):
# pylint: disable=too-many-arguments
n_connections = utility_calls.get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
self._p_connect)
return self._get_weight_maximum(synapse_info.weights, n_connections)
def get_n_connections_from_pre_vertex_maximum(
self, post_vertex_slice, min_delay=None, max_delay=None):
prob_in_slice = (
float(post_vertex_slice.n_atoms) / float(self._n_post_neurons))
max_in_slice = utility_calls.get_probable_maximum_selected(
self._num_synapses, self._num_synapses, prob_in_slice)
prob_in_row = 1.0 / float(self._n_pre_neurons)
n_connections = utility_calls.get_probable_maximum_selected(
self._num_synapses, max_in_slice, prob_in_row)
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
self._n_pre_neurons * self._n_post_neurons, n_connections,
min_delay, max_delay)
def get_delay_maximum(self, synapse_info):
n_connections = get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
self._p_connect)
return self._get_delay_maximum(synapse_info.delays, n_connections,
synapse_info)
def get_weight_maximum(self):
# pylint: disable=too-many-arguments
return self._get_weight_maximum(
utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons,
numpy.amax(self._probs)))
def get_n_connections_from_pre_vertex_maximum(
self, pre_slices, pre_slice_index, post_slices,
post_slice_index, pre_vertex_slice, post_vertex_slice,
min_delay=None, max_delay=None):
self._update_synapses_per_post_vertex(pre_slices, post_slices)
n_total_connections = self._get_n_connections(
pre_slice_index, post_slice_index)
if n_total_connections == 0:
return 0
prob_per_atom = (
float(n_total_connections) /
float(pre_vertex_slice.n_atoms * post_vertex_slice.n_atoms))
full_connections = 0
while prob_per_atom > 1.0:
full_connections += 1
prob_per_atom -= 1.0
n_connections_per_pre_atom = \
utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
post_vertex_slice.n_atoms, prob_per_atom)
n_connections_per_pre_atom += (
full_connections * post_vertex_slice.n_atoms)
if min_delay is None or max_delay is None:
return n_connections_per_pre_atom
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
self._delays, self._n_pre_neurons * self._n_post_neurons,
n_connections_per_pre_atom,
[self._get_connection_slice(pre_slice_index, post_slice_index)],
min_delay, max_delay)
def get_weight_maximum(self, weights):
self._update_probs_from_index_expression()
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons,
numpy.amax(self._probs))
return self._get_weight_maximum(weights, n_connections)
def get_n_connections_from_pre_vertex_maximum(
self, pre_slices, pre_slice_index, post_slices,
post_slice_index, pre_vertex_slice, post_vertex_slice,
min_delay=None, max_delay=None):
self._update_synapses_per_post_vertex(pre_slices, post_slices)
n_total_connections = self._get_n_connections(
pre_slice_index, post_slice_index)
if n_total_connections == 0:
return 0
prob_per_atom = (
float(n_total_connections) /
float(pre_vertex_slice.n_atoms * post_vertex_slice.n_atoms))
full_connections = 0
while prob_per_atom > 1.0:
full_connections += 1
prob_per_atom -= 1.0
n_connections_per_pre_atom = \
utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
post_vertex_slice.n_atoms, prob_per_atom)
n_connections_per_pre_atom += (
full_connections * post_vertex_slice.n_atoms)
if min_delay is None or max_delay is None:
return n_connections_per_pre_atom
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
self._delays, self._n_pre_neurons * self._n_post_neurons,
n_connections_per_pre_atom,
[self._get_connection_slice(pre_slice_index, post_slice_index)],
min_delay, max_delay)
def get_n_connections_from_pre_vertex_maximum(
self, delays, post_vertex_slice, min_delay=None, max_delay=None):
prob_in_slice = (
float(post_vertex_slice.n_atoms) / float(self._n_post_neurons))
max_in_slice = utility_calls.get_probable_maximum_selected(
self._num_synapses, self._num_synapses, prob_in_slice)
prob_in_row = 1.0 / float(self._n_pre_neurons)
n_connections = utility_calls.get_probable_maximum_selected(
self._num_synapses, max_in_slice, prob_in_row)
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
delays, self._n_pre_neurons * self._n_post_neurons,
n_connections, min_delay, max_delay)
def get_weight_maximum(self, synapse_info):
# pylint: disable=too-many-arguments
return self._get_weight_maximum(
synapse_info.weights,
get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
numpy.amax(self.__probs)), synapse_info)
def get_weight_maximum(self, weights):
# pylint: disable=too-many-arguments
return self._get_weight_maximum(
weights,
utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons,
numpy.amax(self._probs)))
def get_n_connections_to_post_vertex_maximum(self, synapse_info):
# pylint: disable=too-many-arguments
selection_prob = 1.0 / float(synapse_info.n_post_neurons)
n_connections = utility_calls.get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_pre_neurons, selection_prob,
chance=1.0/100000.0)
return int(math.ceil(n_connections))
def get_n_connections_to_post_vertex_maximum(self):
# pylint: disable=too-many-arguments
selection_prob = 1.0 / float(self._n_post_neurons)
n_connections = utility_calls.get_probable_maximum_selected(
self._n_post_neurons * self._n_pre_neurons,
self._n_post * self._n_pre_neurons, selection_prob,
chance=1.0/100000.0)
return int(math.ceil(n_connections))
def get_delay_maximum(self):
self._update_probs_from_index_expression()
return self._get_delay_maximum(
self._delays,
utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons,
numpy.amax(self._probs)))
def get_n_connections_from_pre_vertex_maximum(
self, delays, post_vertex_slice, min_delay=None, max_delay=None):
# pylint: disable=too-many-arguments
prob_selection = 1.0 / float(self._n_pre_neurons)
n_connections_total = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre * self._n_post_neurons, prob_selection,
chance=1.0/10000.0)
prob_in_slice = (
float(post_vertex_slice.n_atoms) / float(self._n_post_neurons))
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
n_connections_total, prob_in_slice)
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
delays, self._n_pre_neurons * self._n_post_neurons,
n_connections, min_delay, max_delay)
def get_n_connections_from_pre_vertex_maximum(
self, delays, post_vertex_slice, min_delay=None, max_delay=None):
self._update_probs_from_index_expression()
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
post_vertex_slice.n_atoms, numpy.amax(self.__probs))
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
delays, self._n_pre_neurons * self._n_post_neurons,
n_connections, min_delay, max_delay)
def get_n_connections_from_pre_vertex_maximum(
self, delays, post_vertex_slice, min_delay=None, max_delay=None):
self._update_probs_from_index_expression()
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
post_vertex_slice.n_atoms, numpy.amax(self._probs))
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
delays, self._n_pre_neurons * self._n_post_neurons,
n_connections, min_delay, max_delay)
def get_n_connections_from_pre_vertex_maximum(
self, delays, post_vertex_slice, min_delay=None, max_delay=None):
# pylint: disable=too-many-arguments
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
post_vertex_slice.n_atoms, self._p_connect, chance=1.0/10000.0)
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
delays, self._n_pre_neurons * self._n_post_neurons,
n_connections, min_delay, max_delay)
def get_n_connections_from_pre_vertex_maximum(
self, delays, post_vertex_slice, min_delay=None, max_delay=None):
# pylint: disable=too-many-arguments
max_prob = numpy.amax(
self._probs[0:self._n_pre_neurons, post_vertex_slice.as_slice])
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
post_vertex_slice.n_atoms, max_prob)
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
delays, self._n_pre_neurons * self._n_post_neurons,
n_connections, min_delay, max_delay)
def get_n_connections_from_pre_vertex_maximum(
self, post_vertex_slice, min_delay=None, max_delay=None):
# pylint: disable=too-many-arguments
prob_in_slice = (
post_vertex_slice.n_atoms / float(self._n_post_neurons))
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_pre_neurons,
self._n_post, prob_in_slice)
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
self._n_post_neurons * self._n_pre_neurons, n_connections,
min_delay, max_delay)
def get_n_connections_from_pre_vertex_maximum(self,
post_vertex_slice,
min_delay=None,
max_delay=None):
# pylint: disable=too-many-arguments
max_prob = numpy.amax(self._probs[0:self._n_pre_neurons,
post_vertex_slice.as_slice])
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
post_vertex_slice.n_atoms, max_prob)
if min_delay is None or max_delay is None:
return int(math.ceil(n_connections))
return self._get_n_connections_from_pre_vertex_with_delay_maximum(
self._n_pre_neurons * self._n_post_neurons, n_connections,
min_delay, max_delay)
def get_n_connections_to_post_vertex_maximum(
self, pre_slices, pre_slice_index, post_slices,
post_slice_index, pre_vertex_slice, post_vertex_slice):
self._update_synapses_per_post_vertex(pre_slices, post_slices)
n_total_connections = self._get_n_connections(
pre_slice_index, post_slice_index)
if n_total_connections == 0:
return 0
prob_per_atom = (
float(n_total_connections) /
float(pre_vertex_slice.n_atoms * post_vertex_slice.n_atoms))
full_connections = 0
while prob_per_atom > 1.0:
full_connections += 1
prob_per_atom -= 1.0
return (utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
pre_vertex_slice.n_atoms, prob_per_atom) +
(full_connections * pre_vertex_slice.n_atoms))
def get_n_connections_to_post_vertex_maximum(
self, pre_slices, pre_slice_index, post_slices,
post_slice_index, pre_vertex_slice, post_vertex_slice):
self._update_synapses_per_post_vertex(pre_slices, post_slices)
n_total_connections = self._get_n_connections(
pre_slice_index, post_slice_index)
if n_total_connections == 0:
return 0
prob_per_atom = (
float(n_total_connections) /
float(pre_vertex_slice.n_atoms * post_vertex_slice.n_atoms))
full_connections = 0
while prob_per_atom > 1.0:
full_connections += 1
prob_per_atom -= 1.0
return (utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
pre_vertex_slice.n_atoms, prob_per_atom) +
(full_connections * pre_vertex_slice.n_atoms))
def get_n_connections_to_post_vertex_maximum(self):
# pylint: disable=too-many-arguments
return utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons, self._n_post_neurons,
numpy.amax(self.__probs))
def get_n_connections_to_post_vertex_maximum(self):
# pylint: disable=too-many-arguments
return utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons, self._n_post_neurons,
numpy.amax(self._probs))
def get_n_connections_to_post_vertex_maximum(self, synapse_info):
self._update_probs_from_index_expression(synapse_info)
return utility_calls.get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_pre_neurons, numpy.amax(self.__probs))
def get_n_connections_to_post_vertex_maximum(self):
prob_of_choosing_post_atom = 1.0 / float(self._n_post_neurons)
return utility_calls.get_probable_maximum_selected(
self.__num_synapses, self.__num_synapses,
prob_of_choosing_post_atom)
def get_delay_maximum(self):
return self._get_delay_maximum(
self._delays, utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons, self._p_connect))
def _get_n_connections(self, out_of):
return utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons, out_of,
self._p_connect)
def get_n_connections_to_post_vertex_maximum(self):
self._update_probs_from_index_expression()
return utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons, numpy.amax(self._probs))
def get_n_connections_to_post_vertex_maximum(self, synapse_info):
# pylint: disable=too-many-arguments
return get_probable_maximum_selected(
synapse_info.n_pre_neurons * synapse_info.n_post_neurons,
synapse_info.n_post_neurons, numpy.amax(self.__probs))
def get_delay_maximum(self, delays):
n_connections = utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons,
self._n_pre_neurons * self._n_post_neurons, self._p_connect)
return self._get_delay_maximum(delays, n_connections)
def _get_n_connections(self, out_of, pre_vertex_slice, post_vertex_slice):
max_prob = numpy.amax(
self._probs[pre_vertex_slice.as_slice, post_vertex_slice.as_slice])
return utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons, out_of,
max_prob)
def _get_n_connections(self, out_of):
return utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons, out_of,
self._p_connect)
def _get_n_connections(self, out_of):
return utility_calls.get_probable_maximum_selected(
self._n_post_neurons,
self._n_pre * out_of,
1.0 / self._n_pre_neurons,
chance=(1.0 / 100000.0))
def get_n_connections_to_post_vertex_maximum(self):
prob_of_choosing_post_atom = 1.0 / float(self._n_post_neurons)
return utility_calls.get_probable_maximum_selected(
self._num_synapses, self._num_synapses, prob_of_choosing_post_atom)
def _get_n_connections(self, out_of, pre_vertex_slice, post_vertex_slice):
self._update_probs_from_index_expression()
max_prob = numpy.amax(self._probs[pre_vertex_slice.as_slice,
post_vertex_slice.as_slice])
return utility_calls.get_probable_maximum_selected(
self._n_pre_neurons * self._n_post_neurons, out_of, max_prob)
