def test_signal_init_values(RefSimulator): """Tests that initial values are not overwritten.""" zero = Signal([0]) one = Signal([1]) five = Signal([5.0]) zeroarray = Signal([[0], [0], [0]]) array = Signal([1, 2, 3]) m = Model(dt=0) m.operators += [ PreserveValue(five), PreserveValue(array), DotInc(zero, zero, five), DotInc(zeroarray, one, array) ] sim = RefSimulator(None, model=m) assert sim.signals[zero][0] == 0 assert sim.signals[one][0] == 1 assert sim.signals[five][0] == 5.0 assert np.all(np.array([1, 2, 3]) == sim.signals[array]) sim.step() assert sim.signals[zero][0] == 0 assert sim.signals[one][0] == 1 assert sim.signals[five][0] == 5.0 assert np.all(np.array([1, 2, 3]) == sim.signals[array])
def test_signal_indexing_1(RefSimulator): one = Signal(np.zeros(1), name="a") two = Signal(np.zeros(2), name="b") three = Signal(np.zeros(3), name="c") tmp = Signal(np.zeros(3), name="tmp") m = Model(dt=0.001) m.operators += [ Reset(one), Reset(two), Reset(tmp), DotInc(Signal(1, name="A1"), three[:1], one), DotInc(Signal(2.0, name="A2"), three[1:], two), DotInc(Signal([[0, 0, 1], [0, 1, 0], [1, 0, 0]], name="A3"), three, tmp), Copy(src=tmp, dst=three, as_update=True), ] sim = RefSimulator(None, model=m) sim.signals[three] = np.asarray([1, 2, 3]) sim.step() assert np.all(sim.signals[one] == 1) assert np.all(sim.signals[two] == [4, 6]) assert np.all(sim.signals[three] == [3, 2, 1]) sim.step() assert np.all(sim.signals[one] == 3) assert np.all(sim.signals[two] == [4, 2]) assert np.all(sim.signals[three] == [1, 2, 3])
def test_multidotinc_compress(monkeypatch): if nengo.version.version_info < (2, 3, 1): # LEGACY # Nengo versions <= 2.3.0 have more stringent op validation which # required PreserveValue. That's been removed, so the strict # validation causes this test to fail despite it working. monkeypatch.setattr(nengo.utils.simulator, "validate_ops", lambda *args: None) a = Signal([0, 0]) b = Signal([0, 0]) A = Signal([[1, 2], [0, 1]]) B = Signal([[2, 1], [-1, 1]]) x = Signal([1, 1]) y = Signal([1, -1]) m = Model(dt=0) m.operators += [Reset(a), DotInc(A, x, a), DotInc(B, y, a)] m.operators += [DotInc(A, y, b), DotInc(B, x, b)] with nengo_ocl.Simulator(None, model=m) as sim: sim.step() assert np.allclose(sim.signals[a], [4, -1]) assert np.allclose(sim.signals[b], [2, -1]) sim.step() assert np.allclose(sim.signals[a], [4, -1]) assert np.allclose(sim.signals[b], [4, -2])
def build_pes(model, pes, rule): # TODO: Filter activities conn = rule.connection activities = model.sig[conn.pre_obj]['out'] error = model.sig[pes.error_connection]['out'] scaled_error = Signal(np.zeros(error.shape), name="PES:error * learning_rate") scaled_error_view = scaled_error.reshape((error.size, 1)) activities_view = activities.reshape((1, activities.size)) lr_sig = Signal(pes.learning_rate * model.dt, name="PES:learning_rate") model.add_op(Reset(scaled_error)) model.add_op(DotInc(lr_sig, error, scaled_error, tag="PES:scale error")) if conn.solver.weights or (isinstance(conn.pre_obj, Neurons) and isinstance(conn.post_obj, Neurons)): post = (conn.post_obj.ensemble if isinstance(conn.post_obj, Neurons) else conn.post_obj) transform = model.sig[conn]['transform'] encoders = model.sig[post]['encoders'] encoded_error = Signal(np.zeros(transform.shape[0]), name="PES: encoded error") model.add_op(Reset(encoded_error)) model.add_op( DotInc(encoders, scaled_error, encoded_error, tag="PES:Encode error")) encoded_error_view = encoded_error.reshape((encoded_error.size, 1)) model.add_op( ElementwiseInc(encoded_error_view, activities_view, transform, tag="PES:Inc Transform")) elif isinstance(conn.pre_obj, Neurons): transform = model.sig[conn]['transform'] model.add_op( ElementwiseInc(scaled_error_view, activities_view, transform, tag="PES:Inc Transform")) else: assert isinstance(conn.pre_obj, Ensemble) decoders = model.sig[conn]['decoders'] model.add_op( ElementwiseInc(scaled_error_view, activities_view, decoders, tag="PES:Inc Decoder")) # expose these for probes model.sig[rule]['scaled_error'] = scaled_error model.sig[rule]['activities'] = activities model.params[rule] = None # no build-time info to return
def test_operators(): sig = Signal(np.array([0.0]), name="sig") assert fnmatch(repr(TimeUpdate(sig, sig)), "<TimeUpdate at 0x*>") assert fnmatch(repr(TimeUpdate(sig, sig, tag="tag")), "<TimeUpdate 'tag' at 0x*>") assert fnmatch(repr(Reset(sig)), "<Reset at 0x*>") assert fnmatch(repr(Reset(sig, tag="tag")), "<Reset 'tag' at 0x*>") assert fnmatch(repr(Copy(sig, sig)), "<Copy at 0x*>") assert fnmatch(repr(Copy(sig, sig, tag="tag")), "<Copy 'tag' at 0x*>") assert fnmatch(repr(ElementwiseInc(sig, sig, sig)), "<ElementwiseInc at 0x*>") assert fnmatch(repr(ElementwiseInc(sig, sig, sig, tag="tag")), "<ElementwiseInc 'tag' at 0x*>") assert fnmatch(repr(DotInc(sig, sig, sig)), "<DotInc at 0x*>") assert fnmatch(repr(DotInc(sig, sig, sig, tag="tag")), "<DotInc 'tag' at 0x*>") assert fnmatch(repr(SimPyFunc(sig, lambda x: 0.0, True, sig)), "<SimPyFunc at 0x*>") assert fnmatch( repr(SimPyFunc(sig, lambda x: 0.0, True, sig, tag="tag")), "<SimPyFunc 'tag' at 0x*>", ) assert fnmatch(repr(SimPES(sig, sig, sig, 0.1)), "<SimPES at 0x*>") assert fnmatch(repr(SimPES(sig, sig, sig, 0.1, tag="tag")), "<SimPES 'tag' at 0x*>") assert fnmatch(repr(SimBCM(sig, sig, sig, sig, 0.1)), "<SimBCM at 0x*>") assert fnmatch(repr(SimBCM(sig, sig, sig, sig, 0.1, tag="tag")), "<SimBCM 'tag' at 0x*>") assert fnmatch(repr(SimOja(sig, sig, sig, sig, 0.1, 1.0)), "<SimOja at 0x*>") assert fnmatch(repr(SimOja(sig, sig, sig, sig, 0.1, 1.0, tag="tag")), "<SimOja 'tag' at 0x*>") assert fnmatch(repr(SimVoja(sig, sig, sig, sig, 1.0, sig, 1.0)), "<SimVoja at 0x*>") assert fnmatch( repr(SimVoja(sig, sig, sig, sig, 0.1, sig, 1.0, tag="tag")), "<SimVoja 'tag' at 0x*>", ) assert fnmatch(repr(SimRLS(sig, sig, sig, sig)), "<SimRLS at 0x*>") assert fnmatch( repr(SimRLS(sig, sig, sig, sig, tag="tag")), "<SimRLS 'tag' at 0x*>", ) assert fnmatch(repr(SimNeurons(LIF(), sig, {"sig": sig})), "<SimNeurons at 0x*>") assert fnmatch( repr(SimNeurons(LIF(), sig, {"sig": sig}, tag="tag")), "<SimNeurons 'tag' at 0x*>", ) assert fnmatch(repr(SimProcess(WhiteNoise(), sig, sig, sig)), "<SimProcess at 0x*>") assert fnmatch( repr(SimProcess(WhiteNoise(), sig, sig, sig, tag="tag")), "<SimProcess 'tag' at 0x*>", )
def build_pes(model, pes, rule): conn = rule.connection # Create input error signal error = Signal(np.zeros(rule.size_in), name="PES:error") model.add_op(Reset(error)) model.sig[rule]['in'] = error # error connection will attach here acts = filtered_signal(model, pes, model.sig[conn.pre_obj]['out'], pes.pre_tau) acts_view = acts.reshape((1, acts.size)) # Compute the correction, i.e. the scaled negative error correction = Signal(np.zeros(error.shape), name="PES:correction") local_error = correction.reshape((error.size, 1)) model.add_op(Reset(correction)) # correction = -learning_rate * (dt / n_neurons) * error n_neurons = (conn.pre_obj.n_neurons if isinstance(conn.pre_obj, Ensemble) else conn.pre_obj.size_in) lr_sig = Signal(-pes.learning_rate * model.dt / n_neurons, name="PES:learning_rate") model.add_op(DotInc(lr_sig, error, correction, tag="PES:correct")) if conn.solver.weights or (isinstance(conn.pre_obj, Neurons) and isinstance(conn.post_obj, Neurons)): post = get_post_ens(conn) transform = model.sig[conn]['transform'] encoders = model.sig[post]['encoders'] # encoded = dot(encoders, correction) encoded = Signal(np.zeros(transform.shape[0]), name="PES:encoded") model.add_op(Reset(encoded)) model.add_op(DotInc(encoders, correction, encoded, tag="PES:encode")) local_error = encoded.reshape((encoded.size, 1)) elif not isinstance(conn.pre_obj, (Ensemble, Neurons)): raise ValueError("'pre' object '%s' not suitable for PES learning" % (conn.pre_obj)) # delta = local_error * activities model.add_op(Reset(model.sig[rule]['delta'])) model.add_op( ElementwiseInc(local_error, acts_view, model.sig[rule]['delta'], tag="PES:Inc Delta")) # expose these for probes model.sig[rule]['error'] = error model.sig[rule]['correction'] = correction model.sig[rule]['activities'] = acts model.params[rule] = None # no build-time info to return
def build_node(model, node): # Get input if node.output is None or callable(node.output): if node.size_in > 0: model.sig[node]['in'] = model.Signal(npext.castDecimal( np.zeros(node.size_in)), name="%s.signal" % node) # Reset input signal to 0 each timestep model.add_op(Reset(model.sig[node]['in'])) # Provide output if node.output is None: model.sig[node]['out'] = model.sig[node]['in'] elif not callable(node.output): model.sig[node]['out'] = model.Signal(node.output, name=str(node)) else: sig_in, sig_out = build_pyfunc(model=model, fn=node.output, t_in=True, n_in=node.size_in, n_out=node.size_out, label="%s.pyfn" % node) if sig_in is not None: model.add_op( DotInc(model.sig[node]['in'], model.sig['common'][1], sig_in, tag="%s input" % node)) if sig_out is not None: model.sig[node]['out'] = sig_out model.params[node] = None
def test_signal_init_values(Simulator): """Tests that initial values are not overwritten.""" zero = Signal([0.0]) one = Signal([1.0]) five = Signal([5.0]) zeroarray = Signal([[0.0], [0.0], [0.0]]) array = Signal([1.0, 2.0, 3.0]) m = nengo.builder.Model(dt=0) m.operators += [ ElementwiseInc(zero, zero, five), DotInc(zeroarray, one, array) ] probes = [ dummies.Probe(zero, add_to_container=False), dummies.Probe(one, add_to_container=False), dummies.Probe(five, add_to_container=False), dummies.Probe(array, add_to_container=False) ] m.probes += probes for p in probes: m.sig[p]['in'] = p.target with Simulator(None, model=m) as sim: sim.run_steps(3) assert np.allclose(sim.data[probes[0]], 0) assert np.allclose(sim.data[probes[1]], 1) assert np.allclose(sim.data[probes[2]], 5) assert np.allclose(sim.data[probes[3]], [1, 2, 3])
def test_signal_init_values(Simulator): """Tests that initial values are not overwritten.""" zero = Signal([0.0]) one = Signal([1.0]) five = Signal([5.0]) zeroarray = Signal([[0.0], [0.0], [0.0]]) array = Signal([1.0, 2.0, 3.0]) class DummyProbe(nengo.Probe): # pylint: disable=super-init-not-called def __init__(self, target): # bypass target validation nengo.Probe.target.data[self] = target m = nengo.builder.Model(dt=0) m.operators += [ElementwiseInc(zero, zero, five), DotInc(zeroarray, one, array)] probes = [DummyProbe(zero, add_to_container=False), DummyProbe(one, add_to_container=False), DummyProbe(five, add_to_container=False), DummyProbe(array, add_to_container=False)] m.probes += probes for p in probes: m.sig[p]['in'] = p.target with Simulator(None, model=m) as sim: sim.run_steps(3) assert np.allclose(sim.data[probes[0]], 0) assert np.allclose(sim.data[probes[1]], 1) assert np.allclose(sim.data[probes[2]], 5) assert np.allclose(sim.data[probes[3]], [1, 2, 3])
def build_delta_rule(model, delta_rule, rule): conn = rule.connection # Create input error signal error = Signal(np.zeros(rule.size_in), name="DeltaRule:error") model.add_op(Reset(error)) model.sig[rule]["in"] = error # error connection will attach here # Multiply by post_fn output if necessary post_fn = delta_rule.post_fn.function post_tau = delta_rule.post_tau post_target = delta_rule.post_target if post_fn is not None: post_sig = model.sig[conn.post_obj][post_target] post_synapse = Lowpass(post_tau) if post_tau is not None else None post_input = (post_sig if post_synapse is None else model.build( post_synapse, post_sig)) post = Signal(np.zeros(post_input.shape), name="DeltaRule:post") model.add_op( SimPyFunc(post, post_fn, t=None, x=post_input, tag="DeltaRule:post_fn")) model.sig[rule]["post"] = post error0 = error error = Signal(np.zeros(rule.size_in), name="DeltaRule:post_error") model.add_op(Reset(error)) model.add_op(ElementwiseInc(error0, post, error)) # Compute: correction = -learning_rate * dt * error correction = Signal(np.zeros(error.shape), name="DeltaRule:correction") model.add_op(Reset(correction)) lr_sig = Signal(-delta_rule.learning_rate * model.dt, name="DeltaRule:learning_rate") model.add_op(DotInc(lr_sig, error, correction, tag="DeltaRule:correct")) # delta_ij = correction_i * pre_j pre_synapse = Lowpass(delta_rule.pre_tau) pre = model.build(pre_synapse, model.sig[conn.pre_obj]["out"]) model.add_op(Reset(model.sig[rule]["delta"])) model.add_op( ElementwiseInc( correction.reshape((-1, 1)), pre.reshape((1, -1)), model.sig[rule]["delta"], tag="DeltaRule:Inc Delta", )) # expose these for probes model.sig[rule]["error"] = error model.sig[rule]["correction"] = correction model.sig[rule]["pre"] = pre
def test_simple_pyfunc(RefSimulator): dt = 0.001 time = Signal(np.zeros(1), name="time") sig = Signal(np.zeros(1), name="sig") m = Model(dt=dt) sig_in, sig_out = build_pyfunc(m, lambda t, x: np.sin(x), True, 1, 1, None) m.operators += [ Reset(sig), DotInc(Signal([[1.0]]), time, sig_in), DotInc(Signal([[1.0]]), sig_out, sig), DotInc(Signal(dt), Signal(1), time, as_update=True), ] sim = RefSimulator(None, model=m) for i in range(5): sim.step() t = i * dt assert np.allclose(sim.signals[sig], np.sin(t)) assert np.allclose(sim.signals[time], t + dt)
def merge(ops): # Simple merge if all X are the same. if all(o.X is ops[0].X for o in ops): A, A_sigr = SigMerger.merge([o.A for o in ops]) Y, Y_sigr = SigMerger.merge([o.Y for o in ops]) return DotInc(A, ops[0].X, Y), Merger.merge_dicts(A_sigr, Y_sigr) assert all(o1.X is not o2.X for i, o1 in enumerate(ops) for o2 in ops[i + 1:]) # BSR merge if X differ X, X_sigr = SigMerger.merge([o.X for o in ops]) Y, Y_sigr = SigMerger.merge([o.Y for o in ops]) # Construct sparse A representation data = np.array([o.A.initial_value for o in ops], dtype=rc.float_dtype) if data.ndim == 1: raise NotImplementedError("A.ndim should be > 2") elif data.ndim == 2: raise NotImplementedError("A.ndim should be > 2") indptr = np.arange(len(ops) + 1, dtype=rc.int_dtype) indices = np.arange(len(ops), dtype=rc.int_dtype) name = f"bsr_merged<{ops[0].A.name}, ..., {ops[-1].A.name}>" readonly = all(o.A.readonly for o in ops) A = Signal(data, name=name, readonly=readonly) A_sigr = {} for i, s in enumerate(o.A for o in ops): A_sigr[s] = Signal( data[i], name=f"{s.name}[{i}]", base=A, offset=i * A.itemsize * np.prod(A.shape[1:]), ) assert np.allclose(s.initial_value, A_sigr[s].initial_value, atol=0, rtol=0, equal_nan=True) assert s.shape == A_sigr[s].shape or (s.shape == () and A_sigr[s].shape == (1, 1)) reshape = reshape_dot( ops[0].A.initial_value, ops[0].X.initial_value, ops[0].Y.initial_value, tag=ops[0].tag, ) return ( BsrDotInc(A, X, Y, indices=indices, indptr=indptr, reshape=reshape), Merger.merge_dicts(X_sigr, Y_sigr, A_sigr), )
def test_planner_size(): # check that operators are selected according to number of available ops input0 = dummies.Signal() operators = [Copy(input0, dummies.Signal(), inc=True) for _ in range(2)] operators += [Copy(input0, dummies.Signal())] operators += [DotInc(input0, dummies.Signal(), dummies.Signal()) for _ in range(3)] plan = greedy_planner(operators) assert len(plan) == 3 assert len(plan[0]) == 3 assert len(plan[1]) == 2 assert len(plan[2]) == 1
def test_dotinc_op(rng): argnames = ["A", "X", "Y"] args = { "A": Signal(np.ones((3, 3)), name="Av"), "X": Signal(np.ones((3, )), name="Xv"), "Y": Signal(np.ones((3, )), name="Yv"), } _, sim = _test_operator_arg_attributes(DotInc, argnames, args=args) assert ( str(sim) == "DotInc{Signal(name=Av, shape=(3, 3)), Signal(name=Xv, shape=(3,)) -> " "Signal(name=Yv, shape=(3,))}") A = Signal(np.ones((2, 2))) X = Signal(np.ones((2, 2))) Y = Signal(np.ones(2)) with pytest.raises(BuildError, match="X must be a column vector"): DotInc(A, X, Y) X = Signal(np.ones(2)) Y = Signal(np.ones((2, 2))) with pytest.raises(BuildError, match="Y must be a column vector"): DotInc(A, X, Y)
def build_mpes(model, mpes, rule): conn = rule.connection # Create input error signal error = Signal(shape=(rule.size_in, ), name="PES:error") model.add_op(Reset(error)) model.sig[rule]["in"] = error # error connection will attach here acts = build_or_passthrough(model, mpes.pre_synapse, model.sig[conn.pre_obj]["out"]) post = get_post_ens(conn) encoders = model.sig[post]["encoders"] pos_memristors, neg_memristors, r_min_noisy, r_max_noisy, exponent_noisy = initialise_memristors( mpes, acts.shape[0], encoders.shape[0]) model.sig[conn]["pos_memristors"] = pos_memristors model.sig[conn]["neg_memristors"] = neg_memristors if conn.post_obj is not conn.post: # in order to avoid slicing encoders along an axis > 0, we pad # `error` out to the full base dimensionality and then do the # dotinc with the full encoder matrix # comes into effect when slicing post connection padded_error = Signal(shape=(encoders.shape[1], )) model.add_op(Copy(error, padded_error, dst_slice=conn.post_slice)) else: padded_error = error # error = dot(encoders, error) local_error = Signal(shape=(post.n_neurons, )) model.add_op(Reset(local_error)) model.add_op(DotInc(encoders, padded_error, local_error, tag="PES:encode")) model.operators.append( SimmPES(acts, local_error, model.sig[conn]["pos_memristors"], model.sig[conn]["neg_memristors"], model.sig[conn]["weights"], mpes.noise_percentage, mpes.gain, r_min_noisy, r_max_noisy, exponent_noisy, mpes.initial_state)) # expose these for probes model.sig[rule]["error"] = error model.sig[rule]["activities"] = acts model.sig[rule]["pos_memristors"] = pos_memristors model.sig[rule]["neg_memristors"] = neg_memristors
def test_signal_init_values(Simulator): """Tests that initial values are not overwritten.""" zero = Signal([0.0]) one = Signal([1.0]) five = Signal([5.0]) zeroarray = Signal([[0.0], [0.0], [0.0]]) array = Signal([1.0, 2.0, 3.0]) class DummyProbe(): def __init__(self, target): self.target = target self.sample_every = None self.size_in = target.size m = nengo.builder.Model(dt=0) m.operators += [ ElementwiseInc(zero, zero, five), DotInc(zeroarray, one, array) ] probes = [ DummyProbe(zero), DummyProbe(one), DummyProbe(five), DummyProbe(array) ] m.probes += probes for p in probes: m.sig[p]['in'] = p.target with Simulator(None, model=m) as sim: sim.run_steps(3) assert np.allclose(sim.data[probes[0]], 0) assert np.allclose(sim.data[probes[1]], 1) assert np.allclose(sim.data[probes[2]], 5) assert np.allclose(sim.data[probes[3]], [1, 2, 3])
def test_remove_reset_incs(): # elementwiseinc converted to elementwiseset x = dummies.Signal() operators = [ Reset(x), ElementwiseInc(dummies.Signal(), dummies.Signal(), x) ] new_operators = remove_reset_incs(operators) assert len(new_operators) == 1 assert isinstance(new_operators[0], op_builders.ElementwiseSet) assert new_operators[0].Y is x assert new_operators[0].incs == [] assert new_operators[0].sets == [x] # dotinc converted to dotset x = dummies.Signal() operators = [Reset(x), DotInc(dummies.Signal(), dummies.Signal(), x)] new_operators = remove_reset_incs(operators) assert len(new_operators) == 1 assert isinstance(new_operators[0], op_builders.DotSet) assert new_operators[0].Y is x # copy inc converted to copy set x = dummies.Signal() operators = [Reset(x), Copy(dummies.Signal(), x, inc=True)] new_operators = remove_reset_incs(operators) assert len(new_operators) == 1 assert not new_operators[0].inc assert new_operators[0].dst is x # simprocess inc converted to simprocess set x = dummies.Signal() operators = [ Reset(x), SimProcess(None, dummies.Signal(), x, dummies.Signal(), mode="inc"), ] new_operators = remove_reset_incs(operators) assert len(new_operators) == 1 assert new_operators[0].mode == "set" assert new_operators[0].output is x # convinc converted to convset x = dummies.Signal() operators = [ Reset(x), ConvInc(dummies.Signal(), dummies.Signal(), x, None) ] new_operators = remove_reset_incs(operators) assert len(new_operators) == 1 assert isinstance(new_operators[0], transform_builders.ConvSet) assert new_operators[0].Y is x # sparsedotinc converted to sparsedotset x = dummies.Signal() operators = [ Reset(x), SparseDotInc(dummies.Signal(sparse=True), dummies.Signal(), x, None), ] new_operators = remove_reset_incs(operators) assert len(new_operators) == 1 assert isinstance(new_operators[0], op_builders.SparseDotSet) assert new_operators[0].Y is x # resetinc converted to reset x = dummies.Signal() operators = [Reset(x), op_builders.ResetInc(x)] operators[1].value = np.ones((2, 3)) new_operators = remove_reset_incs(operators) assert len(new_operators) == 1 assert type(new_operators[0]) == Reset assert np.allclose(new_operators[0].value, 1) assert new_operators[0].dst is x # multiple incs x = dummies.Signal() operators = [ Reset(x), ElementwiseInc(dummies.Signal(), dummies.Signal(), x), ElementwiseInc(dummies.Signal(), dummies.Signal(), x), ] new_operators = remove_reset_incs(operators) assert len(new_operators) == 2 assert isinstance(new_operators[0], op_builders.ElementwiseSet) assert isinstance(new_operators[1], ElementwiseInc) # nonzero reset doesn't get converted x = dummies.Signal() operators = [ Reset(x, value=1), ElementwiseInc(dummies.Signal(), dummies.Signal(), x), ] new_operators = remove_reset_incs(operators) assert operators == new_operators # reset without inc x = dummies.Signal() operators = [ Reset(x), Copy(dummies.Signal(), x, inc=False), ] new_operators = remove_reset_incs(operators) assert operators == new_operators # reset with partial inc x = Signal(shape=(10, )) operators = [ Reset(x), Copy(dummies.Signal(), x[:5], inc=True), ] new_operators = remove_reset_incs(operators) assert operators == new_operators # unknown inc type class NewCopy(Copy): pass x = dummies.Signal() operators = [ Reset(x), NewCopy(dummies.Signal(), x, inc=True), ElementwiseInc(dummies.Signal(), dummies.Signal(), x), ] with pytest.warns(UserWarning, match="Unknown incer type"): new_operators = remove_reset_incs(operators) assert len(new_operators) == 2 # uses the known op (ElementwiseInc) instead of unknown one assert isinstance(new_operators[0], op_builders.ElementwiseSet) assert new_operators[1] is operators[1] operators = [ Reset(x), NewCopy(dummies.Signal(), x, inc=True), ] # no optimization if only unknown incers with pytest.warns(UserWarning, match="Unknown incer type"): new_operators = remove_reset_incs(operators) assert new_operators == operators
def build_ensemble(model, ens): # Create random number generator rng = np.random.RandomState(model.seeds[ens]) eval_points = gen_eval_points(ens, ens.eval_points, rng=rng) # Set up signal model.sig[ens]['in'] = Signal(np.zeros(ens.dimensions), name="%s.signal" % ens) model.add_op(Reset(model.sig[ens]['in'])) # Set up encoders if isinstance(ens.neuron_type, Direct): encoders = np.identity(ens.dimensions) elif isinstance(ens.encoders, Distribution): encoders = ens.encoders.sample(ens.n_neurons, ens.dimensions, rng=rng) encoders = np.asarray(encoders, dtype=np.float64) else: encoders = npext.array(ens.encoders, min_dims=2, dtype=np.float64) encoders /= npext.norm(encoders, axis=1, keepdims=True) # Determine max_rates and intercepts max_rates = sample(ens.max_rates, ens.n_neurons, rng=rng) intercepts = sample(ens.intercepts, ens.n_neurons, rng=rng) # Build the neurons if ens.gain is not None and ens.bias is not None: gain = sample(ens.gain, ens.n_neurons, rng=rng) bias = sample(ens.bias, ens.n_neurons, rng=rng) elif ens.gain is not None or ens.bias is not None: # TODO: handle this instead of error raise NotImplementedError("gain or bias set for %s, but not both. " "Solving for one given the other is not " "implemented yet." % ens) else: gain, bias = ens.neuron_type.gain_bias(max_rates, intercepts) if isinstance(ens.neuron_type, Direct): model.sig[ens.neurons]['in'] = Signal(np.zeros(ens.dimensions), name='%s.neuron_in' % ens) model.sig[ens.neurons]['out'] = model.sig[ens.neurons]['in'] model.add_op(Reset(model.sig[ens.neurons]['in'])) else: model.sig[ens.neurons]['in'] = Signal(np.zeros(ens.n_neurons), name="%s.neuron_in" % ens) model.sig[ens.neurons]['out'] = Signal(np.zeros(ens.n_neurons), name="%s.neuron_out" % ens) model.add_op( Copy(src=Signal(bias, name="%s.bias" % ens), dst=model.sig[ens.neurons]['in'])) # This adds the neuron's operator and sets other signals model.build(ens.neuron_type, ens.neurons) # Scale the encoders if isinstance(ens.neuron_type, Direct): scaled_encoders = encoders else: scaled_encoders = encoders * (gain / ens.radius)[:, np.newaxis] model.sig[ens]['encoders'] = Signal(scaled_encoders, name="%s.scaled_encoders" % ens) # Inject noise if specified if ens.noise is not None: model.build(ens.noise, sig_out=model.sig[ens.neurons]['in'], inc=True) # Create output signal, using built Neurons model.add_op( DotInc(model.sig[ens]['encoders'], model.sig[ens]['in'], model.sig[ens.neurons]['in'], tag="%s encoding" % ens)) # Output is neural output model.sig[ens]['out'] = model.sig[ens.neurons]['out'] model.params[ens] = BuiltEnsemble(eval_points=eval_points, encoders=encoders, intercepts=intercepts, max_rates=max_rates, scaled_encoders=scaled_encoders, gain=gain, bias=bias)
def build_pes(model, pes, rule): """ Builds a `nengo.PES` object into a model. Parameters ---------- model : Model The model to build into. pes : PES Learning rule type to build. rule : LearningRule The learning rule object corresponding to the neuron type. Notes ----- Does not modify ``model.params[]`` and can therefore be called more than once with the same `nengo.PES` instance. """ conn = rule.connection # Create input error signal error = Signal(np.zeros(rule.size_in), name="PES:error") model.add_op(Reset(error)) model.sig[rule]['in'] = error # error connection will attach here if LooseVersion(nengo_version) < "2.7.1": acts = model.build( Lowpass(pes.pre_tau), model.sig[conn.pre_obj]["out"]) else: acts = model.build(pes.pre_synapse, model.sig[conn.pre_obj]["out"]) if not conn.is_decoded: # multiply error by post encoders to get a per-neuron error post = get_post_ens(conn) encoders = model.sig[post]["encoders"] if conn.post_obj is not conn.post: # in order to avoid slicing encoders along an axis > 0, we pad # `error` out to the full base dimensionality and then do the # dotinc with the full encoder matrix padded_error = Signal(np.zeros(encoders.shape[1])) model.add_op(Copy(error, padded_error, dst_slice=conn.post_slice)) else: padded_error = error # error = dot(encoders, error) local_error = Signal(np.zeros(post.n_neurons), name="PES:encoded") model.add_op(Reset(local_error)) model.add_op(DotInc(encoders, padded_error, local_error, tag="PES:encode")) else: local_error = error model.operators.append(SimPES(acts, local_error, model.sig[rule]["delta"], pes.learning_rate)) # expose these for probes model.sig[rule]["error"] = error model.sig[rule]["activities"] = acts
def build_ensemble(model, ens): """Builds an `.Ensemble` object into a model. A brief summary of what happens in the ensemble build process, in order: 1. Generate evaluation points and encoders. 2. Normalize encoders to unit length. 3. Determine bias and gain. 4. Create neuron input signal 5. Add operator for injecting bias. 6. Call build function for neuron type. 7. Scale encoders by gain and radius. 8. Add operators for multiplying decoded input signal by encoders and incrementing the result in the neuron input signal. 9. Call build function for injected noise. Some of these steps may be altered or omitted depending on the parameters of the ensemble, in particular the neuron type. For example, most steps are omitted for the `.Direct` neuron type. Parameters ---------- model : Model The model to build into. ens : Ensemble The ensemble to build. Notes ----- Sets ``model.params[ens]`` to a `.BuiltEnsemble` instance. """ # Create random number generator rng = np.random.RandomState(model.seeds[ens]) eval_points = gen_eval_points(ens, ens.eval_points, rng=rng, dtype=rc.float_dtype) # Set up signal model.sig[ens]["in"] = Signal(shape=ens.dimensions, name="%s.signal" % ens) model.add_op(Reset(model.sig[ens]["in"])) # Set up encoders if isinstance(ens.neuron_type, Direct): encoders = np.identity(ens.dimensions, dtype=rc.float_dtype) elif isinstance(ens.encoders, Distribution): encoders = get_samples(ens.encoders, ens.n_neurons, ens.dimensions, rng=rng) encoders = np.asarray(encoders, dtype=rc.float_dtype) else: encoders = npext.array(ens.encoders, min_dims=2, dtype=rc.float_dtype) if ens.normalize_encoders: encoders /= npext.norm(encoders, axis=1, keepdims=True) if np.any(np.isnan(encoders)): raise BuildError( "NaNs detected in %r encoders. This usually means that you had zero-length " "encoders that were normalized, resulting in NaNs. Ensure all encoders " "have non-zero length, or set `normalize_encoders=False`." % ens) # Build the neurons gain, bias, max_rates, intercepts = get_gain_bias(ens, rng, dtype=rc.float_dtype) if isinstance(ens.neuron_type, Direct): model.sig[ens.neurons]["in"] = Signal(shape=ens.dimensions, name="%s.neuron_in" % ens) model.sig[ens.neurons]["out"] = model.sig[ens.neurons]["in"] model.add_op(Reset(model.sig[ens.neurons]["in"])) else: model.sig[ens.neurons]["in"] = Signal(shape=ens.n_neurons, name="%s.neuron_in" % ens) model.sig[ens.neurons]["out"] = Signal(shape=ens.n_neurons, name="%s.neuron_out" % ens) model.sig[ens.neurons]["bias"] = Signal(bias, name="%s.bias" % ens, readonly=True) model.add_op( Copy(model.sig[ens.neurons]["bias"], model.sig[ens.neurons]["in"])) # This adds the neuron's operator and sets other signals model.build(ens.neuron_type, ens.neurons) # Scale the encoders if isinstance(ens.neuron_type, Direct): scaled_encoders = encoders else: scaled_encoders = encoders * (gain / ens.radius)[:, np.newaxis] model.sig[ens]["encoders"] = Signal(scaled_encoders, name="%s.scaled_encoders" % ens, readonly=True) # Inject noise if specified if ens.noise is not None: model.build(ens.noise, sig_out=model.sig[ens.neurons]["in"], mode="inc") # Create output signal, using built Neurons model.add_op( DotInc( model.sig[ens]["encoders"], model.sig[ens]["in"], model.sig[ens.neurons]["in"], tag="%s encoding" % ens, )) # Output is neural output model.sig[ens]["out"] = model.sig[ens.neurons]["out"] model.params[ens] = BuiltEnsemble( eval_points=eval_points, encoders=encoders, intercepts=intercepts, max_rates=max_rates, scaled_encoders=scaled_encoders, gain=gain, bias=bias, )
def test_remove_zero_incs(): # check that zero inputs get removed (for A or X) operators = [DotInc(dummies.Signal(), dummies.Signal(initial_value=1), dummies.Signal())] new_operators = remove_zero_incs(operators) assert new_operators == [] operators = [DotInc(dummies.Signal(initial_value=1), dummies.Signal(), dummies.Signal())] new_operators = remove_zero_incs(operators) assert new_operators == [] # check that zero inputs (copy) get removed operators = [Copy(dummies.Signal(), dummies.Signal(), dummies.Signal(), inc=True)] new_operators = remove_zero_incs(operators) assert new_operators == [] # check that node inputs don't get removed x = dummies.Signal(label="<Node lorem ipsum") operators = [DotInc(dummies.Signal(initial_value=1), x, dummies.Signal())] new_operators = remove_zero_incs(operators) assert new_operators == operators # check that zero inputs + trainable don't get removed x = dummies.Signal() x.trainable = True operators = [DotInc(dummies.Signal(initial_value=1), x, dummies.Signal())] new_operators = remove_zero_incs(operators) assert new_operators == operators # check that updated input doesn't get removed x = dummies.Signal() operators = [DotInc(dummies.Signal(initial_value=1), x, dummies.Signal()), dummies.Op(updates=[x])] new_operators = remove_zero_incs(operators) assert new_operators == operators # check that inc'd input doesn't get removed x = dummies.Signal() operators = [DotInc(dummies.Signal(initial_value=1), x, dummies.Signal()), dummies.Op(incs=[x])] new_operators = remove_zero_incs(operators) assert new_operators == operators # check that set'd input doesn't get removed x = dummies.Signal() operators = [DotInc(dummies.Signal(initial_value=1), x, dummies.Signal()), dummies.Op(sets=[x])] new_operators = remove_zero_incs(operators) assert new_operators == operators # check that Reset(0) input does get removed x = dummies.Signal() operators = [DotInc(dummies.Signal(initial_value=1), x, dummies.Signal()), Reset(x)] new_operators = remove_zero_incs(operators) assert new_operators == operators[1:] # check that Reset(1) input does not get removed x = dummies.Signal() operators = [DotInc(dummies.Signal(initial_value=1), x, dummies.Signal()), Reset(x, 1)] new_operators = remove_zero_incs(operators) assert new_operators == operators # check that set's get turned into a reset x = dummies.Signal() operators = [Copy(dummies.Signal(), x)] new_operators = remove_zero_incs(operators) assert len(new_operators) == 1 assert isinstance(new_operators[0], Reset) assert new_operators[0].dst is x assert new_operators[0].value == 0
def build_pes(model, pes, rule): """Builds a `.PES` object into a model. Calls synapse build functions to filter the pre activities, and adds a `.SimPES` operator to the model to calculate the delta. Parameters ---------- model : Model The model to build into. pes : PES Learning rule type to build. rule : LearningRule The learning rule object corresponding to the neuron type. Notes ----- Does not modify ``model.params[]`` and can therefore be called more than once with the same `.PES` instance. """ conn = rule.connection # Create input error signal error = Signal(shape=rule.size_in, name="PES:error") model.add_op(Reset(error)) model.sig[rule]["in"] = error # error connection will attach here # Filter pre-synaptic activities with pre_synapse acts = build_or_passthrough( model, pes.pre_synapse, slice_signal( model, model.sig[conn.pre_obj]["out"], conn.pre_slice, ) if isinstance(conn.pre_obj, Neurons) else model.sig[conn.pre_obj]["out"], ) if conn._to_neurons: # multiply error by post encoders to get a per-neuron error # i.e. local_error = dot(encoders, error) post = get_post_ens(conn) if not isinstance(conn.post_slice, slice): raise BuildError( "PES learning rule does not support advanced indexing on non-decoded " "connections") encoders = model.sig[post]["encoders"] # slice along neuron dimension if connecting to a neuron object, otherwise # slice along state dimension encoders = (encoders[:, conn.post_slice] if isinstance( conn.post_obj, Ensemble) else encoders[conn.post_slice, :]) local_error = Signal(shape=(encoders.shape[0], )) model.add_op(Reset(local_error)) model.add_op(DotInc(encoders, error, local_error, tag="PES:encode")) else: local_error = error model.add_op( SimPES(acts, local_error, model.sig[rule]["delta"], pes.learning_rate)) # expose these for probes model.sig[rule]["error"] = error model.sig[rule]["activities"] = acts
def build_connection(model, conn): # 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 print('pre', conn.pre_obj, 'post', conn.post_obj) key = 'out' if is_pre else 'in' if target not in model.sig: raise ValueError("Building %s: the '%s' object %s " "is not in the model, or has a size of zero." % (conn, 'pre' if is_pre else 'post', target)) if key not in model.sig[target]: raise ValueError("Error building %s: the '%s' object %s " "has a '%s' size of zero." % (conn, 'pre' if is_pre else 'post', target, key)) return model.sig[target][key] model.sig[conn]['in'] = get_prepost_signal(is_pre=True) model.sig[conn]['out'] = get_prepost_signal(is_pre=False) decoders = None eval_points = None solver_info = None transform = full_transform(conn, slice_pre=False) # Figure out the signal going across this connection 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 if (conn.function is None and isinstance(conn.pre_slice, slice) and (conn.pre_slice.step is None or conn.pre_slice.step == 1)): signal = model.sig[conn]['in'][conn.pre_slice] else: sig_in, signal = build_pyfunc( fn=(lambda x: x[conn.pre_slice]) if conn.function is None else (lambda x: conn.function(x[conn.pre_slice])), t_in=False, n_in=model.sig[conn]['in'].size, n_out=conn.size_mid, label=str(conn), model=model) model.add_op( DotInc(model.sig[conn]['in'], model.sig['common'][1], sig_in, tag="%s input" % conn)) elif isinstance(conn.pre_obj, Ensemble): # Normal decoded connection eval_points, activities, targets = build_linear_system( model, conn, rng) # Use cached solver, if configured solver = model.decoder_cache.wrap_solver(conn.solver) if conn.solver.weights: # account for transform targets = np.dot(targets, transform.T) transform = np.array(1, dtype=rc.get('precision', 'dtype')) decoders, solver_info = solver( activities, targets, rng=rng, E=model.params[conn.post_obj].scaled_encoders.T) model.sig[conn]['out'] = model.sig[conn.post_obj.neurons]['in'] signal_size = model.sig[conn]['out'].size else: decoders, solver_info = solver(activities, targets, rng=rng) signal_size = conn.size_mid # Add operator for decoders decoders = decoders.T model.sig[conn]['decoders'] = model.Signal(decoders, name="%s.decoders" % conn) signal = model.Signal(npext.castDecimal(np.zeros(signal_size)), name=str(conn)) model.add_op(Reset(signal)) model.add_op( DotInc(model.sig[conn]['decoders'], model.sig[conn]['in'], signal, tag="%s decoding" % conn)) else: # Direct connection signal = model.sig[conn]['in'] # Add operator for filtering if conn.synapse is not None: signal = filtered_signal(model, conn, signal, conn.synapse) if conn.modulatory: # Make a new signal, effectively detaching from post model.sig[conn]['out'] = model.Signal(npext.castDecimal( np.zeros(model.sig[conn]['out'].size)), name="%s.mod_output" % conn) model.add_op(Reset(model.sig[conn]['out'])) # Add operator for transform if isinstance(conn.post_obj, Neurons): if not model.has_built(conn.post_obj.ensemble): # Since it hasn't been built, it wasn't added to the Network, # which is most likely because the Neurons weren't associated # with an Ensemble. raise RuntimeError("Connection '%s' refers to Neurons '%s' " "that are not a part of any Ensemble." % (conn, conn.post_obj)) if conn.post_slice != slice(None): raise NotImplementedError( "Post-slices on connections to neurons are not implemented") gain = model.params[conn.post_obj.ensemble].gain[conn.post_slice] if transform.ndim < 2: transform = transform * gain else: transform *= gain[:, np.newaxis] model.sig[conn]['transform'] = model.Signal(transform, name="%s.transform" % conn) print('abcd', model.sig[conn]['out'].value, signal.value) if transform.ndim < 2: print('line 174', model.sig[conn]['transform'].value) model.add_op( ElementwiseInc(model.sig[conn]['transform'], signal, model.sig[conn]['out'], tag=str(conn))) else: model.add_op( DotInc(model.sig[conn]['transform'], signal, model.sig[conn]['out'], tag=str(conn))) if conn.learning_rule_type: # Forcing update of signal that is modified by learning rules. # Learning rules themselves apply DotIncs. if isinstance(conn.pre_obj, Neurons): modified_signal = model.sig[conn]['transform'] elif isinstance(conn.pre_obj, Ensemble): if conn.solver.weights: # TODO: make less hacky. # Have to do this because when a weight_solver # is provided, then learning rules should operators on # "decoders" which is really the weight matrix. model.sig[conn]['transform'] = model.sig[conn]['decoders'] modified_signal = model.sig[conn]['transform'] else: modified_signal = model.sig[conn]['decoders'] else: raise TypeError( "Can't apply learning rules to connections of " "this type. pre type: %s, post type: %s" % (type(conn.pre_obj).__name__, type(conn.post_obj).__name__)) model.add_op(PreserveValue(modified_signal)) model.params[conn] = BuiltConnection(decoders=decoders, eval_points=eval_points, transform=transform, solver_info=solver_info)
def build_connection(model, conn): # 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 ValueError("Building %s: the '%s' object %s " "is not in the model, or has a size of zero." % (conn, 'pre' if is_pre else 'post', target)) if key not in model.sig[target]: raise ValueError("Error building %s: the '%s' object %s " "has a '%s' size of zero." % (conn, 'pre' if is_pre else 'post', target, key)) return model.sig[target][key] model.sig[conn]['in'] = get_prepost_signal(is_pre=True) model.sig[conn]['out'] = get_prepost_signal(is_pre=False) decoders = None eval_points = None solver_info = None transform = full_transform(conn, slice_pre=False) # Figure out the signal going across this connection 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 if (conn.function is None and isinstance(conn.pre_slice, slice) and (conn.pre_slice.step is None or conn.pre_slice.step == 1)): signal = model.sig[conn]['in'][conn.pre_slice] else: signal = Signal(np.zeros(conn.size_mid), name='%s.func' % conn) fn = ((lambda x: x[conn.pre_slice]) if conn.function is None else (lambda x: conn.function(x[conn.pre_slice]))) model.add_op( SimPyFunc(output=signal, fn=fn, t_in=False, x=model.sig[conn]['in'])) elif isinstance(conn.pre_obj, Ensemble): # Normal decoded connection eval_points, activities, targets = build_linear_system( model, conn, rng) # Use cached solver, if configured solver = model.decoder_cache.wrap_solver(conn.solver) if conn.solver.weights: # include transform in solved weights targets = np.dot(targets, transform.T) transform = np.array(1., dtype=np.float64) decoders, solver_info = solver( activities, targets, rng=rng, E=model.params[conn.post_obj].scaled_encoders.T) model.sig[conn]['out'] = model.sig[conn.post_obj.neurons]['in'] signal_size = model.sig[conn]['out'].size else: decoders, solver_info = solver(activities, targets, rng=rng) signal_size = conn.size_mid # Add operator for decoders decoders = decoders.T model.sig[conn]['decoders'] = Signal(decoders, name="%s.decoders" % conn) signal = Signal(np.zeros(signal_size), name=str(conn)) model.add_op(Reset(signal)) model.add_op( DotInc(model.sig[conn]['decoders'], model.sig[conn]['in'], signal, tag="%s decoding" % conn)) else: # Direct connection signal = model.sig[conn]['in'] # Add operator for filtering if conn.synapse is not None: signal = filtered_signal(model, conn, signal, conn.synapse) # Add operator for transform if isinstance(conn.post_obj, Neurons): if not model.has_built(conn.post_obj.ensemble): # Since it hasn't been built, it wasn't added to the Network, # which is most likely because the Neurons weren't associated # with an Ensemble. raise RuntimeError("Connection '%s' refers to Neurons '%s' " "that are not a part of any Ensemble." % (conn, conn.post_obj)) if conn.post_slice != slice(None): raise NotImplementedError( "Post-slices on connections to neurons are not implemented") gain = model.params[conn.post_obj.ensemble].gain[conn.post_slice] if transform.ndim < 2: transform = transform * gain else: transform *= gain[:, np.newaxis] model.sig[conn]['transform'] = Signal(transform, name="%s.transform" % conn) if transform.ndim < 2: model.add_op( ElementwiseInc(model.sig[conn]['transform'], signal, model.sig[conn]['out'], tag=str(conn))) else: model.add_op( DotInc(model.sig[conn]['transform'], signal, model.sig[conn]['out'], tag=str(conn))) # Build learning rules if conn.learning_rule: if isinstance(conn.pre_obj, Ensemble): model.add_op(PreserveValue(model.sig[conn]['decoders'])) else: model.add_op(PreserveValue(model.sig[conn]['transform'])) if isinstance(conn.pre_obj, Ensemble) and conn.solver.weights: # TODO: make less hacky. # Have to do this because when a weight_solver # is provided, then learning rules should operate on # "decoders" which is really the weight matrix. model.sig[conn]['transform'] = model.sig[conn]['decoders'] rule = conn.learning_rule if is_iterable(rule): for r in itervalues(rule) if isinstance(rule, dict) else rule: model.build(r) elif rule is not None: model.build(rule) model.params[conn] = BuiltConnection(decoders=decoders, eval_points=eval_points, transform=transform, solver_info=solver_info)
def build_pes(model, pes, rule): """Builds a `.PES` object into a model. Calls synapse build functions to filter the pre activities, and adds several operators to implement the PES learning rule. Unlike other learning rules, there is no corresponding `.Operator` subclass for the PES rule. Instead, the rule is implemented with generic operators like `.ElementwiseInc` and `.DotInc`. Generic operators are used because they are more likely to be implemented on other backends like Nengo OCL. Parameters ---------- model : Model The model to build into. pes : PES Learning rule type to build. rule : LearningRule The learning rule object corresponding to the neuron type. Notes ----- Does not modify ``model.params[]`` and can therefore be called more than once with the same `.PES` instance. """ conn = rule.connection # Create input error signal error = Signal(np.zeros(rule.size_in), name="PES:error") model.add_op(Reset(error)) model.sig[rule]['in'] = error # error connection will attach here # Filter pre-synaptic activities with pre_synapse acts = build_or_passthrough(model, pes.pre_synapse, model.sig[conn.pre_obj]['out']) # Compute the correction, i.e. the scaled negative error correction = Signal(np.zeros(error.shape), name="PES:correction") model.add_op(Reset(correction)) # correction = -learning_rate * (dt / n_neurons) * error n_neurons = (conn.pre_obj.n_neurons if isinstance(conn.pre_obj, Ensemble) else conn.pre_obj.size_in) lr_sig = Signal(-pes.learning_rate * model.dt / n_neurons, name="PES:learning_rate") model.add_op(ElementwiseInc(lr_sig, error, correction, tag="PES:correct")) if not conn.is_decoded: post = get_post_ens(conn) weights = model.sig[conn]['weights'] encoders = model.sig[post]['encoders'][:, conn.post_slice] # encoded = dot(encoders, correction) encoded = Signal(np.zeros(weights.shape[0]), name="PES:encoded") model.add_op(Reset(encoded)) model.add_op(DotInc(encoders, correction, encoded, tag="PES:encode")) local_error = encoded elif isinstance(conn.pre_obj, (Ensemble, Neurons)): local_error = correction else: raise BuildError("'pre' object '%s' not suitable for PES learning" % (conn.pre_obj)) # delta = local_error * activities model.add_op(Reset(model.sig[rule]['delta'])) model.add_op( ElementwiseInc(local_error.column(), acts.row(), model.sig[rule]['delta'], tag="PES:Inc Delta")) # expose these for probes model.sig[rule]['error'] = error model.sig[rule]['correction'] = correction model.sig[rule]['activities'] = acts
def build_mpes(model, mpes, rule): conn = rule.connection # Create input error signal error = Signal(shape=(rule.size_in, ), name="PES:error") model.add_op(Reset(error)) model.sig[rule]["in"] = error # error connection will attach here acts = build_or_passthrough(model, mpes.pre_synapse, model.sig[conn.pre_obj]["out"]) post = get_post_ens(conn) encoders = model.sig[post]["encoders"] out_size = encoders.shape[0] in_size = acts.shape[0] from scipy.stats import truncnorm def get_truncated_normal(mean, sd, low, upp): try: return truncnorm( (low - mean) / sd, (upp - mean) / sd, loc=mean, scale=sd ) \ .rvs( out_size * in_size ) \ .reshape( (out_size, in_size) ) except ZeroDivisionError: return np.full((out_size, in_size), mean) np.random.seed(mpes.seed) r_min_noisy = get_truncated_normal(mpes.r_min, mpes.r_min * mpes.noise_percentage[0], 0, np.inf) np.random.seed(mpes.seed) r_max_noisy = get_truncated_normal(mpes.r_max, mpes.r_max * mpes.noise_percentage[1], np.max(r_min_noisy), np.inf) np.random.seed(mpes.seed) exponent_noisy = np.random.normal( mpes.exponent, np.abs(mpes.exponent) * mpes.noise_percentage[2], (out_size, in_size)) np.random.seed(mpes.seed) pos_mem_initial = np.random.normal(1e8, 1e8 * mpes.noise_percentage[3], (out_size, in_size)) np.random.seed(mpes.seed + 1) neg_mem_initial = np.random.normal(1e8, 1e8 * mpes.noise_percentage[3], (out_size, in_size)) pos_memristors = Signal(shape=(out_size, in_size), name="mPES:pos_memristors", initial_value=pos_mem_initial) neg_memristors = Signal(shape=(out_size, in_size), name="mPES:neg_memristors", initial_value=neg_mem_initial) model.sig[conn]["pos_memristors"] = pos_memristors model.sig[conn]["neg_memristors"] = neg_memristors if conn.post_obj is not conn.post: # in order to avoid slicing encoders along an axis > 0, we pad # `error` out to the full base dimensionality and then do the # dotinc with the full encoder matrix # comes into effect when slicing post connection padded_error = Signal(shape=(encoders.shape[1], )) model.add_op(Copy(error, padded_error, dst_slice=conn.post_slice)) else: padded_error = error # error = dot(encoders, error) local_error = Signal(shape=(post.n_neurons, )) model.add_op(Reset(local_error)) model.add_op(DotInc(encoders, padded_error, local_error, tag="PES:encode")) model.operators.append( SimmPES(acts, local_error, mpes.learning_rate, model.sig[conn]["pos_memristors"], model.sig[conn]["neg_memristors"], model.sig[conn]["weights"], mpes.noise_percentage, mpes.gain, r_min_noisy, r_max_noisy, exponent_noisy)) # expose these for probes model.sig[rule]["error"] = error model.sig[rule]["activities"] = acts model.sig[rule]["pos_memristors"] = pos_memristors model.sig[rule]["neg_memristors"] = neg_memristors