예제 #1
0
    def make_step(self, signals, dt, rng):
        src = signals[self.src]
        dst = signals[self.dst]
        src_slice = self.src_slice if self.src_slice is not None else Ellipsis
        dst_slice = self.dst_slice if self.dst_slice is not None else Ellipsis
        inc = self.inc

        dst_slice = (np.asarray(dst_slice)
                     if is_array_like(dst_slice) else dst_slice)
        # There are repeated indices in dst_slice, special case
        repeats = (is_array_like(dst_slice) and dst_slice.dtype != np.bool
                   and len(np.unique(dst_slice)) < len(dst_slice))
        if inc and repeats:

            def step_copy():
                np.add.at(dst, dst_slice, src[src_slice])
        elif inc:

            def step_copy():
                dst[dst_slice] += src[src_slice]
        elif repeats:
            raise BuildError("%s: Cannot have repeated indices in "
                             "``dst_slice`` when copy is not an increment" %
                             self)
        else:

            def step_copy():
                dst[dst_slice] = src[src_slice]

        return step_copy
예제 #2
0
def build_node(model, node):
    # input signal
    if not is_array_like(node.output) and node.size_in > 0:
        sig_in = Signal(np.zeros(node.size_in), name="%s.in" % node)
        model.add_op(Reset(sig_in))
    else:
        sig_in = None

    # Provide output
    if node.output is None:
        sig_out = sig_in
    elif isinstance(node.output, Process):
        sig_out = Signal(np.zeros(node.size_out), name="%s.out" % node)
        model.build(node.output, sig_in, sig_out)
    elif callable(node.output):
        sig_out = (Signal(np.zeros(node.size_out), name="%s.out" %
                          node) if node.size_out > 0 else None)
        model.add_op(
            SimPyFunc(output=sig_out, fn=node.output, t=model.time, x=sig_in))
    elif is_array_like(node.output):
        sig_out = Signal(node.output, name="%s.out" % node)
    else:
        raise BuildError("Invalid node output type %r" %
                         node.output.__class__.__name__)

    model.sig[node]['in'] = sig_in
    model.sig[node]['out'] = sig_out
    model.params[node] = None
예제 #3
0
파일: node.py 프로젝트: JolyZhang/nengo
def build_node(model, node):
    # input signal
    if not is_array_like(node.output) and node.size_in > 0:
        sig_in = Signal(np.zeros(node.size_in), name="%s.in" % node)
        model.add_op(Reset(sig_in))
    else:
        sig_in = None

    # Provide output
    if node.output is None:
        sig_out = sig_in
    elif isinstance(node.output, Process):
        sig_out = Signal(np.zeros(node.size_out), name="%s.out" % node)
        model.build(node.output, sig_in, sig_out)
    elif callable(node.output):
        sig_out = (Signal(np.zeros(node.size_out), name="%s.out" % node)
                   if node.size_out > 0 else None)
        model.add_op(SimPyFunc(
            output=sig_out, fn=node.output, t=model.time, x=sig_in))
    elif is_array_like(node.output):
        sig_out = Signal(node.output, name="%s.out" % node)
    else:
        raise BuildError(
            "Invalid node output type %r" % node.output.__class__.__name__)

    model.sig[node]['in'] = sig_in
    model.sig[node]['out'] = sig_out
    model.params[node] = None
예제 #4
0
 def equal(self, instance_a, instance_b):
     a = self.__get__(instance_a, None)
     b = self.__get__(instance_b, None)
     if self.equatable:
         if is_array_like(a) or is_array_like(b):
             return np.array_equal(a, b)
         else:
             return a == b
     else:
         return a is b
예제 #5
0
    def coerce(self, conn, function):
        function = super(ConnectionFunctionParam, self).coerce(conn, function)

        if function is None:
            function_info = FunctionInfo(function=None, size=None)
        elif isinstance(function, FunctionInfo):
            function_info = function
        elif is_array_like(function):
            array = np.array(function, copy=False, dtype=np.float64)
            self.check_array(conn, array)
            function_info = FunctionInfo(function=array, size=array.shape[1])
        elif callable(function):
            function_info = FunctionInfo(function=function,
                                         size=self.determine_size(
                                             conn, function))
            # TODO: necessary?
            super(ConnectionFunctionParam, self).coerce(conn, function_info)
        else:
            raise ValidationError("Invalid connection function type %r "
                                  "(must be callable or array-like)" %
                                  type(function).__name__,
                                  attr=self.name,
                                  obj=conn)

        self.check_function_can_be_applied(conn, function_info)

        return function_info
예제 #6
0
    def __init__(self, shape, init=1.0):
        super(Dense, self).__init__()

        self.shape = shape

        if is_array_like(init):
            init = np.asarray(init, dtype=np.float64)

            # check that the shape of init is compatible with the given shape
            # for this transform
            expected_shape = None
            if shape[0] != shape[1]:
                # init must be 2D if transform is not square
                expected_shape = shape
            elif init.ndim == 1:
                expected_shape = (shape[0], )
            elif init.ndim >= 2:
                expected_shape = shape

            if expected_shape is not None and init.shape != expected_shape:
                raise ValidationError(
                    "Shape of initial value %s does not match expected "
                    "shape %s" % (init.shape, expected_shape),
                    attr="init")

        self.init = init
예제 #7
0
파일: node.py 프로젝트: nengo/nengo
    def __set__(self, node, output):
        super(OutputParam, self).validate(node, output)

        size_in_set = node.size_in is not None
        node.size_in = node.size_in if size_in_set else 0

        # --- Validate and set the new size_out
        if output is None:
            if node.size_out is not None:
                warnings.warn("'Node.size_out' is being overwritten with " "'Node.size_in' since 'Node.output=None'")
            node.size_out = node.size_in
        elif isinstance(output, Process):
            if not size_in_set:
                node.size_in = output.default_size_in
            if node.size_out is None:
                node.size_out = output.default_size_out
        elif callable(output):
            # We trust user's size_out if set, because calling output
            # may have unintended consequences (e.g., network communication)
            if node.size_out is None:
                result = self.validate_callable(node, output)
                node.size_out = 0 if result is None else result.size
        elif is_array_like(output):
            # Make into correctly shaped numpy array before validation
            output = npext.array(output, min_dims=1, copy=False, dtype=np.float64)
            self.validate_ndarray(node, output)
            node.size_out = output.size
        else:
            raise ValidationError("Invalid node output type %r" % type(output).__name__, attr=self.name, obj=node)

        # --- Set output
        self.data[node] = output
예제 #8
0
    def make_step(self, signals, dt, rng):
        src = signals[self.src]
        dst = signals[self.dst]
        src_slice = self.src_slice if self.src_slice is not None else Ellipsis
        dst_slice = self.dst_slice if self.dst_slice is not None else Ellipsis
        inc = self.inc

        # If there are repeated indices in dst_slice, special handling needed.
        repeats = False
        if is_array_like(dst_slice):
            dst_slice = np.array(dst_slice)  # copy because we might modify it
            if dst_slice.dtype.kind != "b":
                # get canonical, positive indices first
                dst_slice[dst_slice < 0] += len(dst)
                repeats = len(np.unique(dst_slice)) < len(dst_slice)

        if inc and repeats:
            def step_copy():
                np.add.at(dst, dst_slice, src[src_slice])
        elif inc:
            def step_copy():
                dst[dst_slice] += src[src_slice]
        elif repeats:
            raise BuildError("%s: Cannot have repeated indices in "
                             "``dst_slice`` when copy is not an increment"
                             % self)
        else:
            def step_copy():
                dst[dst_slice] = src[src_slice]

        return step_copy
예제 #9
0
파일: node.py 프로젝트: 4n6strider/nengo
def build_node(model, node):
    """Builds a `.Node` object into a model.

    The node build function is relatively simple. It involves creating input
    and output signals, and connecting them with an `.Operator` that depends
    on the type of ``node.output``.

    Parameters
    ----------
    model : Model
        The model to build into.
    node : Node
        The node to build.

    Notes
    -----
    Sets ``model.params[node]`` to ``None``.
    """

    # input signal
    if not is_array_like(node.output) and node.size_in > 0:
        sig_in = Signal(np.zeros(node.size_in), name="%s.in" % node)
        model.add_op(Reset(sig_in))
    else:
        sig_in = None

    # Provide output
    if node.output is None:
        sig_out = sig_in
    elif isinstance(node.output, Process):
        sig_out = Signal(np.zeros(node.size_out), name="%s.out" % node)
        model.build(node.output, sig_in, sig_out)
    elif callable(node.output):
        sig_out = (Signal(np.zeros(node.size_out), name="%s.out" % node)
                   if node.size_out > 0 else None)
        model.add_op(SimPyFunc(
            output=sig_out, fn=node.output, t=model.time, x=sig_in))
    elif is_array_like(node.output):
        sig_out = Signal(node.output, name="%s.out" % node)
    else:
        raise BuildError(
            "Invalid node output type %r" % node.output.__class__.__name__)

    model.sig[node]['in'] = sig_in
    model.sig[node]['out'] = sig_out
    model.params[node] = None
예제 #10
0
def build_node(model, node):
    """Builds a `.Node` object into a model.

    The node build function is relatively simple. It involves creating input
    and output signals, and connecting them with an `.Operator` that depends
    on the type of ``node.output``.

    Parameters
    ----------
    model : Model
        The model to build into.
    node : Node
        The node to build.

    Notes
    -----
    Sets ``model.params[node]`` to ``None``.
    """

    # input signal
    if not is_array_like(node.output) and node.size_in > 0:
        sig_in = Signal(np.zeros(node.size_in), name="%s.in" % node)
        model.add_op(Reset(sig_in))
    else:
        sig_in = None

    # Provide output
    if node.output is None:
        sig_out = sig_in
    elif isinstance(node.output, Process):
        sig_out = Signal(np.zeros(node.size_out), name="%s.out" % node)
        model.build(node.output, sig_in, sig_out)
    elif callable(node.output):
        sig_out = (Signal(np.zeros(node.size_out), name="%s.out" %
                          node) if node.size_out > 0 else None)
        model.add_op(
            SimPyFunc(output=sig_out, fn=node.output, t=model.time, x=sig_in))
    elif is_array_like(node.output):
        sig_out = Signal(node.output, name="%s.out" % node)
    else:
        raise BuildError("Invalid node output type %r" %
                         type(node.output).__name__)

    model.sig[node]['in'] = sig_in
    model.sig[node]['out'] = sig_out
    model.params[node] = None
 def dot(self, other):
     """Return the dot product of the two vectors."""
     if isinstance(other, Fixed):
         infer_types(self, other)
         other = other.evaluate().v
     if is_array_like(other):
         return np.vdot(self.v, other)
     else:
         return other.vdot(self)
예제 #12
0
def assert_is_deepcopy(cp, original):
    assert cp is not original  # ensures separate parameters
    for param in iter_params(cp):
        param_inst = getattr(cp, param)
        if isinstance(param_inst, nengo.solvers.Solver) or isinstance(
                param_inst, nengo.base.NengoObject):
            assert_is_copy(param_inst, getattr(original, param))
        elif is_array_like(param_inst):
            assert np.all(param_inst == getattr(original, param))
        else:
            assert param_inst == getattr(original, param)
예제 #13
0
def assert_is_deepcopy(cp, original):
    assert cp is not original  # ensures separate parameters
    for param in iter_params(cp):
        param_inst = getattr(cp, param)
        if isinstance(param_inst, nengo.solvers.Solver) or isinstance(
                param_inst, nengo.base.NengoObject):
            assert_is_copy(param_inst, getattr(original, param))
        elif is_array_like(param_inst):
            assert np.all(param_inst == getattr(original, param))
        else:
            assert param_inst == getattr(original, param)
예제 #14
0
파일: connection.py 프로젝트: GYGit/nengo
    def __set__(self, conn, function):
        if function is None:
            function_info = self.Info(function=None, size=None)
        elif is_array_like(function):
            array = np.array(function, copy=False, dtype=np.float64)
            self.validate_array(conn, array)
            function_info = self.Info(function=array, size=array.shape[1])
        elif callable(function):
            function_info = self.Info(function=function,
                                      size=self.determine_size(conn, function))
            self.validate_callable(conn, function_info)
        else:
            raise ValidationError("Invalid connection function type %r "
                                  "(must be callable or array-like)"
                                  % type(function).__name__,
                                  attr=self.name, obj=conn)

        self.validate(conn, function_info)
        self.data[conn] = function_info
예제 #15
0
    def __set__(self, node, output):
        super(OutputParam, self).validate(node, output)

        size_in_set = node.size_in is not None
        node.size_in = node.size_in if size_in_set else 0

        # --- Validate and set the new size_out
        if output is None:
            if node.size_out is not None:
                warnings.warn("'Node.size_out' is being overwritten with "
                              "'Node.size_in' since 'Node.output=None'")
            node.size_out = node.size_in
        elif isinstance(output, Process):
            if not size_in_set:
                node.size_in = output.default_size_in
            if node.size_out is None:
                node.size_out = output.default_size_out
        elif callable(output):
            # We trust user's size_out if set, because calling output
            # may have unintended consequences (e.g., network communication)
            if node.size_out is None:
                result = self.validate_callable(node, output)
                node.size_out = 0 if result is None else result.size
        elif is_array_like(output):
            # Make into correctly shaped numpy array before validation
            output = npext.array(output,
                                 min_dims=1,
                                 copy=False,
                                 dtype=np.float64)
            self.validate_ndarray(node, output)
            if not np.all(np.isfinite(output)):
                raise ValidationError("Output value must be finite.",
                                      attr=self.name,
                                      obj=node)
            node.size_out = output.size
        else:
            raise ValidationError("Invalid node output type %r" %
                                  type(output).__name__,
                                  attr=self.name,
                                  obj=node)

        # --- Set output
        self.data[node] = output
예제 #16
0
    def __set__(self, conn, function):
        if function is None:
            function_info = FunctionInfo(function=None, size=None)
        elif isinstance(function, FunctionInfo):
            function_info = function
        elif is_array_like(function):
            array = np.array(function, copy=False, dtype=np.float64)
            self.validate_array(conn, array)
            function_info = FunctionInfo(function=array, size=array.shape[1])
        elif callable(function):
            function_info = FunctionInfo(function=function,
                                         size=self.determine_size(
                                             conn, function))
            self.validate_callable(conn, function_info)
        else:
            raise ValidationError("Invalid connection function type %r "
                                  "(must be callable or array-like)" %
                                  type(function).__name__,
                                  attr=self.name,
                                  obj=conn)

        self.validate(conn, function_info)
        self.data[conn] = function_info
예제 #17
0
파일: params.py 프로젝트: utsavakru/nengo
def equal(a, b):
    if is_array_like(a) or is_array_like(b):
        return np.array_equal(a, b)
    else:
        return a == b
예제 #18
0
 def is_transform_type(transform, types):
     types = (types, ) if isinstance(types, str) else types
     assert is_array_like(transform)
     return "Dense" in types  # all old transforms are dense