7288977951

Committed 21 Dec 2023 01:49PM UTC coverage: 62.824% (+0.05%) from 62.778%

Build # 7288977951

Build Type

Pull #1425

github

Committed by

Christian-B

Commit Message

typing fixes

Pull Request Pull Request #1425: Overrides check

Run Details

1909 of 4481 branches covered (0.0%)

Branch coverage included in aggregate %.

326 of 360 new or added lines in 66 files covered. (90.56%)

31 existing lines in 17 files now uncovered.

12798 of 18929 relevant lines covered (67.61%)

0.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

44.44

/spynnaker/pyNN/models/neuron/synapse_dynamics/synapse_dynamics_structural_stdp.py

# Copyright (c) 2017 The University of Manchester
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import annotations
import numpy
from pyNN.standardmodels.synapses import StaticSynapse
from typing import (
    Dict, Iterable, Optional, Sequence, Tuple, TYPE_CHECKING, Union)
from spinn_utilities.overrides import overrides
from pacman.model.graphs.application import ApplicationVertex
from spynnaker.pyNN.exceptions import SynapticConfigurationException
from spynnaker.pyNN.types import Weight_Delay_In_Types as _In_Types
from spynnaker.pyNN.utilities.utility_calls import create_mars_kiss_seeds
from .abstract_synapse_dynamics_structural import (
    AbstractSynapseDynamicsStructural, InitialDelay)
from .synapse_dynamics_stdp import SynapseDynamicsSTDP
from .synapse_dynamics_structural_common import (
    DEFAULT_F_REW, DEFAULT_INITIAL_WEIGHT, DEFAULT_INITIAL_DELAY,
    DEFAULT_S_MAX, SynapseDynamicsStructuralCommon)
from .synapse_dynamics_neuromodulation import SynapseDynamicsNeuromodulation
from spynnaker.pyNN.utilities.constants import SPIKE_PARTITION_ID
from .abstract_synapse_dynamics import AbstractSynapseDynamics
from .abstract_plastic_synapse_dynamics import AbstractPlasticSynapseDynamics
if TYPE_CHECKING:
    from pacman.model.graphs import AbstractVertex
    from pacman.model.graphs.machine import MachineVertex
    from pacman.model.graphs.common import Slice
    from spynnaker.pyNN.models.neuron.structural_plasticity.synaptogenesis.\
        partner_selection.abstract_partner_selection import \
        AbstractPartnerSelection
    from spynnaker.pyNN.models.neuron.structural_plasticity.synaptogenesis.\
        formation.abstract_formation import AbstractFormation
    from spynnaker.pyNN.models.neuron.structural_plasticity.synaptogenesis.\
        elimination.abstract_elimination import AbstractElimination
    from spynnaker.pyNN.models.neuron.plasticity.stdp.timing_dependence.\
        abstract_timing_dependence import AbstractTimingDependence
    from spynnaker.pyNN.models.neuron.plasticity.stdp.weight_dependence.\
        abstract_weight_dependence import AbstractWeightDependence
    from spynnaker.pyNN.models.neural_projections import (
        ProjectionApplicationEdge, SynapseInformation)
    from spynnaker.pyNN.models.neural_projections.connectors import (
        AbstractConnector)
    from spynnaker.pyNN.models.neuron.synapse_dynamics.types import (
        ConnectionsArray)
    from .synapse_dynamics_structural_common import ConnectionsInfo


class SynapseDynamicsStructuralSTDP(
        SynapseDynamicsSTDP, SynapseDynamicsStructuralCommon):
    """
    Class that enables synaptic rewiring in the presence of STDP.

    It acts as a wrapper around SynapseDynamicsSTDP, meaning rewiring can
    operate in parallel with STDP synapses.

    Written by Petrut Bogdan.
    """
    __slots__ = (
        # Frequency of rewiring (Hz)
        "__f_rew",
        # Initial weight assigned to a newly formed connection
        "__initial_weight",
        # Delay assigned to a newly formed connection
        "__initial_delay",
        # Maximum fan-in per target layer neuron
        "__s_max",
        # The seed
        "__seed",
        # Holds initial connectivity as defined via connector
        "__connections",
        # The actual type of weights: static through the simulation or those
        # that can be change through STDP
        "__weight_dynamics",
        # Shared RNG seed to be written on all cores
        "__seeds",
        # The RNG used with the seed that is passed in
        "__rng",
        # The partner selection rule
        "__partner_selection",
        # The formation rule
        "__formation",
        # The elimination rule
        "__elimination",
        "__with_replacement")

    def __init__(
            self, partner_selection: AbstractPartnerSelection,
            formation: AbstractFormation, elimination: AbstractElimination,
            timing_dependence: AbstractTimingDependence,
            weight_dependence: AbstractWeightDependence,
            voltage_dependence: None = None,
            dendritic_delay_fraction: float = 1.0,
            f_rew: float = DEFAULT_F_REW,
            initial_weight: float = DEFAULT_INITIAL_WEIGHT,
            initial_delay: InitialDelay = DEFAULT_INITIAL_DELAY,
            s_max: int = DEFAULT_S_MAX,
            with_replacement: bool = True, seed: Optional[int] = None,
            weight: _In_Types = StaticSynapse.default_parameters['weight'],
            delay: _In_Types = None,
            backprop_delay: bool = True):
        """
        :param AbstractPartnerSelection partner_selection:
            The partner selection rule
        :param AbstractFormation formation: The formation rule
        :param AbstractElimination elimination: The elimination rule
        :param AbstractTimingDependence timing_dependence:
            The STDP timing dependence rule
        :param AbstractWeightDependence weight_dependence:
            The STDP weight dependence rule
        :param None voltage_dependence:
            The STDP voltage dependence (unsupported)
        :param float dendritic_delay_fraction:
            The STDP dendritic delay fraction
        :param float 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 bool with_replacement:
            If set to True (default), a new synapse can be formed in a
            location where a connection already exists; if False, then it must
            form where no connection already exists
        :param seed: seed for the random number generators
        :type seed: int or None
        :param float weight: The weight of connections formed by the connector
        :param delay: The delay of connections formed by the connector
            Use ``None`` to get the simulator default minimum delay.
        :type delay: float or None
        :param bool backprop_delay: Whether back-propagated delays are used
        """
        super().__init__(
            timing_dependence, weight_dependence, voltage_dependence,
            dendritic_delay_fraction, weight, delay, pad_to_length=s_max,
            backprop_delay=backprop_delay)
        self.__partner_selection = partner_selection
        self.__formation = formation
        self.__elimination = elimination
        self.__f_rew = float(f_rew)
        self.__initial_weight = initial_weight
        self.__initial_delay = initial_delay
        self.__s_max = s_max
        self.__with_replacement = with_replacement
        self.__seed = seed
        self.__connections: ConnectionsInfo = dict()

        self.__rng = numpy.random.RandomState(seed)
        self.__seeds: Dict[object, Tuple[int, ...]] = dict()

    @overrides(AbstractPlasticSynapseDynamics.merge)
    def merge(self, synapse_dynamics: AbstractSynapseDynamics
              ) -> SynapseDynamicsStructuralSTDP:
        # If dynamics is Neuromodulation, merge with other neuromodulation,
        # and then return ourselves, as neuromodulation can't be used by
        # itself
        if isinstance(synapse_dynamics, SynapseDynamicsNeuromodulation):
            self._merge_neuromodulation(synapse_dynamics)
            return self
        # If other is structural, check structural matches
        if isinstance(synapse_dynamics, AbstractSynapseDynamicsStructural):
            if not SynapseDynamicsStructuralCommon.is_same_as(
                    self, synapse_dynamics):
                raise SynapticConfigurationException(
                    "Synapse dynamics must match exactly when using multiple"
                    " edges to the same population")
        # If other is STDP, check STDP matches
        if isinstance(synapse_dynamics, SynapseDynamicsSTDP):
            if not SynapseDynamicsSTDP.is_same_as(self, synapse_dynamics):
                raise SynapticConfigurationException(
                    "Synapse dynamics must match exactly when using multiple"
                    " edges to the same population")

        # If everything matches, return ourselves as supreme!
        return self

    def set_projection_parameter(self, param: str, value):
        """
        :param str param:
        :param value:
        """
        for item in (self.partner_selection, self.__formation,
                     self.__elimination):
            if hasattr(item, param):
                setattr(item, param, value)
                break
        else:
            raise ValueError(f"Unknown parameter {param}")

    @overrides(AbstractPlasticSynapseDynamics.is_same_as)
    @overrides(SynapseDynamicsStructuralCommon.is_same_as)
    def is_same_as(self, synapse_dynamics: Union[
            AbstractSynapseDynamics,
            AbstractSynapseDynamicsStructural]) -> bool:
        if not (isinstance(synapse_dynamics, SynapseDynamicsStructuralSTDP)):
            return False
        if not SynapseDynamicsSTDP.is_same_as(self, synapse_dynamics):
            return False
        return SynapseDynamicsStructuralCommon.is_same_as(
            self, synapse_dynamics)

    @overrides(SynapseDynamicsSTDP.get_vertex_executable_suffix)
    def get_vertex_executable_suffix(self) -> str:
        return (super().get_vertex_executable_suffix() +
                SynapseDynamicsStructuralCommon.get_vertex_executable_suffix(
                    self))

    @overrides(AbstractSynapseDynamicsStructural.set_connections)
    def set_connections(
            self, connections: ConnectionsArray, post_vertex_slice: Slice,
            app_edge: ProjectionApplicationEdge,
            synapse_info: SynapseInformation):
        if not isinstance(synapse_info.synapse_dynamics,
                          AbstractSynapseDynamicsStructural):
            return
        collector = self.__connections.setdefault(
            (app_edge.post_vertex, post_vertex_slice.lo_atom), [])
        collector.append((connections, app_edge, synapse_info))

    @overrides(AbstractPlasticSynapseDynamics.get_parameter_names)
    def get_parameter_names(self) -> Iterable[str]:
        yield from super().get_parameter_names()
        yield from SynapseDynamicsStructuralCommon.get_parameter_names(self)

    @property
    @overrides(AbstractSynapseDynamicsStructural.f_rew)
    def f_rew(self) -> float:
        return self.__f_rew

    @property
    @overrides(AbstractSynapseDynamicsStructural.s_max)
    def s_max(self) -> int:
        return self.__s_max

    @property
    @overrides(AbstractSynapseDynamicsStructural.with_replacement)
    def with_replacement(self) -> bool:
        return self.__with_replacement

    @property
    @overrides(AbstractSynapseDynamicsStructural.seed)
    def seed(self) -> Optional[int]:
        return self.__seed

    @property
    @overrides(AbstractSynapseDynamicsStructural.initial_weight)
    def initial_weight(self) -> float:
        return self.__initial_weight

    @property
    @overrides(AbstractSynapseDynamicsStructural.initial_delay)
    def initial_delay(self) -> InitialDelay:
        return self.__initial_delay

    @property
    @overrides(AbstractSynapseDynamicsStructural.partner_selection)
    def partner_selection(self) -> AbstractPartnerSelection:
        return self.__partner_selection

    @property
    @overrides(AbstractSynapseDynamicsStructural.formation)
    def formation(self) -> AbstractFormation:
        return self.__formation

    @property
    @overrides(AbstractSynapseDynamicsStructural.elimination)
    def elimination(self) -> AbstractElimination:
        return self.__elimination

    @property
    @overrides(SynapseDynamicsStructuralCommon.connections)
    def connections(self) -> ConnectionsInfo:
        return self.__connections

    @overrides(AbstractPlasticSynapseDynamics.get_weight_mean)
    def get_weight_mean(self, connector: AbstractConnector,
                        synapse_info: SynapseInformation) -> float:
        # Claim the mean is the maximum, a massive but safe overestimation
        return self.get_weight_maximum(connector, synapse_info)

    @overrides(AbstractPlasticSynapseDynamics.get_weight_maximum)
    def get_weight_maximum(
            self, connector: AbstractConnector,
            synapse_info: SynapseInformation) -> float:
        w_max = super().get_weight_maximum(connector, synapse_info)
        return max(w_max, self.__initial_weight)

    @overrides(SynapseDynamicsSTDP.get_delay_maximum)
    def get_delay_maximum(
            self, connector: AbstractConnector,
            synapse_info: SynapseInformation) -> Optional[float]:
        d_m = super().get_delay_maximum(connector, synapse_info)
        if d_m is None:
            return self.__initial_delay
        return max(d_m, self.__initial_delay)

    @overrides(SynapseDynamicsSTDP.get_delay_minimum)
    def get_delay_minimum(self, connector: AbstractConnector,
                          synapse_info: SynapseInformation) -> Optional[float]:
        d_m = super().get_delay_minimum(connector, synapse_info)
        if d_m is None:
            return self.__initial_delay
        return min(d_m, self.__initial_delay)

    @overrides(SynapseDynamicsSTDP.get_delay_variance)
    def get_delay_variance(
            self, connector: AbstractConnector, delays: numpy.ndarray,
            synapse_info: SynapseInformation) -> float:
        return 0.0

    @overrides(SynapseDynamicsStructuralCommon._get_seeds)
    def _get_seeds(
            self, app_vertex: Union[None, ApplicationVertex, Slice] = None
            ) -> Sequence[int]:
        if app_vertex:
            if app_vertex not in self.__seeds.keys():
                self.__seeds[app_vertex] = (
                    create_mars_kiss_seeds(self.__rng))
            return self.__seeds[app_vertex]
        else:
            return create_mars_kiss_seeds(self.__rng)

    @overrides(SynapseDynamicsSTDP.generate_on_machine)
    def generate_on_machine(self) -> bool:
        # Never generate structural connections on the machine
        return False

    @overrides(AbstractSynapseDynamics.get_connected_vertices)
    def get_connected_vertices(
            self, s_info: SynapseInformation,
            source_vertex: ApplicationVertex,
            target_vertex: ApplicationVertex) -> Sequence[
                Tuple[MachineVertex, Sequence[AbstractVertex]]]:
        # Things change, so assume all connected
        return [(m_vertex, [source_vertex])
                for m_vertex in target_vertex.splitter.get_in_coming_vertices(
                    SPIKE_PARTITION_ID)]

    @property
    @overrides(AbstractSynapseDynamics.is_combined_core_capable)
    def is_combined_core_capable(self) -> bool:
        return False

1	# Copyright (c) 2017 The University of Manchester
2	#
3	# Licensed under the Apache License, Version 2.0 (the "License");
4	# you may not use this file except in compliance with the License.
5	# You may obtain a copy of the License at
6	#
7	# https://www.apache.org/licenses/LICENSE-2.0
8	#
9	# Unless required by applicable law or agreed to in writing, software
10	# distributed under the License is distributed on an "AS IS" BASIS,
11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	# See the License for the specific language governing permissions and
13	# limitations under the License.
14	from __future__ import annotations	1✔
15	import numpy	1✔
16	from pyNN.standardmodels.synapses import StaticSynapse	1✔
17	from typing import (	1✔
18	Dict, Iterable, Optional, Sequence, Tuple, TYPE_CHECKING, Union)
19	from spinn_utilities.overrides import overrides	1✔
20	from pacman.model.graphs.application import ApplicationVertex	1✔
21	from spynnaker.pyNN.exceptions import SynapticConfigurationException	1✔
22	from spynnaker.pyNN.types import Weight_Delay_In_Types as _In_Types	1✔
23	from spynnaker.pyNN.utilities.utility_calls import create_mars_kiss_seeds	1✔
24	from .abstract_synapse_dynamics_structural import (	1✔
25	AbstractSynapseDynamicsStructural, InitialDelay)
26	from .synapse_dynamics_stdp import SynapseDynamicsSTDP	1✔
27	from .synapse_dynamics_structural_common import (	1✔
28	DEFAULT_F_REW, DEFAULT_INITIAL_WEIGHT, DEFAULT_INITIAL_DELAY,
29	DEFAULT_S_MAX, SynapseDynamicsStructuralCommon)
30	from .synapse_dynamics_neuromodulation import SynapseDynamicsNeuromodulation	1✔
31	from spynnaker.pyNN.utilities.constants import SPIKE_PARTITION_ID	1✔
32	from .abstract_synapse_dynamics import AbstractSynapseDynamics	1✔
33	from .abstract_plastic_synapse_dynamics import AbstractPlasticSynapseDynamics	1✔
34	if TYPE_CHECKING:
35	from pacman.model.graphs import AbstractVertex
36	from pacman.model.graphs.machine import MachineVertex
37	from pacman.model.graphs.common import Slice
38	from spynnaker.pyNN.models.neuron.structural_plasticity.synaptogenesis.\
39	partner_selection.abstract_partner_selection import \
40	AbstractPartnerSelection
41	from spynnaker.pyNN.models.neuron.structural_plasticity.synaptogenesis.\
42	formation.abstract_formation import AbstractFormation
43	from spynnaker.pyNN.models.neuron.structural_plasticity.synaptogenesis.\
44	elimination.abstract_elimination import AbstractElimination
45	from spynnaker.pyNN.models.neuron.plasticity.stdp.timing_dependence.\
46	abstract_timing_dependence import AbstractTimingDependence
47	from spynnaker.pyNN.models.neuron.plasticity.stdp.weight_dependence.\
48	abstract_weight_dependence import AbstractWeightDependence
49	from spynnaker.pyNN.models.neural_projections import (
50	ProjectionApplicationEdge, SynapseInformation)
51	from spynnaker.pyNN.models.neural_projections.connectors import (
52	AbstractConnector)
53	from spynnaker.pyNN.models.neuron.synapse_dynamics.types import (
54	ConnectionsArray)
55	from .synapse_dynamics_structural_common import ConnectionsInfo
56
57
58	class SynapseDynamicsStructuralSTDP(	1✔
59	SynapseDynamicsSTDP, SynapseDynamicsStructuralCommon):
60	"""
61	Class that enables synaptic rewiring in the presence of STDP.
62
63	It acts as a wrapper around SynapseDynamicsSTDP, meaning rewiring can
64	operate in parallel with STDP synapses.
65
66	Written by Petrut Bogdan.
67	"""
68	__slots__ = (	1✔
69	# Frequency of rewiring (Hz)
70	"__f_rew",
71	# Initial weight assigned to a newly formed connection
72	"__initial_weight",
73	# Delay assigned to a newly formed connection
74	"__initial_delay",
75	# Maximum fan-in per target layer neuron
76	"__s_max",
77	# The seed
78	"__seed",
79	# Holds initial connectivity as defined via connector
80	"__connections",
81	# The actual type of weights: static through the simulation or those
82	# that can be change through STDP
83	"__weight_dynamics",
84	# Shared RNG seed to be written on all cores
85	"__seeds",
86	# The RNG used with the seed that is passed in
87	"__rng",
88	# The partner selection rule
89	"__partner_selection",
90	# The formation rule
91	"__formation",
92	# The elimination rule
93	"__elimination",
94	"__with_replacement")
95
96	def __init__(	1✔
97	self, partner_selection: AbstractPartnerSelection,
98	formation: AbstractFormation, elimination: AbstractElimination,
99	timing_dependence: AbstractTimingDependence,
100	weight_dependence: AbstractWeightDependence,
101	voltage_dependence: None = None,
102	dendritic_delay_fraction: float = 1.0,
103	f_rew: float = DEFAULT_F_REW,
104	initial_weight: float = DEFAULT_INITIAL_WEIGHT,
105	initial_delay: InitialDelay = DEFAULT_INITIAL_DELAY,
106	s_max: int = DEFAULT_S_MAX,
107	with_replacement: bool = True, seed: Optional[int] = None,
108	weight: _In_Types = StaticSynapse.default_parameters['weight'],
109	delay: _In_Types = None,
110	backprop_delay: bool = True):
111	"""
112	:param AbstractPartnerSelection partner_selection:
113	The partner selection rule
114	:param AbstractFormation formation: The formation rule
115	:param AbstractElimination elimination: The elimination rule
116	:param AbstractTimingDependence timing_dependence:
117	The STDP timing dependence rule
118	:param AbstractWeightDependence weight_dependence:
119	The STDP weight dependence rule
120	:param None voltage_dependence:
121	The STDP voltage dependence (unsupported)
122	:param float dendritic_delay_fraction:
123	The STDP dendritic delay fraction
124	:param float f_rew:
125	How many rewiring attempts will be done per second.
126	:param float initial_weight:
127	Weight assigned to a newly formed connection
128	:param initial_delay:
129	Delay assigned to a newly formed connection; a single value means
130	a fixed delay value, or a tuple of two values means the delay will
131	be chosen at random from a uniform distribution between the given
132	values
133	:type initial_delay: float or tuple(float, float)
134	:param int s_max: Maximum fan-in per target layer neuron
135	:param bool with_replacement:
136	If set to True (default), a new synapse can be formed in a
137	location where a connection already exists; if False, then it must
138	form where no connection already exists
139	:param seed: seed for the random number generators
140	:type seed: int or None
141	:param float weight: The weight of connections formed by the connector
142	:param delay: The delay of connections formed by the connector
143	Use ``None`` to get the simulator default minimum delay.
144	:type delay: float or None
145	:param bool backprop_delay: Whether back-propagated delays are used
146	"""
147	super().__init__(	×
148	timing_dependence, weight_dependence, voltage_dependence,
149	dendritic_delay_fraction, weight, delay, pad_to_length=s_max,
150	backprop_delay=backprop_delay)
151	self.__partner_selection = partner_selection	×
152	self.__formation = formation	×
153	self.__elimination = elimination	×
154	self.__f_rew = float(f_rew)	×
155	self.__initial_weight = initial_weight	×
156	self.__initial_delay = initial_delay	×
157	self.__s_max = s_max	×
158	self.__with_replacement = with_replacement	×
159	self.__seed = seed	×
160	self.__connections: ConnectionsInfo = dict()	×
161
162	self.__rng = numpy.random.RandomState(seed)	×
163	self.__seeds: Dict[object, Tuple[int, ...]] = dict()	×
164
165	@overrides(AbstractPlasticSynapseDynamics.merge)	1✔
166	def merge(self, synapse_dynamics: AbstractSynapseDynamics	1✔
167	) -> SynapseDynamicsStructuralSTDP:
168	# If dynamics is Neuromodulation, merge with other neuromodulation,
169	# and then return ourselves, as neuromodulation can't be used by
170	# itself
171	if isinstance(synapse_dynamics, SynapseDynamicsNeuromodulation):	×
172	self._merge_neuromodulation(synapse_dynamics)	×
173	return self	×
174	# If other is structural, check structural matches
175	if isinstance(synapse_dynamics, AbstractSynapseDynamicsStructural):	×
176	if not SynapseDynamicsStructuralCommon.is_same_as(	×
177	self, synapse_dynamics):
178	raise SynapticConfigurationException(	×
179	"Synapse dynamics must match exactly when using multiple"
180	" edges to the same population")
181	# If other is STDP, check STDP matches
182	if isinstance(synapse_dynamics, SynapseDynamicsSTDP):	×
183	if not SynapseDynamicsSTDP.is_same_as(self, synapse_dynamics):	×
184	raise SynapticConfigurationException(	×
185	"Synapse dynamics must match exactly when using multiple"
186	" edges to the same population")
187
188	# If everything matches, return ourselves as supreme!
189	return self	×
190
191	def set_projection_parameter(self, param: str, value):	1✔
192	"""
193	:param str param:
194	:param value:
195	"""
196	for item in (self.partner_selection, self.__formation,	×
197	self.__elimination):
198	if hasattr(item, param):	×
199	setattr(item, param, value)	×
200	break	×
201	else:
202	raise ValueError(f"Unknown parameter {param}")	×
203
204	@overrides(AbstractPlasticSynapseDynamics.is_same_as)	1✔
205	@overrides(SynapseDynamicsStructuralCommon.is_same_as)	1✔
206	def is_same_as(self, synapse_dynamics: Union[	1✔
207	AbstractSynapseDynamics,
208	AbstractSynapseDynamicsStructural]) -> bool:
NEW 209	if not (isinstance(synapse_dynamics, SynapseDynamicsStructuralSTDP)):	×
NEW 210	return False	×
NEW 211	if not SynapseDynamicsSTDP.is_same_as(self, synapse_dynamics):	×
212	return False	×
213	return SynapseDynamicsStructuralCommon.is_same_as(	×
214	self, synapse_dynamics)
215
216	@overrides(SynapseDynamicsSTDP.get_vertex_executable_suffix)	1✔
217	def get_vertex_executable_suffix(self) -> str:	1✔
218	return (super().get_vertex_executable_suffix() +	×
219	SynapseDynamicsStructuralCommon.get_vertex_executable_suffix(
220	self))
221
222	@overrides(AbstractSynapseDynamicsStructural.set_connections)	1✔
223	def set_connections(	1✔
224	self, connections: ConnectionsArray, post_vertex_slice: Slice,
225	app_edge: ProjectionApplicationEdge,
226	synapse_info: SynapseInformation):
227	if not isinstance(synapse_info.synapse_dynamics,	×
228	AbstractSynapseDynamicsStructural):
229	return	×
230	collector = self.__connections.setdefault(	×
231	(app_edge.post_vertex, post_vertex_slice.lo_atom), [])
232	collector.append((connections, app_edge, synapse_info))	×
233
234	@overrides(AbstractPlasticSynapseDynamics.get_parameter_names)	1✔
235	def get_parameter_names(self) -> Iterable[str]:	1✔
236	yield from super().get_parameter_names()	×
237	yield from SynapseDynamicsStructuralCommon.get_parameter_names(self)	×
238
239	@property	1✔
240	@overrides(AbstractSynapseDynamicsStructural.f_rew)	1✔
241	def f_rew(self) -> float:	1✔
242	return self.__f_rew	×
243
244	@property	1✔
245	@overrides(AbstractSynapseDynamicsStructural.s_max)	1✔
246	def s_max(self) -> int:	1✔
247	return self.__s_max	×
248
249	@property	1✔
250	@overrides(AbstractSynapseDynamicsStructural.with_replacement)	1✔
251	def with_replacement(self) -> bool:	1✔
252	return self.__with_replacement	×
253
254	@property	1✔
255	@overrides(AbstractSynapseDynamicsStructural.seed)	1✔
256	def seed(self) -> Optional[int]:	1✔
257	return self.__seed	×
258
259	@property	1✔
260	@overrides(AbstractSynapseDynamicsStructural.initial_weight)	1✔
261	def initial_weight(self) -> float:	1✔
262	return self.__initial_weight	×
263
264	@property	1✔
265	@overrides(AbstractSynapseDynamicsStructural.initial_delay)	1✔
266	def initial_delay(self) -> InitialDelay:	1✔
267	return self.__initial_delay	×
268
269	@property	1✔
270	@overrides(AbstractSynapseDynamicsStructural.partner_selection)	1✔
271	def partner_selection(self) -> AbstractPartnerSelection:	1✔
272	return self.__partner_selection	×
273
274	@property	1✔
275	@overrides(AbstractSynapseDynamicsStructural.formation)	1✔
276	def formation(self) -> AbstractFormation:	1✔
277	return self.__formation	×
278
279	@property	1✔
280	@overrides(AbstractSynapseDynamicsStructural.elimination)	1✔
281	def elimination(self) -> AbstractElimination:	1✔
282	return self.__elimination	×
283
284	@property	1✔
285	@overrides(SynapseDynamicsStructuralCommon.connections)	1✔
286	def connections(self) -> ConnectionsInfo:	1✔
287	return self.__connections	×
288
289	@overrides(AbstractPlasticSynapseDynamics.get_weight_mean)	1✔
290	def get_weight_mean(self, connector: AbstractConnector,	1✔
291	synapse_info: SynapseInformation) -> float:
292	# Claim the mean is the maximum, a massive but safe overestimation
293	return self.get_weight_maximum(connector, synapse_info)	×
294
295	@overrides(AbstractPlasticSynapseDynamics.get_weight_maximum)	1✔
296	def get_weight_maximum(	1✔
297	self, connector: AbstractConnector,
298	synapse_info: SynapseInformation) -> float:
299	w_max = super().get_weight_maximum(connector, synapse_info)	×
300	return max(w_max, self.__initial_weight)	×
301
302	@overrides(SynapseDynamicsSTDP.get_delay_maximum)	1✔
303	def get_delay_maximum(	1✔
304	self, connector: AbstractConnector,
305	synapse_info: SynapseInformation) -> Optional[float]:
306	d_m = super().get_delay_maximum(connector, synapse_info)	×
307	if d_m is None:	×
308	return self.__initial_delay	×
309	return max(d_m, self.__initial_delay)	×
310
311	@overrides(SynapseDynamicsSTDP.get_delay_minimum)	1✔
312	def get_delay_minimum(self, connector: AbstractConnector,	1✔
313	synapse_info: SynapseInformation) -> Optional[float]:
314	d_m = super().get_delay_minimum(connector, synapse_info)	×
315	if d_m is None:	×
316	return self.__initial_delay	×
317	return min(d_m, self.__initial_delay)	×
318
319	@overrides(SynapseDynamicsSTDP.get_delay_variance)	1✔
320	def get_delay_variance(	1✔
321	self, connector: AbstractConnector, delays: numpy.ndarray,
322	synapse_info: SynapseInformation) -> float:
UNCOV 323	return 0.0	×
324
325	@overrides(SynapseDynamicsStructuralCommon._get_seeds)	1✔
326	def _get_seeds(	1✔
327	self, app_vertex: Union[None, ApplicationVertex, Slice] = None
328	) -> Sequence[int]:
329	if app_vertex:	×
330	if app_vertex not in self.__seeds.keys():	×
331	self.__seeds[app_vertex] = (	×
332	create_mars_kiss_seeds(self.__rng))
333	return self.__seeds[app_vertex]	×
334	else:
335	return create_mars_kiss_seeds(self.__rng)	×
336
337	@overrides(SynapseDynamicsSTDP.generate_on_machine)	1✔
338	def generate_on_machine(self) -> bool:	1✔
339	# Never generate structural connections on the machine
340	return False	×
341
342	@overrides(AbstractSynapseDynamics.get_connected_vertices)	1✔
343	def get_connected_vertices(	1✔
344	self, s_info: SynapseInformation,
345	source_vertex: ApplicationVertex,
346	target_vertex: ApplicationVertex) -> Sequence[
347	Tuple[MachineVertex, Sequence[AbstractVertex]]]:
348	# Things change, so assume all connected
349	return [(m_vertex, [source_vertex])	×
350	for m_vertex in target_vertex.splitter.get_in_coming_vertices(
351	SPIKE_PARTITION_ID)]
352
353	@property	1✔
354	@overrides(AbstractSynapseDynamics.is_combined_core_capable)	1✔
355	def is_combined_core_capable(self) -> bool:	1✔
356	return False	×

SpiNNakerManchester / sPyNNaker / 7288977951

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous