def extend(self, keys, unitary=False): """Extends the vocabulary with additional keys. Creates and adds the semantic pointers listed in keys to the vocabulary. Parameters ---------- keys : list List of semantic pointer names to be added to the vocabulary. unitary : bool or list, optional If True, all generated pointers will be unitary. If a list of strings, any pointer whose name is on the list will be forced to be unitary when created. """ if is_iterable(unitary): if is_iterable(self.unitary): self.unitary.extend(unitary) else: self.unitary = list(unitary) elif unitary: if is_iterable(self.unitary): self.unitary.extend(keys) else: self.unitary = list(keys) for key in keys: if key not in self.keys: self[key]
def extend(self, keys, unitary=False): """Extends the vocabulary with additional keys. Creates and adds the semantic pointers listed in keys to the vocabulary. Parameters ---------- keys : list List of semantic pointer names to be added to the vocabulary. unitary : bool or list, optional (Default: False) If True, all generated pointers will be unitary. If a list of strings, any pointer whose name is on the list will be forced to be unitary when created. """ if is_iterable(unitary): if is_iterable(self.unitary): self.unitary.extend(unitary) else: self.unitary = list(unitary) elif unitary: if is_iterable(self.unitary): self.unitary.extend(keys) else: self.unitary = list(keys) for key in keys: if key not in self.keys: self[key]
def add_input_mapping(self, name, input_vectors, input_scales=1.0): """Adds a set of input vectors to the associative memory network. Creates a transform with the given input vectors between the a named input node and associative memory element input to enable the inputs to be mapped onto ensembles of the Associative Memory. Parameters ---------- name: str Name to use for the input node. This name will be used as the name of the attribute for the associative memory network. input_vectors: array_like The list of vectors to be compared against. input_scales: float or array_like, optional Scaling factor to apply on each of the input vectors. Note that it is possible to scale each vector independently. """ # --- Put arguments in canonical form n_vectors, d_vectors = input_vectors.shape if is_iterable(input_vectors): input_vectors = np.array(input_vectors, ndmin=2) if not is_iterable(input_scales): input_scales = input_scales * np.ones((1, n_vectors)) else: input_scales = np.array(input_scales, ndmin=2) # --- Check some preconditions if input_scales.shape[1] != n_vectors: raise ValidationError( "Number of input_scale values (%d) does not " "match number of input vectors (%d)." % (input_scales.shape[1], n_vectors), attr="input_scales", ) if hasattr(self, name): raise ValidationError( "Name '%s' already exists as a node in the " "associative memory." % name, attr="name", ) # --- Finally, make the input node and connect it in_node = Node(size_in=d_vectors, label=name) setattr(self, name, in_node) Connection( in_node, self.elem_input, synapse=None, transform=input_vectors * input_scales.T, )
def simplify(self): is_num = lambda x: isinstance(x, NumExp) if isinstance(self.fn, str): return self # cannot simplify elif all(map(is_num, self.args)): # simplify scalar function return NumExp(self.fn(*[a.value for a in self.args])) elif all( is_num(a) or is_iterable(a) and all(map(is_num, a)) for a in self.args): # simplify vector function return NumExp( self.fn([[aa.value for aa in a] if is_iterable(a) else a.value for a in self.args])) else: return self # cannot simplify
def coerce(self, instance, rule): if is_iterable(rule): for r in (rule.values() if isinstance(rule, dict) else rule): self.check_rule(instance, r) elif rule is not None: self.check_rule(instance, rule) return super().coerce(instance, rule)
def coerce(self, instance, rule): # pylint: disable=arguments-renamed if is_iterable(rule): for r in rule.values() if isinstance(rule, dict) else rule: self.check_rule(instance, r) elif rule is not None: self.check_rule(instance, rule) return super().coerce(instance, rule)
def coerce(self, instance, rule): if is_iterable(rule): for r in (rule.values() if isinstance(rule, dict) else rule): self.check_rule(instance, r) elif rule is not None: self.check_rule(instance, rule) return super().coerce(instance, rule)
def __getitem__(self, item): if isinstance(item, slice): item = np.arange(len(self))[item] if is_iterable(item): rval = self.__class__.__new__(self.__class__) rval.starts = [self.starts[i] for i in item] rval.shape0s = [self.shape0s[i] for i in item] rval.shape1s = [self.shape1s[i] for i in item] rval.stride0s = [self.stride0s[i] for i in item] rval.stride1s = [self.stride1s[i] for i in item] rval.buf = self.buf rval.names = [self.names[i] for i in item] return rval else: if isinstance(item, np.ndarray): item.shape = () # avoid numpy DeprecationWarning itemsize = self.dtype.itemsize shape = (self.shape0s[item], self.shape1s[item]) byteoffset = itemsize * self.starts[item] bytestrides = ( itemsize * self.stride0s[item], itemsize * self.stride1s[item], ) return np.ndarray( shape=shape, dtype=self.dtype, buffer=self.buf.data, offset=byteoffset, strides=bytestrides, )
def add_output_mapping(self, name, output_vectors): """Adds another output to the associative memory network. Creates a transform with the given output vectors between the associative memory element output and a named output node to enable the selection of output vectors by the associative memory. Parameters ---------- name: str Name to use for the output node. This name will be used as the name of the attribute for the associative memory network. output_vectors: array_like The list of vectors to be produced for each match. """ # --- Put arguments in canonical form if is_iterable(output_vectors): output_vectors = np.array(output_vectors, ndmin=2) # --- Check preconditions if hasattr(self, name): raise ValidationError("Name '%s' already exists as a node in the " "associative memory." % name, attr='name') # --- Make the output node and connect it output = nengo.Node(size_in=output_vectors.shape[1], label=name) setattr(self, name, output) if self.thresh_ens is not None: c = nengo.Connection(self.thresh_ens.output, output, synapse=None, transform=output_vectors.T) else: c = nengo.Connection(self.elem_output, output, synapse=None, transform=output_vectors.T) self.out_conns.append(c)
def __init__( self, target=None, key=None, slice=None, weights=None, synapse=None, reindexing=None, ): self.key = key self.synapse = synapse iterable_target = is_iterable(target) self.target = ([] if target is None else list(target) if iterable_target else [target]) # targets can be LoihiBlock or None. `Model.add_probe` checks Nones are filled. assert all( isinstance(t, (LoihiBlock, type(None))) for t in self.target) self.slice = ( [self._slice(None) for _ in self.target] if slice is None else slice if iterable_target # a single `slice` can be e.g. a list, so use target else [slice]) assert len(self.slice) == len(self.target) self.weights = ( [None for _ in self.target] if weights is None else [np.asarray(w) if w is not None else None for w in weights] if iterable_target else [np.asarray(weights)]) assert len(self.weights) == len(self.target) self.reindexing = reindexing
def getitem_device(self, item): if isinstance(item, slice): item = np.arange(len(self))[item] if is_iterable(item): return CLRaggedArray.from_buffer( self.queue, self.cl_buf, self.starts[item], self.shape0s[item], self.shape1s[item], self.stride0s[item], self.stride1s[item], names=[self.names[i] for i in item], ) else: s = self.dtype.itemsize return Array( self.queue, (self.shape0s[item], self.shape1s[item]), self.dtype, strides=(self.stride0s[item] * s, self.stride1s[item] * s), data=self.cl_buf.data, offset=self.starts[item] * s, )
def add_output_mapping(self, name, output_vectors): """Adds another output to the associative memory network. Creates a transform with the given output vectors between the associative memory element output and a named output node to enable the selection of output vectors by the associative memory. Parameters ---------- name: str Name to use for the output node. This name will be used as the name of the attribute for the associative memory network. output_vectors: array_like The list of vectors to be produced for each match. """ # --- Put arguments in canonical form if is_iterable(output_vectors): output_vectors = np.array(output_vectors, ndmin=2) # --- Check preconditions if hasattr(self, name): raise ValidationError("Name '%s' already exists as a node in the " "associative memory." % name, attr='name') # --- Make the output node and connect it output = nengo.Node(size_in=output_vectors.shape[1], label=name) setattr(self, name, output) if self.thresh_ens is not None: c = nengo.Connection(self.thresh_ens.output, output, synapse=None, transform=output_vectors.T) else: c = nengo.Connection(self.elem_output, output, synapse=None, transform=output_vectors.T) self.out_conns.append(c)
def function_args(self, conn, function): x = ( conn.eval_points[0] if is_iterable(conn.eval_points) else np.zeros(conn.size_in) ) return (x,)
def __init__(self, fn, in_dims=None, out_dim=None): if in_dims is not None and not is_iterable(in_dims): in_dims = [in_dims] self.fn = fn self.in_dims = in_dims self.out_dim = out_dim self._translator = None
def __init__(self, n_neurons, n_ensembles, ens_dimensions=1, neuron_nodes=False, label=None, seed=None, add_to_container=None, **ens_kwargs): if "dimensions" in ens_kwargs: raise ValidationError( "'dimensions' is not a valid argument to EnsembleArray. " "To set the number of ensembles, use 'n_ensembles'. To set " "the number of dimensions per ensemble, use 'ens_dimensions'.", attr='dimensions', obj=self) super().__init__(label, seed, add_to_container) for param in ens_kwargs: if is_iterable(ens_kwargs[param]): ens_kwargs[param] = nengo.dists.Samples(ens_kwargs[param]) self.config[nengo.Ensemble].update(ens_kwargs) label_prefix = "" if label is None else label + "_" self.n_neurons_per_ensemble = n_neurons self.n_ensembles = n_ensembles self.dimensions_per_ensemble = ens_dimensions # These may be set in add_neuron_input and add_neuron_output self.neuron_input, self.neuron_output = None, None self.ea_ensembles = [] with self: self.input = nengo.Node(size_in=self.dimensions, label="input") for i in range(n_ensembles): e = nengo.Ensemble(n_neurons, self.dimensions_per_ensemble, label="%s%d" % (label_prefix, i)) nengo.Connection(self.input[i * ens_dimensions:(i + 1) * ens_dimensions], e, synapse=None) self.ea_ensembles.append(e) if neuron_nodes: self.add_neuron_input() self.add_neuron_output() warnings.warn( "'neuron_nodes' argument will be removed in Nengo 2.2. Use " "'add_neuron_input' and 'add_neuron_output' methods instead.", DeprecationWarning) self.add_output('output', function=None)
def probe(cls, x): """Returns a function that consumes a simulator and produces probe data.""" # Probes are created eagerly, but the actual probing is done lazily # through recursive calls that inject the simulator object. if is_iterable(x): p_funcs = tuple(cls.probe(xi) for xi in x) return lambda sim: tuple(p_func(sim) for p_func in p_funcs) p = nengo.Probe(x) return lambda sim: sim.data[p]
def add_input_mapping(self, name, input_vectors, input_scales=1.0): """Adds a set of input vectors to the associative memory network. Creates a transform with the given input vectors between the a named input node and associative memory element input to enable the inputs to be mapped onto ensembles of the Associative Memory. Parameters ---------- name: str Name to use for the input node. This name will be used as the name of the attribute for the associative memory network. input_vectors: array_like The list of vectors to be compared against. input_scales: float or array_like, optional (Default: 1.0) Scaling factor to apply on each of the input vectors. Note that it is possible to scale each vector independently. """ # --- Put arguments in canonical form n_vectors, d_vectors = input_vectors.shape if is_iterable(input_vectors): input_vectors = np.array(input_vectors, ndmin=2) if not is_iterable(input_scales): input_scales = input_scales * np.ones((1, n_vectors)) else: input_scales = np.array(input_scales, ndmin=2) # --- Check some preconditions if input_scales.shape[1] != n_vectors: raise ValidationError("Number of input_scale values (%d) does not " "match number of input vectors (%d)." % (input_scales.shape[1], n_vectors), attr='input_scales') if hasattr(self, name): raise ValidationError("Name '%s' already exists as a node in the " "associative memory." % name, attr='name') # --- Finally, make the input node and connect it in_node = nengo.Node(size_in=d_vectors, label=name) setattr(self, name, in_node) nengo.Connection(in_node, self.elem_input, synapse=None, transform=input_vectors * input_scales.T)
def __init__( self, n_neurons, n_ensembles, ens_dimensions=1, label=None, seed=None, add_to_container=None, **ens_kwargs, ): if "dimensions" in ens_kwargs: raise ValidationError( "'dimensions' is not a valid argument to EnsembleArray. " "To set the number of ensembles, use 'n_ensembles'. To set " "the number of dimensions per ensemble, use 'ens_dimensions'.", attr="dimensions", obj=self, ) super().__init__(label, seed, add_to_container) for param, value in ens_kwargs.items(): if is_iterable(value): ens_kwargs[param] = Samples(value) self.config[Ensemble].update(ens_kwargs) label_prefix = "" if label is None else label + "_" self.n_neurons_per_ensemble = n_neurons self.n_ensembles = n_ensembles self.dimensions_per_ensemble = ens_dimensions # These may be set in add_neuron_input and add_neuron_output self.neuron_input, self.neuron_output = None, None self.ea_ensembles = [] with self: self.input = Node(size_in=self.dimensions, label="input") for i in range(n_ensembles): e = Ensemble( n_neurons, self.dimensions_per_ensemble, label=f"{label_prefix}{i}", ) Connection( self.input[i * ens_dimensions : (i + 1) * ens_dimensions], e, synapse=None, ) self.ea_ensembles.append(e) self.add_output("output", function=None)
def __init__(self, n_neurons, n_ensembles, ens_dimensions=1, neuron_nodes=False, label=None, seed=None, add_to_container=None, **ens_kwargs): if "dimensions" in ens_kwargs: raise ValidationError( "'dimensions' is not a valid argument to EnsembleArray. " "To set the number of ensembles, use 'n_ensembles'. To set " "the number of dimensions per ensemble, use 'ens_dimensions'.", attr='dimensions', obj=self) super().__init__(label, seed, add_to_container) for param in ens_kwargs: if is_iterable(ens_kwargs[param]): ens_kwargs[param] = nengo.dists.Samples(ens_kwargs[param]) self.config[nengo.Ensemble].update(ens_kwargs) label_prefix = "" if label is None else label + "_" self.n_neurons_per_ensemble = n_neurons self.n_ensembles = n_ensembles self.dimensions_per_ensemble = ens_dimensions # These may be set in add_neuron_input and add_neuron_output self.neuron_input, self.neuron_output = None, None self.ea_ensembles = [] with self: self.input = nengo.Node(size_in=self.dimensions, label="input") for i in range(n_ensembles): e = nengo.Ensemble(n_neurons, self.dimensions_per_ensemble, label="%s%d" % (label_prefix, i)) nengo.Connection(self.input[i * ens_dimensions: (i + 1) * ens_dimensions], e, synapse=None) self.ea_ensembles.append(e) if neuron_nodes: self.add_neuron_input() self.add_neuron_output() warnings.warn( "'neuron_nodes' argument will be removed in Nengo 2.2. Use " "'add_neuron_input' and 'add_neuron_output' methods instead.", DeprecationWarning) self.add_output('output', function=None)
def _broadcast_args(self, func, args): """Apply 'func' element-wise to lists of args""" as_list = lambda x: list(x) if is_iterable(x) else [x] args = list(map(as_list, args)) arg_lens = list(map(len, args)) max_len = max(arg_lens) assert all(n in [0, 1, max_len] for n in arg_lens), ( "Could not broadcast arguments with lengths %s" % arg_lens) result = [ func(*[a[i] if len(a) > 1 else a[0] for a in args]) for i in range(max_len) ] result = [r.simplify() for r in result] return result[0] if len(result) == 1 else result
def visit_Return(self, expr): value = self.visit(expr.value) if is_iterable(value): self._check_vector_length(len(value)) if not all(isinstance(v, Expression) for v in value): raise ValueError( "Can only return a list of mathematical expressions") return [ "%s[%d] = %s;" % (OUTPUT_NAME, i, v.to_ocl()) for i, v in enumerate(value) ] + ["return;"] elif isinstance(value, Expression): return ["%s[0] = %s;" % (OUTPUT_NAME, value.to_ocl()), "return;"] else: raise ValueError("Can only return mathematical expressions, " "or lists of expressions")
def __setitem__(self, item, new_value): if isinstance(item, slice) or is_iterable(item): raise NotImplementedError("TODO") else: m, n = self.shape0s[item], self.shape1s[item] sm, sn = self.stride0s[item], self.stride1s[item] if (sm, sn) in [(1, m), (n, 1)]: # contiguous clarray = self.getitem_device(item) if isinstance(new_value, np.ndarray): array = np.asarray(new_value, order="C", dtype=self.dtype) else: array = np.zeros(clarray.shape, dtype=clarray.dtype) array[...] = new_value array.shape = clarray.shape # reshape to avoid warning assert equal_strides(array.strides, clarray.strides, clarray.shape) clarray.set(array) else: # discontiguous # Copy a contiguous region off the device that surrounds the # discontiguous, set the appropriate values, and copy back s = self.starts[item] array = to_host( self.queue, self.cl_buf.data, self.dtype, s, (m, n), (sm, sn), is_blocking=True, ) array[...] = new_value buf = array.base if array.base is not None else array bytestart = self.dtype.itemsize * s cl.enqueue_copy( self.queue, self.cl_buf.data, buf, device_offset=bytestart, is_blocking=True, )
def lti(u, system, state=lambda x: x, dt=0.001, method="zoh"): r"""Operator that solves \dot{x} = A.state(x) + B.u. where A, B = system. The state parameter can be any callable function that consumes a Stimulus operator and produces a Gyrus operator that consumes said operator as an input. For instance, nonlinear dynamical systems may be implemented by specifying a nonlinear function for the ``state``. """ if not is_iterable(system) or len(system) != 2: raise NotImplementedError( f"lti currently only supports systems as two-tuples: (A, B); not {system}" ) # Reshape and validate A, B matrices. A, B = system A = np.asarray(A) if A.ndim != 2 or A.shape[0] != A.shape[1]: raise ValueError(f"A ({A}) must be a square matrix") size_out = A.shape[0] B = np.asarray(B) if B.ndim == 1: B = B[:, None] if B.ndim != 2: raise ValueError(f"B ({B}) must be 1D or 2D, but is {B.ndim}") if B.shape[0] != size_out: raise ValueError( f"B ({B}) must be an array of length {size_out}, not {B.shape[0]}") C = np.zeros_like(B).T D = 0 # Discretize the dynamical system, \dot{x} = Ax + Bu, to # x[t + dt] = Ax[t] + Bu[t], using some method (ZOH recommended for stability). Abar, Bbar, _, _, _ = cont2discrete((A, B, C, D), dt=dt, method=method) # Apply Voelker (2019) equation 5.30 with H(z) = dt / (z - 1). # This compensates for the discretized integrator such that the resulting # system is the one that was requested. In this particular case (with the # synapse being the discretized integrator) this reduces to the inverse # of Euler's method. Amap = (Abar - np.eye(len(Abar))) / dt Bmap = Bbar / dt # Finally express the Amap, Bmap system using vectorized Gyrus operators. return u.transform(Bmap).integrate( integrand=lambda x: state(x).transform(Amap))
def __getitem__(self, item): """ Getting one item returns a numpy array (on the host). Getting multiple items returns a view into the device. """ if is_iterable(item): return self.getitem_device(item) else: buf = to_host( self.queue, self.cl_buf.data, self.dtype, self.starts[item], (self.shape0s[item], self.shape1s[item]), (self.stride0s[item], self.stride1s[item]), ) buf.setflags(write=False) return buf
def learning_rule(self): """(LearningRule or iterable) Connectable learning rule object(s).""" if self.learning_rule_type is None: return None types = self.learning_rule_type if isinstance(types, dict): learning_rule = type(types)() # dict of same type for k, v in types.items(): learning_rule[k] = LearningRule(self, v) elif is_iterable(types): learning_rule = [LearningRule(self, v) for v in types] elif isinstance(types, LearningRuleType): learning_rule = LearningRule(self, types) else: assert False, "Validation should catch this" return learning_rule
def __getitem__(self, key): """Return the semantic pointer with the requested name. If one does not exist, automatically create one. The key must be a valid semantic pointer name, which is any Python identifier starting with a capital letter. """ if not key[0].isupper(): raise SpaParseError( "Semantic pointers must begin with a capital letter.") value = self.pointers.get(key, None) if value is None: if is_iterable(self.unitary): unitary = key in self.unitary else: unitary = self.unitary value = self.create_pointer(unitary=unitary) self.add(key, value) return value
def __getitem__(self, key): """Return the semantic pointer with the requested name. If one does not exist, automatically create one. The key must be a valid semantic pointer name, which is any Python identifier starting with a capital letter. """ if not key[0].isupper(): raise SpaParseError( "Semantic pointers must begin with a capital letter.") value = self.pointers.get(key, None) if value is None: if is_iterable(self.unitary): unitary = key in self.unitary else: unitary = self.unitary value = self.create_pointer(unitary=unitary) self.add(key, value) return value
def learning_rule(self): """(LearningRule or iterable) Connectable learning rule object(s).""" if self.learning_rule_type is None: return None types = self.learning_rule_type if isinstance(types, dict): learning_rule = type(types)() # dict of same type for k, v in types.items(): learning_rule[k] = LearningRule(self, v) elif is_iterable(types): learning_rule = [LearningRule(self, v) for v in types] elif isinstance(types, LearningRuleType): learning_rule = LearningRule(self, types) else: raise ValidationError("Invalid type %r" % type(types).__name__, attr='learning_rule_type', obj=self) return learning_rule
def learning_rule(self): """(LearningRule or iterable) Connectable learning rule object(s).""" if self.learning_rule_type is None: return None types = self.learning_rule_type if isinstance(types, dict): learning_rule = type(types)() # dict of same type for k, v in types.items(): learning_rule[k] = LearningRule(self, v) elif is_iterable(types): learning_rule = [LearningRule(self, v) for v in types] elif isinstance(types, LearningRuleType): learning_rule = LearningRule(self, types) else: raise ValidationError( "Invalid type %r" % type(types).__name__, attr='learning_rule_type', obj=self) return learning_rule
def similarity(data, vocab, normalize=False): """Return the similarity between some data and the vocabulary. Computes the dot products between all data vectors and each vocabulary vector. If ``normalize=True``, normalizes all vectors to compute the cosine similarity. Parameters ---------- data: array_like The data used for comparison. vocab: Vocabulary or array_like Vocabulary (or list of vectors) to use to calculate the similarity values. normalize : bool, optional (Default: False) Whether to normalize all vectors, to compute the cosine similarity. """ from nengo.spa.vocab import Vocabulary if isinstance(vocab, Vocabulary): vectors = vocab.vectors elif npext.is_iterable(vocab): vectors = np.array(vocab, copy=False, ndmin=2) else: raise ValidationError("%r object is not a valid vocabulary" % (type(vocab).__name__), attr='vocab') data = np.array(data, copy=False, ndmin=2) dots = np.dot(data, vectors.T) if normalize: # Zero-norm vectors should return zero, so avoid divide-by-zero error eps = np.nextafter(0, 1) # smallest float above zero dnorm = np.maximum(npext.norm(data, axis=1, keepdims=True), eps) vnorm = np.maximum(npext.norm(vectors, axis=1, keepdims=True), eps) dots /= dnorm dots /= vnorm.T return dots
def similarity(data, vocab, normalize=False): """Return the similarity between some data and the vocabulary. Computes the dot products between all data vectors and each vocabulary vector. If ``normalize=True``, normalizes all vectors to compute the cosine similarity. Parameters ---------- data: array_like The data used for comparison. vocab: Vocabulary or array_like Vocabulary (or list of vectors) to use to calculate the similarity values. normalize : bool, optional (Default: False) Whether to normalize all vectors, to compute the cosine similarity. """ from nengo.spa.vocab import Vocabulary if isinstance(vocab, Vocabulary): vectors = vocab.vectors elif npext.is_iterable(vocab): vectors = np.array(vocab, copy=False, ndmin=2) else: raise ValidationError("%r object is not a valid vocabulary" % (type(vocab).__name__), attr='vocab') data = np.array(data, copy=False, ndmin=2) dots = np.dot(data, vectors.T) if normalize: # Zero-norm vectors should return zero, so avoid divide-by-zero error eps = np.nextafter(0, 1) # smallest float above zero dnorm = np.maximum(npext.norm(data, axis=1, keepdims=True), eps) vnorm = np.maximum(npext.norm(vectors, axis=1, keepdims=True), eps) dots /= dnorm dots /= vnorm.T return dots
def build_connection(model, conn): """Builds a `.Connection` object into a model. A brief summary of what happens in the connection build process, in order: 1. Solve for decoders. 2. Combine transform matrix with decoders to get weights. 3. Add operators for computing the function or multiplying neural activity by weights. 4. Call build function for the synapse. 5. Call build function for the learning rule. 6. Add operator for applying learning rule delta to weights. Some of these steps may be altered or omitted depending on the parameters of the connection, in particular the pre and post types. Parameters ---------- model : Model The model to build into. conn : Connection The connection to build. Notes ----- Sets ``model.params[conn]`` to a `.BuiltConnection` instance. """ # Create random number generator rng = np.random.RandomState(model.seeds[conn]) # Get input and output connections from pre and post def get_prepost_signal(is_pre): target = conn.pre_obj if is_pre else conn.post_obj key = "out" if is_pre else "in" if target not in model.sig: raise BuildError("Building %s: the %r object %s is not in the " "model, or has a size of zero." % (conn, "pre" if is_pre else "post", target)) signal = model.sig[target].get(key, None) if signal is None or signal.size == 0: raise BuildError( "Building %s: the %r object %s has a %r size of zero." % (conn, "pre" if is_pre else "post", target, key)) return signal model.sig[conn]["in"] = get_prepost_signal(is_pre=True) model.sig[conn]["out"] = get_prepost_signal(is_pre=False) decoders = None encoders = None eval_points = None solver_info = None post_slice = conn.post_slice # Figure out the signal going across this connection in_signal = model.sig[conn]["in"] if isinstance(conn.pre_obj, Node) or (isinstance(conn.pre_obj, Ensemble) and isinstance(conn.pre_obj.neuron_type, Direct)): # Node or Decoded connection in directmode sliced_in = slice_signal(model, in_signal, conn.pre_slice) if conn.function is None: in_signal = sliced_in elif isinstance(conn.function, np.ndarray): raise BuildError("Cannot use function points in direct connection") else: in_signal = Signal(shape=conn.size_mid, name="%s.func" % conn) model.add_op(SimPyFunc(in_signal, conn.function, None, sliced_in)) elif isinstance(conn.pre_obj, Ensemble): # Normal decoded connection eval_points, decoders, solver_info = model.build( conn.solver, conn, rng) if isinstance(conn.post_obj, Ensemble) and conn.solver.weights: model.sig[conn]["out"] = model.sig[conn.post_obj.neurons]["in"] encoders = model.params[conn.post_obj].scaled_encoders.T encoders = encoders[conn.post_slice] # post slice already applied to encoders (either here or in # `build_decoders`), so don't apply later post_slice = None else: in_signal = slice_signal(model, in_signal, conn.pre_slice) # Build transform if conn.solver.weights and not conn.solver.compositional: # special case for non-compositional weight solvers, where # the solver is solving for the full weight matrix. so we don't # need to combine decoders/transform/encoders. weighted, weights = model.build(Dense(decoders.shape, init=decoders), in_signal, rng=rng) else: weighted, weights = model.build(conn.transform, in_signal, decoders=decoders, encoders=encoders, rng=rng) model.sig[conn]["weights"] = weights # Build synapse if conn.synapse is not None: weighted = model.build(conn.synapse, weighted, mode="update") # Store the weighted-filtered output in case we want to probe it model.sig[conn]["weighted"] = weighted if isinstance(conn.post_obj, Neurons): # Apply neuron gains (we don't need to do this if we're connecting to # an Ensemble, because the gains are rolled into the encoders) gains = Signal( model.params[conn.post_obj.ensemble].gain[post_slice], name="%s.gains" % conn, ) if is_integer(post_slice) or isinstance(post_slice, slice): sliced_out = model.sig[conn]["out"][post_slice] else: # advanced indexing not supported on Signals, so we need to set up an # intermediate signal and use a Copy op to perform the indexing sliced_out = Signal(shape=gains.shape, name="%s.sliced_out" % conn) model.add_op(Reset(sliced_out)) model.add_op( Copy(sliced_out, model.sig[conn]["out"], dst_slice=post_slice, inc=True)) model.add_op( ElementwiseInc(gains, weighted, sliced_out, tag="%s.gains_elementwiseinc" % conn)) else: # Copy to the proper slice model.add_op( Copy( weighted, model.sig[conn]["out"], dst_slice=post_slice, inc=True, tag="%s" % conn, )) # Build learning rules if conn.learning_rule is not None: # TODO: provide a general way for transforms to expose learnable params if not isinstance(conn.transform, (Dense, NoTransform)): raise NotImplementedError( "Learning on connections with %s transforms is not supported" % (type(conn.transform).__name__, )) rule = conn.learning_rule rule = [rule] if not is_iterable(rule) else rule targets = [] for r in rule.values() if isinstance(rule, dict) else rule: model.build(r) targets.append(r.modifies) if "encoders" in targets: encoder_sig = model.sig[conn.post_obj]["encoders"] encoder_sig.readonly = False if "decoders" in targets or "weights" in targets: if weights.ndim < 2: raise BuildError( "'transform' must be a 2-dimensional array for learning") model.sig[conn]["weights"].readonly = False model.params[conn] = BuiltConnection( eval_points=eval_points, solver_info=solver_info, transform=conn.transform, weights=getattr(weights, "initial_value", None), )
def probeable(cls, x): """Returns True iff the probe method can handle x.""" return is_iterable(x) or is_probeable(x)
def is_symbolic(x): return isinstance( x, Expression) or (is_iterable(x) and all(isinstance(xx, Expression) for xx in x))
def discretize_synapse(synapse, w_max, w_scale, w_exp): """Discretize a `.Synapse` in-place. Turns a floating-point `.Synapse` into a discrete (integer) block appropriate for Loihi. Parameters ---------- synapse : `.Synapse` The synapse to discretize. w_max : float The largest connection weight in the `.LoihiBlock` containing ``synapse``. Used to scale weights appropriately. w_scale : float Connection weight scaling factor. Usually computed by `.discretize_compartment`. w_exp : float Exponent on the connection weight scaling factor. Usually computed by `.discretize_compartment`. """ w_max_i = synapse.max_abs_weight() if synapse.learning: w_exp2 = synapse.learning_wgt_exp dw_exp = w_exp - w_exp2 elif w_max_i > 1e-16: dw_exp = int(np.floor(np.log2(w_max / w_max_i))) assert dw_exp >= 0 w_exp2 = max(w_exp - dw_exp, -6) else: w_exp2 = -6 dw_exp = w_exp - w_exp2 synapse.format(weight_exp=w_exp2) for w, idxs in zip(synapse.weights, synapse.indices): ws = w_scale[idxs] if is_iterable(w_scale) else w_scale array_to_int( w, discretize_weights(synapse.synapse_cfg, w * ws * 2**dw_exp)) # discretize learning if synapse.learning: synapse.tracing_tau = int(np.round(synapse.tracing_tau)) if is_iterable(w_scale): assert np.all(w_scale == w_scale[0]) w_scale_i = w_scale[0] if is_iterable(w_scale) else w_scale # incorporate weight scale and difference in weight exponents # to learning rate, since these affect speed at which we learn ws = w_scale_i * 2**dw_exp synapse.learning_rate *= ws # Loihi down-scales learning factors based on the number of # overflow bits. Increasing learning rate maintains true rate. synapse.learning_rate *= 2**learn_overflow_bits(2) # TODO: Currently, Loihi learning rate fixed at 2**-7. # We should explore adjusting it for better performance. lscale = 2**-7 / synapse.learning_rate synapse.learning_rate *= lscale synapse.tracing_mag /= lscale # discretize learning rate into mantissa and exponent lr_exp = int(np.floor(np.log2(synapse.learning_rate))) lr_int = int(np.round(synapse.learning_rate * 2**(-lr_exp))) synapse.learning_rate = lr_int * 2**lr_exp synapse._lr_int = lr_int synapse._lr_exp = lr_exp assert lr_exp >= -7 # discretize tracing mag into integer and fractional components mag_int, mag_frac = tracing_mag_int_frac(synapse.tracing_mag) if mag_int > 127: warnings.warn("Trace increment exceeds upper limit " "(learning rate may be too large)") mag_int = 127 mag_frac = 127 synapse.tracing_mag = mag_int + mag_frac / 128.0
def add_output(self, name, function, synapse=None, **conn_kwargs): """Adds a node that collects the decoded output of all ensembles. By default, this is called once in ``__init__`` with ``function=None``. However, this can be called multiple times with different functions, similar to the way in which an ensemble can be connected to many downstream ensembles with different functions. Note that in addition to the parameters below, parameters affecting all of the connections from the sub-ensembles to the new node can be passed to this function. For example:: ea.add_output('output', None, solver=nengo.solers.Lstsq()) creates a new output with the decoders of each connection solved for with the `.Lstsq` solver. Parameters ---------- name : str The name of the output. This will also be the name of the attribute set on the ensemble array. function : callable or iterable of callables The function to compute across the connection from sub-ensembles to the new output node. If function is an iterable, it must be an iterable consisting of one function for each sub-ensemble. synapse : Synapse, optional (Default: None) The synapse model with which to filter the connections from sub-ensembles to the new output node. This is kept separate from the other ``conn_kwargs`` because this defaults to None rather than the default synapse model. In almost all cases the synapse should stay as None, and synaptic filtering should be performed in the connection from the output node. """ dims_per_ens = self.dimensions_per_ensemble # get output size for each ensemble sizes = np.zeros(self.n_ensembles, dtype=int) if is_iterable(function) and all(callable(f) for f in function): if len(list(function)) != self.n_ensembles: raise ValidationError( "Must have one function per ensemble", attr='function') for i, func in enumerate(function): sizes[i] = np.asarray(func(np.zeros(dims_per_ens))).size elif callable(function): sizes[:] = np.asarray(function(np.zeros(dims_per_ens))).size function = [function] * self.n_ensembles elif function is None: sizes[:] = dims_per_ens function = [None] * self.n_ensembles else: raise ValidationError("'function' must be a callable, list of " "callables, or None", attr='function') output = nengo.Node(output=None, size_in=sizes.sum(), label=name) setattr(self, name, output) indices = np.zeros(len(sizes) + 1, dtype=int) indices[1:] = np.cumsum(sizes) for i, e in enumerate(self.ea_ensembles): nengo.Connection( e, output[indices[i]:indices[i+1]], function=function[i], synapse=synapse, **conn_kwargs) return output
def add_output(self, name, function, synapse=None, **conn_kwargs): """Adds a node that collects the decoded output of all ensembles. By default, this is called once in ``__init__`` with ``function=None``. However, this can be called multiple times with different functions, similar to the way in which an ensemble can be connected to many downstream ensembles with different functions. Note that in addition to the parameters below, parameters affecting all of the connections from the sub-ensembles to the new node can be passed to this function. For example: .. testcode:: ea.add_output("lstsq_output", None, solver=nengo.solvers.Lstsq()) creates a new output at ``ea.lstsq_output`` with the decoders of each connection solved for with the `.Lstsq` solver. Parameters ---------- name : str The name of the output. This will also be the name of the attribute set on the ensemble array. function : callable or iterable of callables The function to compute across the connection from sub-ensembles to the new output node. If function is an iterable, it must be an iterable consisting of one function for each sub-ensemble. synapse : Synapse, optional The synapse model with which to filter the connections from sub-ensembles to the new output node. This is kept separate from the other ``conn_kwargs`` because this defaults to None rather than the default synapse model. In almost all cases the synapse should stay as None, and synaptic filtering should be performed in the connection from the output node. """ if hasattr(self, name): raise ValidationError( f"Cannot add output '{name}'; there is already an attribute " "with this name", attr="name", obj=self, ) dims_per_ens = self.dimensions_per_ensemble # get output size for each ensemble sizes = np.zeros(self.n_ensembles, dtype=int) if is_iterable(function) and all(callable(f) for f in function): if len(list(function)) != self.n_ensembles: raise ValidationError( "Must have one function per ensemble", attr="function", obj=self ) for i, func in enumerate(function): sizes[i] = np.asarray(func(np.zeros(dims_per_ens))).size elif callable(function): sizes[:] = np.asarray(function(np.zeros(dims_per_ens))).size function = [function] * self.n_ensembles elif function is None: sizes[:] = dims_per_ens function = [None] * self.n_ensembles else: raise ValidationError( "'function' must be a callable, list of callables, or None", attr="function", obj=self, ) output = Node(output=None, size_in=sizes.sum(), label=name) setattr(self, name, output) indices = np.zeros(len(sizes) + 1, dtype=int) indices[1:] = np.cumsum(sizes) for i, e in enumerate(self.ea_ensembles): Connection( e, output[indices[i] : indices[i + 1]], function=function[i], synapse=synapse, **conn_kwargs, ) return output
def is_foldable(cls, input_ops): """Returns True iff input_ops is an acceptable argument to the constructor.""" # There is no technical reason to disallow a fold to be the input, but # this would be a noop and likely not what the user intends to do. return is_iterable(input_ops) and not isinstance(input_ops, Fold)
def __init__(self, input_vectors, output_vectors=None, # noqa: C901 n_neurons=50, threshold=0.3, input_scales=1.0, inhibitable=False, label=None, seed=None, add_to_container=None): super().__init__(label, seed, add_to_container) # --- Put arguments in canonical form if output_vectors is None: # If output vocabulary is not specified, use input vector list # (i.e autoassociative memory) output_vectors = input_vectors if is_iterable(input_vectors): input_vectors = np.array(input_vectors, ndmin=2) if is_iterable(output_vectors): output_vectors = np.array(output_vectors, ndmin=2) if input_vectors.shape[0] == 0: raise ValidationError("Number of input vectors cannot be 0.", attr='input_vectors', obj=self) elif input_vectors.shape[0] != output_vectors.shape[0]: # Fail if number of input items and number of output items don't # match raise ValidationError( "Number of input vectors does not match number of output " "vectors. %d != %d" % (input_vectors.shape[0], output_vectors.shape[0]), attr='input_vectors', obj=type(self)) # Handle possible different threshold / input_scale values for each # element in the associative memory if not is_iterable(threshold): threshold = threshold * np.ones(input_vectors.shape[0]) else: threshold = np.array(threshold) # --- Check preconditions self.n_items = input_vectors.shape[0] if self.n_items != output_vectors.shape[0]: raise ValidationError( "Number of input vectors (%d) does not match number of output " "vectors (%d)" % (self.n_items, output_vectors.shape[0]), attr='input_vectors', obj=self) if threshold.shape[0] != self.n_items: raise ValidationError( "Number of threshold values (%d) does not match number of " "input vectors (%d)." % (threshold.shape[0], self.n_items), attr='threshold', obj=self) # --- Set parameters self.out_conns = [] # Used in `add_threshold_to_output` # Used in `add_threshold_to_output` self.default_vector_inhibit_conns = [] self.thresh_ens = None # Will hold thresholded outputs self.is_wta = False self._inhib_scale = 1.5 # -- Create the core network with self, self.am_ens_config: self.bias_node = nengo.Node(output=1) self.elem_input = nengo.Node( size_in=self.n_items, label="element input") self.elem_output = nengo.Node( size_in=self.n_items, label="element output") self.utilities = self.elem_output self.am_ensembles = [] label_prefix = "" if label is None else label + "_" filt_scale = 15 filt_step_func = lambda x: filtered_step(x, 0.0, scale=filt_scale) for i in range(self.n_items): e = nengo.Ensemble(n_neurons, 1, label=label_prefix + str(i)) self.am_ensembles.append(e) # Connect input and output nodes nengo.Connection(self.bias_node, e, transform=-threshold[i]) nengo.Connection(self.elem_input[i], e) nengo.Connection( e, self.elem_output[i], function=filt_step_func) if inhibitable: # Input node for inhibitory gating signal (if enabled) self.inhibit = nengo.Node(size_in=1, label="inhibit") nengo.Connection(self.inhibit, self.elem_input, transform=-np.ones((self.n_items, 1)) * self._inhib_scale) # Note: We can use a decoded connection here because all the # am_ensembles have [1] encoders else: self.inhibit = None self.thresh_bias = None self.thresholded_utilities = None self.add_input_mapping("input", input_vectors, input_scales) self.add_output_mapping("output", output_vectors)
def function_args(self, conn, function): x = (conn.eval_points[0] if is_iterable(conn.eval_points) else np.zeros(conn.size_in)) return (x,)
def __init__( # noqa: C901 self, input_vectors, output_vectors=None, n_neurons=50, threshold=0.3, input_scales=1.0, inhibitable=False, label=None, seed=None, add_to_container=None, ): super().__init__(label, seed, add_to_container) # --- Put arguments in canonical form if output_vectors is None: # If output vocabulary is not specified, use input vector list # (i.e autoassociative memory) output_vectors = input_vectors if is_iterable(input_vectors): input_vectors = np.array(input_vectors, ndmin=2) if is_iterable(output_vectors): output_vectors = np.array(output_vectors, ndmin=2) if input_vectors.shape[0] == 0: raise ValidationError("Number of input vectors cannot be 0.", attr="input_vectors", obj=self) elif input_vectors.shape[0] != output_vectors.shape[0]: # Fail if number of input items and number of output items don't # match raise ValidationError( "Number of input vectors does not match number of output " "vectors. %d != %d" % (input_vectors.shape[0], output_vectors.shape[0]), attr="input_vectors", obj=type(self), ) # Handle possible different threshold / input_scale values for each # element in the associative memory if not is_iterable(threshold): threshold = threshold * np.ones(input_vectors.shape[0]) else: threshold = np.array(threshold) # --- Check preconditions self.n_items = input_vectors.shape[0] if threshold.shape[0] != self.n_items: raise ValidationError( "Number of threshold values (%d) does not match number of " "input vectors (%d)." % (threshold.shape[0], self.n_items), attr="threshold", obj=self, ) # --- Set parameters self.out_conns = [] # Used in `add_threshold_to_output` # Used in `add_threshold_to_output` self.default_vector_inhibit_conns = [] self.thresh_ens = None # Will hold thresholded outputs self.is_wta = False self._inhib_scale = 1.5 # -- Create the core network with self, self.am_ens_config: self.bias_node = Node(output=1) self.elem_input = Node(size_in=self.n_items, label="element input") self.elem_output = Node(size_in=self.n_items, label="element output") self.utilities = self.elem_output self.am_ensembles = [] label_prefix = "" if label is None else label + "_" filt_scale = 15 filt_step_func = lambda x: filtered_step(x, 0.0, scale=filt_scale) for i in range(self.n_items): e = Ensemble(n_neurons, 1, label=label_prefix + str(i)) self.am_ensembles.append(e) # Connect input and output nodes Connection(self.bias_node, e, transform=-threshold[i]) Connection(self.elem_input[i], e) Connection(e, self.elem_output[i], function=filt_step_func) if inhibitable: # Input node for inhibitory gating signal (if enabled) self.inhibit = Node(size_in=1, label="inhibit") Connection( self.inhibit, self.elem_input, transform=-np.ones((self.n_items, 1)) * self._inhib_scale, ) # Note: We can use a decoded connection here because all the # am_ensembles have [1] encoders else: self.inhibit = None self.thresh_bias = None self.thresholded_utilities = None self.add_input_mapping("input", input_vectors, input_scales) self.add_output_mapping("output", output_vectors)