def __init__(self,
size,
cellclass,
cellparams=None,
structure=None,
initial_values=None,
label=None,
constraints=None,
additional_parameters=None):
"""
:param int size: The number of neurons in the population
:param cellclass: The implementation of the individual neurons.
:type cellclass: type or AbstractPyNNModel
:param cellparams: Parameters to pass to ``cellclass`` if it
is a class to instantiate. Must be ``None`` if ``cellclass`` is an
instantiated object.
:type cellparams: dict(str,object) or None
:param ~pyNN.space.BaseStructure structure:
:param dict(str,float) initial_values:
Initial values of state variables
:param str label: A label for the population
:param list(~pacman.model.constraints.AbstractConstraint) constraints:
Any constraints on how the population is deployed to SpiNNaker.
:param additional_parameters:
Additional parameters to pass to the vertex creation function.
:type additional_parameters: dict(str, ...)
"""
# pylint: disable=too-many-arguments
moved_in_v6("spynnaker8.models.populations.Population",
"spynnaker.pyNN.models.populations.Population")
super(Population, self).__init__(size, cellclass, cellparams,
structure, initial_values, label,
constraints, additional_parameters)
def __init__(
self, conn_list, safe=True, verbose=False, column_names=None,
callback=None):
"""
:param conn_list:
a list of tuples, one tuple for each connection. Each tuple should
contain: `(pre_idx, post_idx, p1, p2, ..., pn)` where `pre_idx` is
the index (i.e. order in the Population, not the ID) of the
presynaptic neuron, `post_idx` is the index of the postsynaptic
neuron, and `p1`, `p2`, etc. are the synaptic parameters (e.g.,
weight, delay, plasticity parameters).
:type conn_list: list(tuple(int,int,...)) or ~numpy.ndarray
:param bool safe:
if True, check that weights and delays have valid values.
If False, this check is skipped.
:param bool verbose:
Whether to output extra information about the connectivity to a
CSV file
:param column_names:
the names of the parameters `p1`, `p2`, etc. If not provided, it
is assumed the parameters are `weight, delay` (for backwards
compatibility).
:type column_names: tuple(str) or list(str) or None
:param callable callback:
if given, a callable that display a progress bar on the terminal.
.. note::
Not supported by sPyNNaker.
"""
moved_in_v6("spynnaker8.models.connectors.FromListConnector",
"spynnaker.pyNN.models.neural_projections.connectors"
".FromListConnector")
_BaseClass.__init__(
self, conn_list=conn_list, safe=safe, verbose=verbose,
column_names=column_names, callback=callback)
def __init__(
self, partner_selection, formation, elimination,
f_rew=DEFAULT_F_REW, initial_weight=DEFAULT_INITIAL_WEIGHT,
initial_delay=DEFAULT_INITIAL_DELAY, s_max=DEFAULT_S_MAX,
seed=None, weight=StaticSynapse.default_parameters['weight'],
delay=None):
"""
:param AbstractPartnerSelection partner_selection:
The partner selection rule
:param AbstractFormation formation: The formation rule
:param AbstractElimination elimination: The elimination rule
:param int f_rew: How many rewiring attempts will be done per second.
:param float initial_weight:
Weight assigned to a newly formed connection
:param initial_delay:
Delay assigned to a newly formed connection; a single value means
a fixed delay value, or a tuple of two values means the delay will
be chosen at random from a uniform distribution between the given
values
:type initial_delay: float or tuple(float, float)
:param int s_max: Maximum fan-in per target layer neuron
:param int seed: seed the random number generators
:param float weight: The weight of connections formed by the connector
:param delay: The delay of connections formed by the connector
:type delay: float or None
"""
moved_in_v6("spynnaker8.models.synapse_dynamics"
".SynapseDynamicsStructuralStatic",
"spynnaker.pyNN.models.neuron.synapse_dynamics"
".SynapseDynamicsStructuralStatic")
_BaseClass.__init__(
self, partner_selection, formation, elimination, f_rew=f_rew,
initial_weight=initial_weight, initial_delay=initial_delay,
s_max=s_max, seed=seed, weight=weight, delay=delay)
def __init__(
self, p_connect, allow_self_connections=True, safe=True,
verbose=False, rng=None, callback=None):
"""
:param float p_connect: a number between zero and one. Each potential
connection is created with this probability.
:param bool allow_self_connections: if the connector is used to
connect a Population to itself, this flag determines whether a
neuron is allowed to connect to itself, or only to other neurons
in the Population.
:param bool safe: if True, check that weights and delays have valid
values. If False, this check is skipped.
:param ~pyNN.space.Space space: a Space object, needed if you wish to
specify distance-dependent weights or delays - not implemented
:param bool verbose:
Whether to output extra information about the connectivity to a
CSV file
:param rng: random number generator
:type rng: ~pyNN.random.NumpyRNG or None
:param callable callback:
if given, a callable that display a progress bar on the terminal.
.. note::
Not supported by sPyNNaker.
"""
# pylint: disable=too-many-arguments
moved_in_v6("spynnaker8.models.connectors",
"spynnaker.pyNN.models.neural_projections.connectors")
_BaseClass.__init__(
self, p_connect=p_connect,
allow_self_connections=allow_self_connections, safe=safe,
verbose=verbose, rng=rng, callback=callback)
def __init__(self,
allow_self_connections=True,
safe=True,
verbose=None,
callback=None):
"""
:param bool allow_self_connections:
if the connector is used to connect a Population to itself, this
flag determines whether a neuron is allowed to connect to itself,
or only to other neurons in the Population.
:param bool safe: if True, check that weights and delays have valid
values. If False, this check is skipped.
:param bool verbose:
Whether to output extra information about the connectivity to a
CSV file
:param callable callback:
if given, a callable that display a progress bar on the terminal.
.. note::
Not supported by sPyNNaker.
"""
moved_in_v6(
"spynnaker8.models.connectors.AllToAllConnector",
"spynnaker.pyNN.models.neural_projections.connectors"
".AllToAllConnector")
_BaseClass.__init__(self,
allow_self_connections=allow_self_connections,
safe=safe,
verbose=verbose,
callback=callback)
def __init__(self,
n,
allow_self_connections=True,
with_replacement=True,
safe=True,
verbose=False,
rng=None):
"""
:param int n: This is the total number of synapses in the connection.
:param bool allow_self_connections:
Allow a neuron to connect to itself or not.
:param bool with_replacement:
When selecting, allow a neuron to be re-selected or not.
:param bool safe:
Whether to check that weights and delays have valid values.
If False, this check is skipped.
:param bool verbose:
Whether to output extra information about the connectivity to a
CSV file
:param rng: random number generator
:type rng: ~pyNN.random.NumpyRNG or None
"""
moved_in_v6(
"spynnaker8.models.connectors.MultapseConnector",
"spynnaker.pyNN.models.neural_projections.connectors."
"MultapseConnector")
super(MultapseConnector,
self).__init__(n=n,
allow_self_connections=allow_self_connections,
with_replacement=with_replacement,
safe=safe,
verbose=verbose,
rng=rng)
def __init__(self,
timing_dependence,
weight_dependence,
voltage_dependence=None,
dendritic_delay_fraction=1.0,
weight=PyNNStaticSynapse.default_parameters['weight'],
delay=None,
backprop_delay=True):
"""
:param AbstractTimingDependence timing_dependence:
:param AbstractWeightDependence weight_dependence:
:param None voltage_dependence: Unsupported
:param float dendritic_delay_fraction:
:param float weight:
:param delay:
:type delay: float or None
:param bool backprop_delay:
"""
# pylint: disable=too-many-arguments
# instantiate common functionality.
moved_in_v6(
"spynnaker8.models.synapse_dynamics.SynapseDynamicsSTDP",
"spynnaker.pyNN.models.neuron.synapse_dynamics"
".SynapseDynamicsSTDP")
super(SynapseDynamicsSTDP,
self).__init__(timing_dependence,
weight_dependence,
voltage_dependence,
dendritic_delay_fraction,
weight,
delay,
backprop_delay=backprop_delay)
def __init__(self,
pre_synaptic_population,
post_synaptic_population,
connector,
synapse_type=None,
source=None,
receptor_type=None,
space=None,
label=None):
"""
:param ~spynnaker.pyNN.models.populations.PopulationBase \
pre_synaptic_population:
:param ~spynnaker.pyNN.models.populations.PopulationBase \
post_synaptic_population:
:param AbstractConnector connector:
:param AbstractStaticSynapseDynamics synapse_type:
:param None source: Unsupported; must be None
:param str receptor_type:
:param ~pyNN.space.Space space:
:param str label:
"""
moved_in_v6("spynnaker8.models.projection",
"spynnaker.pyNN.models.projection")
super(Projection,
self).__init__(pre_synaptic_population, post_synaptic_population,
connector, synapse_type, source, receptor_type,
space, label)
def __init__(
self,
accumulator_depression=_defaults['accumulator_depression'],
accumulator_potentiation=_defaults['accumulator_potentiation'],
mean_pre_window=_defaults['mean_pre_window'],
mean_post_window=_defaults['mean_post_window'],
dual_fsm=_defaults['dual_fsm'],
A_plus=0.01,
A_minus=0.01):
"""
:param int accumulator_depression:
:param int accumulator_potentiation:
:param float mean_pre_window:
:param float mean_post_window:
:param bool dual_fsm:
:param float A_plus: :math:`A^+`
:param float A_minus: :math:`A^-`
"""
# pylint: disable=too-many-arguments
moved_in_v6(
"spynnaker8.models.synapse_dynamics.timing_dependence."
"TimingDependenceRecurrent",
"spynnaker.pyNN.models.neuron.plasticity.stdp."
"timing_dependence.TimingDependenceRecurrent")
super(TimingDependenceRecurrent,
self).__init__(accumulator_depression=accumulator_depression,
accumulator_potentiation=accumulator_potentiation,
mean_pre_window=mean_pre_window,
mean_post_window=mean_post_window,
dual_fsm=dual_fsm,
A_plus=A_plus,
A_minus=A_minus)
def __init__(self,
tau_plus,
tau_minus,
tau_x,
tau_y,
A_plus=0.01,
A_minus=0.01):
r"""
:param float tau_plus: :math:`\tau_+`
:param float tau_minus: :math:`\tau_-`
:param float tau_x: :math:`\tau_x`
:param float tau_y: :math:`\tau_y`
:param float A_plus: :math:`A^+`
:param float A_minus: :math:`A^-`
"""
# pylint: disable=too-many-arguments
moved_in_v6(
"spynnaker8.models.synapse_dynamics.timing_dependence."
"TimingDependencePfisterSpikeTriplet",
"spynnaker.pyNN.models.neuron.plasticity.stdp."
"timing_dependence.TimingDependencePfisterSpikeTriplet")
super(TimingDependencePfisterSpikeTriplet,
self).__init__(tau_plus=tau_plus,
tau_minus=tau_minus,
tau_x=tau_x,
tau_y=tau_y,
A_plus=A_plus,
A_minus=A_minus)
def __init__(self, population, vertex):
"""
:param population: the population to record for
:type population: ~spynnaker.pyNN.models.populations.Population
"""
moved_in_v6("spynnaker8.models.recorder",
"spynnaker.pyNN.models.recorder")
super(Recorder, self).__init__(population, vertex)
def __init__(self, w_min=0.0, w_max=1.0):
r"""
:param float w_min: :math:`w_\mathrm{min}`
:param float w_max: :math:`w_\mathrm{max}`
"""
moved_in_v6("spynnaker8.models.synapse_dynamics.weight_dependence"
".WeightDependenceMultiplicative",
"spynnaker.pyNN.models.neuron.plasticity.stdp."
"weight_dependence.WeightDependenceMultiplicative")
super(WeightDependenceMultiplicative, self).__init__(
w_max=w_max, w_min=w_min)
def __init__(self, *populations, **kwargs):
"""
:param populations:
the populations or views to form the assembly out of
:type populations: ~spynnaker.pyNN.models.populations.Population or
~spynnaker.pyNN.models.populations.PopulationView
:param kwargs: may contain `label` (a string describing the assembly)
"""
moved_in_v6("spynnaker8.models.populations.Assembly",
"spynnaker.pyNN.models.populations.Assembly")
super(Assembly, self).__init__(*populations, **kwargs)
def convert_spiketrains(spiketrains):
""" Converts a list of spiketrains into spynnaker7 format
.. deprecated:: 6.0
Use
:py:class:`spynnaker.pyNN.utilities.neo_convertor` instead.
:param list(~neo.core.SpikeTrain) spiketrains: List of SpikeTrains
:rtype: ~numpy.ndarray
"""
moved_in_v6("spynnaker8.utilities.neo_convertor",
"spynnaker.pyNN.utilities.neo_convertor")
return _convert_spiketrains(spiketrains)
def __init__(self,
weight=PyNNStaticSynapse.default_parameters['weight'],
delay=None):
"""
:param float weight:
:param delay:
:type delay: float or None
"""
moved_in_v6(
"spynnaker8.models.synapse_dynamics.SynapseDynamicsStatic",
"spynnaker.pyNN.models.neuron.synapse_dynamics"
".SynapseDynamicsStatic")
super(SynapseDynamicsStatic, self).__init__(weight, delay)
def __init__(
self, alpha, tau=_defaults['tau'], A_plus=0.01, A_minus=0.01):
r"""
:param float alpha: :math:`\alpha`
:param float tau: :math:`\tau`
:param float A_plus: :math:`A^+`
:param float A_minus: :math:`A^-`
"""
moved_in_v6("spynnaker8.models.synapse_dynamics.timing_dependence."
"TimingDependenceVogels2011",
"spynnaker.pyNN.models.neuron.plasticity.stdp."
"timing_dependence.TimingDependenceVogels2011")
super(TimingDependenceVogels2011, self).__init__(
tau=tau, alpha=alpha, A_plus=A_plus, A_minus=A_minus)
def count_spiketrains(spiketrains):
""" Help function to count the number of spikes in a list of spiketrains
.. deprecated:: 6.0
Use
:py:class:`spynnaker.pyNN.utilities.neo_convertor` instead.
:param list(~neo.core.SpikeTrain) spiketrains: List of SpikeTrains
:return: Total number of spikes in all the spiketrains
:rtype: int
"""
moved_in_v6("spynnaker8.utilities.neo_convertor",
"spynnaker.pyNN.utilities.neo_convertor")
return sum(map(len, spiketrains))
def convert_spikes(neo, run=0):
""" Extracts the spikes for run one from a Neo Object
.. deprecated:: 6.0
Use
:py:class:`spynnaker.pyNN.utilities.neo_convertor` instead.
:param ~neo.core.Block neo: neo Object including Spike Data
:param int run: Zero based index of the run to extract data for
:rtype: ~numpy.ndarray
"""
moved_in_v6("spynnaker8.utilities.neo_convertor",
"spynnaker.pyNN.utilities.neo_convertor")
return _convert_spikes(neo, run)
def convert_gsyn(gsyn_exc, gsyn_inh):
""" Converts two neo objects into the spynnaker7 format
.. deprecated:: 6.0
Use
:py:class:`spynnaker.pyNN.utilities.neo_convertor` instead.
:param ~neo.core.Block gsyn_exc: neo with gsyn_exc data
:param ~neo.core.Block gsyn_inh: neo with gsyn_exc data
:rtype: ~numpy.ndarray
"""
moved_in_v6("spynnaker8.utilities.neo_convertor",
"spynnaker.pyNN.utilities.neo_convertor")
return _convert_gsyn(gsyn_exc, gsyn_inh)
def plot_spikes_numpy(ax, spikes, label='', **options):
""" Plot all spikes
.. deprecated:: 6.0
Use
:py:class:`spynnaker.spynnaker_plotting` instead.
:param ~matplotlib.axes.Axes ax: An Axes in a matplotlib figure
:param ~numpy.ndarray spikes: spynakker7 format nparray of spikes
:param str label: Label for the graph
:param options: plotting options
"""
moved_in_v6("spynnaker8.spynnaker_plotting",
"spynnaker.spynnaker_plotting")
new_plotting.plot_spikes_numpy(ax, spikes, label, **options)
def heat_plot_numpy(ax, data, label='', **options):
""" Plots neurons, times and values into a heatmap
.. deprecated:: 6.0
Use
:py:class:`spynnaker.spynnaker_plotting` instead.
:param ~matplotlib.axes.Axes ax: An Axes in a matplotlib figure
:param ~numpy.ndarray data: nparray of values in spynnaker7 format
:param str label: Label for the graph
:param options: plotting options
"""
moved_in_v6("spynnaker8.spynnaker_plotting",
"spynnaker.spynnaker_plotting")
new_plotting.heat_plot_numpy(ax, data, label, **options)
def plot_spiketrains(ax, spiketrains, label='', **options):
""" Plot all spike trains in a Segment in a raster plot.
.. deprecated:: 6.0
Use
:py:class:`spynnaker.spynnaker_plotting` instead.
:param ~matplotlib.axes.Axes ax: An Axes in a matplotlib figure
:param list(~neo.core.SpikeTrain) spiketrains: List of spiketimes
:param str label: Label for the graph
:param options: plotting options
"""
moved_in_v6("spynnaker8.spynnaker_plotting",
"spynnaker.spynnaker_plotting")
new_plotting.plot_spiketrains(ax, spiketrains, label, **options)
def convert_analog_signal(signal_array, time_unit):
""" Converts part of a NEO object into told spynnaker7 format
.. deprecated:: 6.0
Use
:py:class:`spynnaker.pyNN.utilities.neo_convertor` instead.
:param ~neo.core.AnalogSignal signal_array: Extended Quantities object
:param quantities.unitquantity.UnitTime time_unit:
Data time unit for time index
:rtype: ~numpy.ndarray
"""
moved_in_v6("spynnaker8.utilities.neo_convertor",
"spynnaker.pyNN.utilities.neo_convertor")
return _convert_analog_signal(signal_array, time_unit)
def heat_plot_neo(ax, signal_array, label='', **options):
""" Plots neurons, times and values into a heatmap
.. deprecated:: 6.0
Use
:py:class:`spynnaker.spynnaker_plotting` instead.
:param ~matplotlib.axes.Axes ax: An Axes in a matplotlib figure
:param ~neo.core.AnalogSignal signal_array: Neo Signal array Object
:param str label: Label for the graph
:param options: plotting options
"""
moved_in_v6("spynnaker8.spynnaker_plotting",
"spynnaker.spynnaker_plotting")
new_plotting.heat_plot_neo(ax, signal_array, label, **options)
def plot_segment(axes, segment, label='', **options):
""" Plots a segment into a plot of spikes or a heatmap
.. deprecated:: 6.0
Use
:py:class:`spynnaker.spynnaker_plotting` instead.
:param ~matplotlib.axes.Axes axes: An Axes in a matplotlib figure
:param ~neo.core.Segment segment: Data for one run to plot
:param str label: Label for the graph
:param options: plotting options
"""
moved_in_v6("spynnaker8.spynnaker_plotting",
"spynnaker.spynnaker_plotting")
new_plotting.plot_segment(axes, segment, label, **options)
def __init__(self, safe=True, callback=None):
"""
:param bool safe: if True, check that weights and delays have valid
values. If False, this check is skipped.
:param callable callback: a function that will be called with the
fractional progress of the connection routine. An example would
be `progress_bar.set_level`.
.. note::
Not supported by sPyNNaker.
"""
moved_in_v6(
"spynnaker8.models.connectors.OneToOneConnector",
"spynnaker.pyNN.models.neural_projections.connectors"
".OneToOneConnector")
_BaseClass.__init__(self, safe=safe, callback=callback)
def convert_data(data, name, run=0):
""" Converts the data into a numpy array in the format ID, time, value
.. deprecated:: 6.0
Use
:py:class:`spynnaker.pyNN.utilities.neo_convertor` instead.
:param ~neo.core.Block data: Data as returned by a getData() call
:param str name: Name of the data to be extracted.
Same values as used in getData()
:param int run: Zero based index of the run to extract data for
:rtype: ~numpy.ndarray
"""
moved_in_v6("spynnaker8.utilities.neo_convertor",
"spynnaker.pyNN.utilities.neo_convertor")
return _convert_data(data, name, run)
def __init__(self, w_min=0.0, w_max=1.0, A3_plus=0.01, A3_minus=0.01):
r"""
:param float w_min: :math:`w_\mathrm{min}`
:param float w_max: :math:`w_\mathrm{max}`
:param float A3_plus: :math:`A_3^+`
:param float A3_minus: :math:`A_3^-`
"""
moved_in_v6(
"spynnaker8.models.synapse_dynamics.weight_dependence"
".WeightDependenceAdditiveTriplet",
"spynnaker.pyNN.models.neuron.plasticity.stdp."
"weight_dependence.WeightDependenceAdditiveTriplet")
super(WeightDependenceAdditiveTriplet,
self).__init__(w_max=w_max,
w_min=w_min,
A3_plus=A3_plus,
A3_minus=A3_minus)
def convert_v_list(data, runs=None):
""" Converts the voltage into a list numpy array one per segment (all\
runs) in the format ID, time, value
.. deprecated:: 6.0
Use
:py:class:`spynnaker.pyNN.utilities.neo_convertor` instead.
:param ~neo.core.Block data: The data to convert; it must have V data in it
:param runs: List of Zero based index of the run to extract data for.
Or None to extract all runs
:type runs: list(int) or None
:rtype: list(~numpy.ndarray)
"""
moved_in_v6("spynnaker8.utilities.neo_convertor",
"spynnaker.pyNN.utilities.neo_convertor")
return _convert_data_list(data, "v", runs=runs)
def __init__(self,
n,
allow_self_connections=True,
safe=True,
verbose=False,
with_replacement=False,
rng=None,
callback=None):
"""
:param int n:
number of random pre-synaptic neurons connected to post-neurons
:param bool allow_self_connections:
if the connector is used to connect a Population to itself, this
flag determines whether a neuron is allowed to connect to itself,
or only to other neurons in the Population.
:param bool safe:
Whether to check that weights and delays have valid values.
If False, this check is skipped.
:param bool verbose:
Whether to output extra information about the connectivity to a
CSV file
:param bool with_replacement:
if False, once a connection is made, it can't be made again; if
True, multiple connections between the same pair of neurons are
allowed
:param rng: random number generator
:type rng: ~pyNN.random.NumpyRNG or None
:param callable callback:
if given, a callable that display a progress bar on the terminal.
.. note::
Not supported by sPyNNaker.
"""
# pylint: disable=too-many-arguments
moved_in_v6(
"spynnaker8.models.connectors.FixedNumberPreConnector",
"spynnaker.pyNN.models.neural_projections.connectors"
".FixedNumberPreConnector")
super(FixedNumberPreConnector,
self).__init__(n=n,
allow_self_connections=allow_self_connections,
with_replacement=with_replacement,
safe=safe,
verbose=verbose,
rng=rng)
