Пример #1
0
    def __init__(self, pre, post, target, window=0.0):
        """
        *Parameters*:
                
            * **pre**: pre-synaptic population.
            * **post**: post-synaptic population.
            * **target**: type of the connection.
            * **window**: duration of the time window to collect spikes (default: dt).
        """
        Projection.__init__(self, pre, post, target, None)
        # Check populations
        if not self.pre.neuron_type.type == 'spike':
            Global._error(
                'The pre-synaptic population of a DecodingProjection must be spiking.'
            )
            exit(0)
        if not self.post.neuron_type.type == 'rate':
            Global._error(
                'The post-synaptic population of a DecodingProjection must be rate-coded.'
            )
            exit(0)

        # Process window argument
        if window == 0.0:
            window = Global.config['dt']
        self.window = window
Пример #2
0
    def __init__(self,
                 pre,
                 post,
                 target,
                 psp="pre.r * w",
                 operation="sum",
                 name=None,
                 copied=False):
        """
        :param pre: pre-synaptic population (either its name or a ``Population`` object).
        :param post: post-synaptic population (either its name or a ``Population`` object).
        :param target: type of the connection
        :param psp: continuous influence of a single synapse on the post-synaptic neuron (default for rate-coded: ``w*pre.r``).
        :param operation: operation (sum, max, min, mean) performed by the kernel (default: sum).
        """

        # Create the description, but it will not be used for generation
        Projection.__init__(self,
                            pre=pre,
                            post=post,
                            target=target,
                            synapse=SharedSynapse(psp=psp,
                                                  operation=operation),
                            name=name,
                            copied=copied)
Пример #3
0
    def __init__(self, pre, post, target, psp="w * pre.r", operation="sum"):
        """
        Projection based on shared weights: each post-synaptic neuron uses the same weights, so they need to be instantiated only once to save memory.

        Learning is not possible for now. The ``synapse`` argument is removed, replaced by a single ``psp`` argument to modified what is summed and ``operation`` to replace the summation operation by max-pooling or similar..

        *Parameters*:

            * **pre**: pre-synaptic population (either its name or a ``Population`` object).
            * **post**: post-synaptic population (either its name or a ``Population`` object).
            * **target**: type of the connection.
            * **psp**: function to be summed. By default: ``w * pre.r``
            * **operation**: function applied on ``psp`` ("sum", "max", "min", "mean"). "sum" is the default.
        """
        # Create the description, but it will not be used for generation
        Projection.__init__(
            self,
            pre,
            post,
            target,
            synapse = SharedSynapse(psp=psp, operation=operation)
        )

        self._omp_config['psp_schedule'] = 'schedule(dynamic)'
        if not Global.config["paradigm"] == "openmp":
            Global._error('Weight sharing is only implemented for the OpenMP paradigm.')
            exit(0)

        if not pre.neuron_type.type == 'rate':
            Global._error('Weight sharing is only implemented for rate-coded populations.')
            exit(0)
Пример #4
0
 def __init__(self, pre, post, target, name=None, copied=False):
     """
     :param pre: pre-synaptic population (either its name or a ``Population`` object).
     :param post: post-synaptic population (either its name or a ``Population`` object).
     :param target: type of the connection.
     """
     # Create the description, but it will not be used for generation
     Projection.__init__(self, pre, post, target, name=name, copied=copied)
Пример #5
0
 def __init__(self, pre, post, target):
     """
     *Parameters*:
             
         * **pre**: pre-synaptic population (either its name or a ``Population`` object).
         * **post**: post-synaptic population (either its name or a ``Population`` object).
         * **target**: type of the connection.
     """
     # Create the description, but it will not be used for generation
     Projection.__init__(self, pre, post, target)
Пример #6
0
    def __init__(self,
                 pre,
                 post,
                 target,
                 operation="max",
                 name=None,
                 copied=False):
        """
        :param pre: pre-synaptic population (either its name or a ``Population`` object).
        :param post: post-synaptic population (either its name or a ``Population`` object).
        :param target: type of the connection
        :param operation: pooling function to be applied ("max", "min", "mean")
        """
        if not operation in ["max", "mean", "min"]:
            Global._error(
                "Pooling: the operation must be either 'max', 'mean' or 'min'."
            )
        self.operation = operation

        Projection.__init__(
            self,
            pre,
            post,
            target,
            synapse=SharedSynapse(
                psp="pre.r",
                operation=operation,
                name="Pooling operation",
                description=operation +
                "-pooling operation over the pre-synaptic population."),
            name=name,
            copied=copied)

        if not pre.neuron_type.type == 'rate':
            Global._error(
                'Pooling: only implemented for rate-coded populations.')

        # check dimensions of populations, should not exceed 4
        self.dim_pre = self.pre.dimension
        self.dim_post = self.post.dimension
        if self.dim_post > 4:
            Global._error(
                'Pooling: Too many dimensions for the post-synaptic population (maximum 4).'
            )
        if self.dim_pre > 4:
            Global._error(
                'Pooling: Too many dimensions for the pre-synaptic population (maximum 4).'
            )

        # Disable saving
        self._saveable = False
Пример #7
0
 def __init__(self, pre, post, target):
     """
     *Parameters*:
             
         * **pre**: pre-synaptic population (either its name or a ``Population`` object).
         * **post**: post-synaptic population (either its name or a ``Population`` object).
         * **target**: type of the connection.
     """
     # Create the description, but it will not be used for generation
     Projection.__init__(
         self, 
         pre,
         post,
         target
     )
Пример #8
0
    def __init__(self,
                 pre,
                 post,
                 target,
                 synapse=None,
                 name=None,
                 copied=False):
        """
        Initialization, receive parameters of Projection objects.

        :param pre: pre-synaptic population.
        :param post: post-synaptic population.
        :param target: type of the connection.
        :param window: duration of the time window to collect spikes (default: dt).
        """
        Projection.__init__(self,
                            pre=pre,
                            post=post,
                            target=target,
                            synapse=synapse,
                            name=name,
                            copied=copied)
Пример #9
0
    def __init__(self, pre, post, target, window=0.0):
        """
        *Parameters*:
                
            * **pre**: pre-synaptic population.
            * **post**: post-synaptic population.
            * **target**: type of the connection.
            * **window**: duration of the time window to collect spikes (default: dt).
        """
        Projection.__init__(self, pre, post, target, None)
        # Check populations
        if not self.pre.neuron_type.type == 'spike':
            Global._error('The pre-synaptic population of a DecodingProjection must be spiking.')
            exit(0)
        if not self.post.neuron_type.type == 'rate':
            Global._error('The post-synaptic population of a DecodingProjection must be rate-coded.')
            exit(0)

        # Process window argument
        if window == 0.0:
            window = Global.config['dt']
        self.window = window
Пример #10
0
    def __init__(self,
                 pre,
                 post,
                 target,
                 psp="pre.r * w",
                 operation="sum",
                 name=None,
                 copied=False):
        """
        :param pre: pre-synaptic population (either its name or a ``Population`` object).
        :param post: post-synaptic population (either its name or a ``Population`` object).
        :param target: type of the connection
        :param psp: continuous influence of a single synapse on the post-synaptic neuron (default for rate-coded: ``w*pre.r``).
        :param operation: operation (sum, max, min, mean) performed by the kernel (default: sum).
        """

        # Create the description, but it will not be used for generation
        Projection.__init__(
            self,
            pre,
            post,
            target,
            synapse=SharedSynapse(
                psp=psp,
                operation=operation,
                name="Convolution operation",
                description=
                "Convoluted kernel over the pre-synaptic population."),
            name=name,
            copied=copied)

        # Disable saving
        self._saveable = False

        # For copy
        self._used_single_filter = False
        self._used_bank_of_filters = False
        self.operation = operation
Пример #11
0
    def __init__(self, proj, target):
        """
        :param proj: original projection
        :param target: type of the connection (can differ from the original one)
        """
        # Transpose is not intended for hybrid projections
        if proj.pre.neuron_type.type == "rate" and proj.post.neuron_type.type == "rate":
            Projection.__init__(self,
                                pre=proj.post,
                                post=proj.pre,
                                target=target,
                                synapse=DefaultRateCodedSynapse)
        elif proj.pre.neuron_type.type == "spike" and proj.post.neuron_type.type == "spike":
            Projection.__init__(self,
                                pre=proj.post,
                                post=proj.pre,
                                target=target,
                                synapse=DefaultSpikingSynapse)
        else:
            Global._error(
                'TransposeProjection are not applyable on hybrid projections ...'
            )

        # in the code generation we directly access properties of the
        # forward projection. Therefore we store the link here to have access in
        # self._generate()
        self.fwd_proj = proj

        if (proj._connection_delay > 0.0):
            Global._error(
                'TransposeProjection can not be applied on delayed projections yet ...'
            )

        # simply copy from the forward view
        self.delays = proj._connection_delay
        self.max_delay = proj.max_delay
        self.uniform_delay = proj.uniform_delay
Пример #12
0
    def __init__(self,
                 pre,
                 post,
                 target,
                 operation="max",
                 extent=None,
                 delays=0.0,
                 name=None,
                 copied=False):
        """
        :param pre: pre-synaptic population (either its name or a ``Population`` object).
        :param post: post-synaptic population (either its name or a ``Population`` object).
        :param target: type of the connection
        :param operation: pooling function to be applied ("max", "min", "mean")
        :param extent: extent of the pooling area expressed in the geometry of the pre-synaptic population. In each
                       dimension, the product of this extent with the number of neurons in the post-synaptic population
                       must be equal to the number of pre-synaptic neurons.
        :param delays: synaptic delay in ms
        """
        self.operation = operation

        Projection.__init__(self,
                            pre,
                            post,
                            target,
                            synapse=SharedSynapse(psp="pre.r",
                                                  operation=operation),
                            name=name,
                            copied=copied)

        if not pre.neuron_type.type == 'rate':
            Global._error(
                'SharedProjection: Weight sharing is only implemented for rate-coded populations.'
            )

        # process extent
        self.extent_init = extent
        if extent is None:  # compute the extent automatically
            if self.pre.dimension != self.post.dimension:
                Global._error(
                    'PoolingProjection: If you do not provide the extent parameter, the two populations must have the same dimensions.'
                )

            extent = list(self.pre.geometry)
            for dim in range(self.pre.dimension):
                extent[dim] /= self.post.geometry[dim]
                if self.pre.geometry[
                        dim] != extent[dim] * self.post.geometry[dim]:
                    Global._error(
                        'PoolingProjection: Unable to compute the extent of the pooling area: the number of neurons do not match.'
                    )

        elif not isinstance(extent, tuple):
            Global._error(
                'SharedProjection: You must provide a tuple for the extent of the pooling operation.'
            )

        self.extent = list(extent)
        if len(self.extent) < self.pre.dimension:
            Global._error(
                'SharedProjection: You must provide a tuple for the extent of the pooling operation.'
            )

        # process delays
        self.delays = delays

        # check dimensions of populations, should not exceed 4
        self.dim_pre = self.pre.dimension
        self.dim_post = self.post.dimension
        if self.dim_post > 4:
            Global._error(
                'SharedProjection: Too many dimensions for the post-synaptic population (maximum 4).'
            )
        if self.dim_pre > 4:
            Global._error(
                'SharedProjection: Too many dimensions for the pre-synaptic population (maximum 4).'
            )

        # Disable saving
        self._saveable = False

        # create fake LIL
        self._create()

        # Generate the pre-synaptic coordinates
        self._generate_extent_coordinates()
Пример #13
0
    def __init__(self, pre, post, target, operation="max", extent=None, delays=0.0, name=None, copied=False):
        """
        :param pre: pre-synaptic population (either its name or a ``Population`` object).
        :param post: post-synaptic population (either its name or a ``Population`` object).
        :param target: type of the connection
        :param operation: pooling function to be applied ("max", "min", "mean")
        :param extent: extent of the pooling area expressed in the geometry of the pre-synaptic population. In each
                       dimension, the product of this extent with the number of neurons in the post-synaptic population
                       must be equal to the number of pre-synaptic neurons.
        :param delays: synaptic delay in ms
        """
        self.operation = operation

        Projection.__init__(
            self,
            pre,
            post,
            target,
            synapse=SharedSynapse(psp="pre.r", operation=operation),
            name=name,
            copied=copied
        )

        if not pre.neuron_type.type == 'rate':
            Global._error('SharedProjection: Weight sharing is only implemented for rate-coded populations.')

        # process extent
        self.extent_init = extent
        if extent is None:  # compute the extent automatically
            if self.pre.dimension != self.post.dimension:
                Global._error(
                    'PoolingProjection: If you do not provide the extent parameter, the two populations must have the same dimensions.')

            extent = list(self.pre.geometry)
            for dim in range(self.pre.dimension):
                extent[dim] /= self.post.geometry[dim]
                if self.pre.geometry[dim] != extent[dim] * self.post.geometry[dim]:
                    Global._error(
                        'PoolingProjection: Unable to compute the extent of the pooling area: the number of neurons do not match.')

        elif not isinstance(extent, tuple):
            Global._error('SharedProjection: You must provide a tuple for the extent of the pooling operation.')

        self.extent = list(extent)
        if len(self.extent) < self.pre.dimension:
            Global._error('SharedProjection: You must provide a tuple for the extent of the pooling operation.')

        # process delays
        self.delays = delays

        # check dimensions of populations, should not exceed 4
        self.dim_pre = self.pre.dimension
        self.dim_post = self.post.dimension
        if self.dim_post > 4:
            Global._error('SharedProjection: Too many dimensions for the post-synaptic population (maximum 4).')
        if self.dim_pre > 4:
            Global._error('SharedProjection: Too many dimensions for the pre-synaptic population (maximum 4).')

        # Disable saving
        self._saveable = False

        # create fake LIL
        self._create()

        # Generate the pre-synaptic coordinates
        self._generate_extent_coordinates()