Ejemplo n.º 1
0
 def saveConnections(self, file, gather=True, compatible_output=True):
     """
     Save connections to file in a format suitable for reading in with a
     FromFileConnector.
     """
     
     if isinstance(file, basestring):
         file = files.StandardTextFile(file, mode='w')
     
     lines = []
     if not compatible_output:
         for c in self.connections:
             lines.append([c.source, c.target, c.weight, c.delay])
     else:
         for c in self.connections: 
             lines.append([self.pre.id_to_index(c.source), self.post.id_to_index(c.target), c.weight, c.delay])
     
     if gather == True and self._simulator.state.num_processes > 1:
         all_lines = { self._simulator.state.mpi_rank: lines }
         all_lines = recording.gather_dict(all_lines)
         if self._simulator.state.mpi_rank == 0:
             lines = reduce(operator.add, all_lines.values())
     elif self._simulator.state.num_processes > 1:
         file.rename('%s.%d' % (file.name, self._simulator.state.mpi_rank))
     
     logger.debug("--- Projection[%s].__saveConnections__() ---" % self.label)
     
     if gather == False or self._simulator.state.mpi_rank == 0:
         file.write(lines, {'pre' : self.pre.label, 'post' : self.post.label})
         file.close()
Ejemplo n.º 2
0
    def saveConnections(self, file, gather=True, compatible_output=True):
        """
        Save connections to file in a format suitable for reading in with a
        FromFileConnector.
        """

        if isinstance(file, basestring):
            file = files.StandardTextFile(file, mode='w')

        lines = []
        if not compatible_output:
            for c in self.connections:
                lines.append([c.source, c.target, c.weight, c.delay])
        else:
            for c in self.connections:
                lines.append([
                    self.pre.id_to_index(c.source),
                    self.post.id_to_index(c.target), c.weight, c.delay
                ])

        if gather == True and self._simulator.state.num_processes > 1:
            all_lines = {self._simulator.state.mpi_rank: lines}
            all_lines = recording.gather_dict(all_lines)
            if self._simulator.state.mpi_rank == 0:
                lines = reduce(operator.add, all_lines.values())
        elif self._simulator.state.num_processes > 1:
            file.rename('%s.%d' % (file.name, self._simulator.state.mpi_rank))

        logger.debug("--- Projection[%s].__saveConnections__() ---" %
                     self.label)

        if gather == False or self._simulator.state.mpi_rank == 0:
            file.write(lines, {'pre': self.pre.label, 'post': self.post.label})
            file.close()
Ejemplo n.º 3
0
    def saveConnections(self, file, gather=True, compatible_output=True):
        """
        Save connections to file in a format suitable for reading in with a
        FromFileConnector.
        """
        import operator

        if isinstance(file, basestring):
            file = files.StandardTextFile(file, mode='w')

        lines = nest.GetStatus(self.connections,
                               ('source', 'target', 'weight', 'delay'))

        if gather == True and num_processes() > 1:
            all_lines = {rank(): lines}
            all_lines = recording.gather_dict(all_lines)
            if rank() == 0:
                lines = reduce(operator.add, all_lines.values())
        elif num_processes() > 1:
            file.rename('%s.%d' % (file.name, rank()))
        logger.debug("--- Projection[%s].__saveConnections__() ---" %
                     self.label)

        if gather == False or rank() == 0:
            lines = numpy.array(lines, dtype=float)
            lines[:, 2] *= 0.001
            if compatible_output:
                lines[:, 0] = self.pre.id_to_index(lines[:, 0])
                lines[:, 1] = self.post.id_to_index(lines[:, 1])
            file.write(lines, {'pre': self.pre.label, 'post': self.post.label})
            file.close()
Ejemplo n.º 4
0
 def saveConnections(self, file, gather=True, compatible_output=True):
     """
     Save connections to file in a format suitable for reading in with a
     FromFileConnector.
     """
     import operator
     
     if isinstance(file, basestring):
         file = files.StandardTextFile(file, mode='w')
     
     lines   = nest.GetStatus(self.connections, ('source', 'target', 'weight', 'delay'))  
     
     if gather == True and num_processes() > 1:
         all_lines = { rank(): lines }
         all_lines = recording.gather_dict(all_lines)
         if rank() == 0:
             lines = reduce(operator.add, all_lines.values())
     elif num_processes() > 1:
         file.rename('%s.%d' % (file.name, rank()))
     logger.debug("--- Projection[%s].__saveConnections__() ---" % self.label)
             
     if gather == False or rank() == 0:
         lines       = numpy.array(lines, dtype=float)
         lines[:,2] *= 0.001
         if compatible_output:
             lines[:,0] = self.pre.id_to_index(lines[:,0])
             lines[:,1] = self.post.id_to_index(lines[:,1])  
         file.write(lines, {'pre' : self.pre.label, 'post' : self.post.label})
         file.close()        
Ejemplo n.º 5
0
 def count(self, gather=False, filter=None):
     """
     Return the number of data points for each cell, as a dict. This is mainly
     useful for spike counts or for variable-time-step integration methods.
     """
     N = {}
     if self.variable == 'spikes':
         for id in self.filter_recorded(filter):
             N[id] = simulator.net.object(self.recorders[id]).spikeCount()
     else:
         raise Exception("Only implemented for spikes.")
     if gather and simulator.state.num_processes > 1:
         N = recording.gather_dict(N)
     return N
Ejemplo n.º 6
0
    def get(self, attribute_names, format, gather=True, with_address=True):
        """
        Get the values of a given attribute (weight or delay) for all
        connections in this Projection.

        `attribute_names`:
            name of the attributes whose values are wanted, or a list of such
            names.
        `format`:
            "list" or "array".

        With list format, returns a list of tuples. Each tuple contains the
        indices of the pre- and post-synaptic cell followed by the attribute
        values in the order given in `attribute_names`. Example::

            >>> prj.get(["weight", "delay"], format="list")[:5]
            [(TODO)]

        With array format, returns a tuple of 2D NumPy arrays, one for each
        name in `attribute_names`. The array element X_ij contains the
        attribute value for the connection from the ith neuron in the pre-
        synaptic Population to the jth neuron in the post-synaptic Population,
        if a single such connection exists. If there are no such connections,
        X_ij will be NaN. If there are multiple such connections, the summed
        value will be given, which makes some sense for weights, but is
        pretty meaningless for delays. Example::

            >>> weights, delays = prj.get(["weight", "delay"], format="array")
            >>> weights.shape
            TODO

        TODO: document "with_address"

        Values will be expressed in the standard PyNN units (i.e. millivolts,
        nanoamps, milliseconds, microsiemens, nanofarads, event per second).
        """
        if isinstance(attribute_names, basestring):
            attribute_names = (attribute_names,)
            return_single = True
        else:
            return_single = False
        if isinstance(self.synapse_type, StandardSynapseType):
            attribute_names = self.synapse_type.get_native_names(*attribute_names)
        if format == 'list':
            names = list(attribute_names)
            if with_address:
                names = ["presynaptic_index", "postsynaptic_index"] + names
            values = self._get_attributes_as_list(*names)
            if gather and self._simulator.state.num_processes > 1:
                all_values = {self._simulator.state.mpi_rank: values}
                all_values = recording.gather_dict(all_values, all=(gather == 'all'))
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    values = reduce(operator.add, all_values.values())
            if not with_address and return_single:
                values = [val[0] for val in values]
            return values
        elif format == 'array':
            if gather and self._simulator.state.num_processes > 1:
                # Node 0 is the only one creating a full connection matrix, and returning it (saving memory)
                # Slaves nodes are returning list of connections, so this may be inconsistent...
                names = list(attribute_names)
                names = ["presynaptic_index", "postsynaptic_index"] + names
                values = self._get_attributes_as_list(*names)
                all_values = {self._simulator.state.mpi_rank: values}
                all_values = recording.gather_dict(all_values, all=(gather == 'all'))
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    tmp_values = reduce(operator.add, all_values.values())
                    values = self._get_attributes_as_arrays(*attribute_names)
                    tmp_values = numpy.array(tmp_values)
                    for i in xrange(len(values)):
                        values[i][tmp_values[:, 0].astype(int), tmp_values[:, 1].astype(int)] = tmp_values[:, 2 + i]
            else:
                values = self._get_attributes_as_arrays(*attribute_names)
            if return_single:
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    assert len(values) == 1, values
                return values[0]
            else:
                return values
        else:
            raise Exception("format must be 'list' or 'array'")
Ejemplo n.º 7
0
    def get(self,
            attribute_names,
            format,
            gather=True,
            with_address=True,
            multiple_synapses='sum'):
        """
        Get the values of a given attribute (weight or delay) for all
        connections in this Projection.

        `attribute_names`:
            name of the attributes whose values are wanted, or a list of such
            names.
        `format`:
            "list" or "array".
        `gather`:
            if True, get connection information from all MPI nodes, otherwise
            only from connections that exist in this node.

        With list format, returns a list of tuples. By default, each tuple
        contains the indices of the pre- and post-synaptic cell followed by
        the attribute values in the order given in `attribute_names`.
        Example::

            >>> prj.get(["weight", "delay"], format="list")[:5]
            [(0.0, 0.0, 0.3401892507507171, 0.1),
             (0.0, 1.0, 0.7990713166233654, 0.30000000000000004),
             (0.0, 2.0, 0.6180841812877726, 0.5),
             (0.0, 3.0, 0.6758149775627305, 0.7000000000000001),
             (0.0, 4.0, 0.7166906726862953, 0.9)]

        If `with_address` is set to False, then the tuples will contain only the
        attribute values, not the cell indices.

        With array format, returns a tuple of 2D NumPy arrays, one for each
        name in `attribute_names`. The array element X_ij contains the
        attribute value for the connection from the ith neuron in the pre-
        synaptic Population to the jth neuron in the post-synaptic Population,
        if a single such connection exists. If there are no such connections,
        X_ij will be NaN. Example::

            >>> weights, delays = prj.get(["weight", "delay"], format="array")
            >>> weights
            array([[ 0.66210438,         nan,  0.10744555,  0.54557088],
                   [ 0.3676134 ,         nan,  0.41463193,         nan],
                   [ 0.57434871,  0.4329354 ,  0.58482943,  0.42863916]])

        If there are multiple such connections, the action to take is
        controlled by the `multiple_synapses` argument, which must be one of
        {'last', 'first', 'sum', 'min', 'max'}.

        Values will be expressed in the standard PyNN units (i.e. millivolts,
        nanoamps, milliseconds, microsiemens, nanofarads, event per second).
        """
        if isinstance(attribute_names, basestring):
            attribute_names = (attribute_names, )
            return_single = True
        else:
            return_single = False
        if isinstance(self.synapse_type, StandardSynapseType):
            attribute_names = self.synapse_type.get_native_names(
                *attribute_names)
        if format == 'list':
            names = list(attribute_names)
            if with_address:
                names = ["presynaptic_index", "postsynaptic_index"] + names
            values = self._get_attributes_as_list(names)
            if gather and self._simulator.state.num_processes > 1:
                all_values = {self._simulator.state.mpi_rank: values}
                all_values = recording.gather_dict(all_values,
                                                   all=(gather == 'all'))
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    values = reduce(operator.add, all_values.values())
            if not with_address and return_single:
                values = [val[0] for val in values]
            return values
        elif format == 'array':
            if multiple_synapses not in Projection.MULTI_SYNAPSE_OPERATIONS:
                raise ValueError(
                    "`multiple_synapses` argument must be one of {}".format(
                        list(Projection.MULTI_SYNAPSE_OPERATIONS)))
            if gather and self._simulator.state.num_processes > 1:
                # Node 0 is the only one creating a full connection matrix, and returning it (saving memory)
                # Slaves nodes are returning list of connections, so this may be inconsistent...
                names = list(attribute_names)
                names = ["presynaptic_index", "postsynaptic_index"] + names
                values = self._get_attributes_as_list(names)
                all_values = {self._simulator.state.mpi_rank: values}
                all_values = recording.gather_dict(all_values,
                                                   all=(gather == 'all'))
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    tmp_values = reduce(operator.add, all_values.values())
                    values = self._get_attributes_as_arrays(
                        attribute_names, multiple_synapses=multiple_synapses)
                    tmp_values = numpy.array(tmp_values)
                    for i in xrange(len(values)):
                        values[i][tmp_values[:, 0].astype(int),
                                  tmp_values[:,
                                             1].astype(int)] = tmp_values[:,
                                                                          2 +
                                                                          i]
            else:
                values = self._get_attributes_as_arrays(
                    attribute_names, multiple_synapses=multiple_synapses)
            if return_single:
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    assert len(values) == 1, values
                return values[0]
            else:
                return values
        else:
            raise Exception("format must be 'list' or 'array'")
Ejemplo n.º 8
0
    def get(self, attribute_names, format, gather=True, with_address=True,
            multiple_synapses='sum'):
        """
        Get the values of a given attribute (weight or delay) for all
        connections in this Projection.

        `attribute_names`:
            name of the attributes whose values are wanted, or a list of such
            names.
        `format`:
            "list" or "array".
        `gather`:
            if True, get connection information from all MPI nodes, otherwise
            only from connections that exist in this node.

        With list format, returns a list of tuples. By default, each tuple
        contains the indices of the pre- and post-synaptic cell followed by
        the attribute values in the order given in `attribute_names`.
        Example::

            >>> prj.get(["weight", "delay"], format="list")[:5]
            [(0.0, 0.0, 0.3401892507507171, 0.1),
             (0.0, 1.0, 0.7990713166233654, 0.30000000000000004),
             (0.0, 2.0, 0.6180841812877726, 0.5),
             (0.0, 3.0, 0.6758149775627305, 0.7000000000000001),
             (0.0, 4.0, 0.7166906726862953, 0.9)]

        If `with_address` is set to False, then the tuples will contain only the
        attribute values, not the cell indices.

        With array format, returns a tuple of 2D NumPy arrays, one for each
        name in `attribute_names`. The array element X_ij contains the
        attribute value for the connection from the ith neuron in the pre-
        synaptic Population to the jth neuron in the post-synaptic Population,
        if a single such connection exists. If there are no such connections,
        X_ij will be NaN. Example::

            >>> weights, delays = prj.get(["weight", "delay"], format="array")
            >>> weights
            array([[ 0.66210438,         nan,  0.10744555,  0.54557088],
                   [ 0.3676134 ,         nan,  0.41463193,         nan],
                   [ 0.57434871,  0.4329354 ,  0.58482943,  0.42863916]])

        If there are multiple such connections, the action to take is
        controlled by the `multiple_synapses` argument, which must be one of
        {'last', 'first', 'sum', 'min', 'max'}.

        Values will be expressed in the standard PyNN units (i.e. millivolts,
        nanoamps, milliseconds, microsiemens, nanofarads, event per second).
        """
        if isinstance(attribute_names, basestring):
            attribute_names = (attribute_names,)
            return_single = True
        else:
            return_single = False
        if isinstance(self.synapse_type, StandardSynapseType):
            attribute_names = self.synapse_type.get_native_names(*attribute_names)
        if format == 'list':
            names = list(attribute_names)
            if with_address:
                names = ["presynaptic_index", "postsynaptic_index"] + names
            values = self._get_attributes_as_list(names)
            if gather and self._simulator.state.num_processes > 1:
                all_values = {self._simulator.state.mpi_rank: values}
                all_values = recording.gather_dict(all_values, all=(gather == 'all'))
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    values = reduce(operator.add, all_values.values())
            if not with_address and return_single:
                values = [val[0] for val in values]
            return values
        elif format == 'array':
            if multiple_synapses not in Projection.MULTI_SYNAPSE_OPERATIONS:
                raise ValueError("`multiple_synapses` argument must be one of {}".format(list(Projection.MULTI_SYNAPSE_OPERATIONS)))
            if gather and self._simulator.state.num_processes > 1:
                # Node 0 is the only one creating a full connection matrix, and returning it (saving memory)
                # Slaves nodes are returning list of connections, so this may be inconsistent...
                names = list(attribute_names)
                names = ["presynaptic_index", "postsynaptic_index"] + names
                values = self._get_attributes_as_list(names)
                all_values = {self._simulator.state.mpi_rank: values}
                all_values = recording.gather_dict(all_values, all=(gather == 'all'))
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    tmp_values = reduce(operator.add, all_values.values())
                    values = self._get_attributes_as_arrays(attribute_names,
                                                            multiple_synapses=multiple_synapses)
                    tmp_values = numpy.array(tmp_values)
                    for i in xrange(len(values)):
                        values[i][tmp_values[:, 0].astype(int), tmp_values[:, 1].astype(int)] = tmp_values[:, 2 + i]
            else:
                values = self._get_attributes_as_arrays(attribute_names,
                                                        multiple_synapses=multiple_synapses)
            if return_single:
                if gather == 'all' or self._simulator.state.mpi_rank == 0:
                    assert len(values) == 1, values
                return values[0]
            else:
                return values
        else:
            raise Exception("format must be 'list' or 'array'")