def test_stateful(Simulator, sim_stateful, func_stateful, func): with Network() as net: config.configure_settings(stateful=sim_stateful) Ensemble(30, 1) with Simulator(net) as sim: kwargs = dict(n_steps=5, stateful=func_stateful) with pytest.warns(None) as recwarns: getattr(sim, func)(**kwargs) assert sim.n_steps == (5 if func_stateful and sim_stateful else 0) if func == "predict" and func_stateful and not sim_stateful: # note: we do not get warnings for predict_on_batch/run_steps because # they automatically set func_stateful=sim_stateful assert (len([ w for w in recwarns if "Ignoring stateful=True" in str(w.message) ]) > 0) else: assert len(recwarns) == 0 getattr(sim, func)(**kwargs) assert sim.n_steps == (10 if func_stateful and sim_stateful else 0)
def test_regular_spiking(Simulator, inference_only, seed): with nengo.Network() as net: config.configure_settings(inference_only=inference_only) inp = nengo.Node([1]) ens0 = nengo.Ensemble( 100, 1, neuron_type=nengo.SpikingRectifiedLinear(amplitude=2), seed=seed) ens1 = nengo.Ensemble( 100, 1, neuron_type=nengo.RegularSpiking(nengo.RectifiedLinear(), amplitude=2), seed=seed, ) nengo.Connection(inp, ens0) nengo.Connection(inp, ens1) p0 = nengo.Probe(ens0.neurons) p1 = nengo.Probe(ens1.neurons) with pytest.warns(None) as recwarns: with Simulator(net) as sim: sim.run_steps(50) assert np.allclose(sim.data[p0], sim.data[p1]) # check that it is actually using the tensorflow implementation assert not any("native TensorFlow implementation" in str(w.message) for w in recwarns)
def test_conditional_update(Simulator, use_loop, caplog): caplog.set_level(logging.INFO) with nengo.Network() as net: config.configure_settings(stateful=False, use_loop=use_loop) a = nengo.Ensemble(10, 1) b = nengo.Node(size_in=1) conn = nengo.Connection(a, b) with Simulator(net): pass assert "Number of state updates: 0" in caplog.text caplog.clear() conn.learning_rule_type = nengo.PES() with Simulator(net): pass assert "Number of state updates: 1" in caplog.text caplog.clear() with net: config.configure_settings(trainable=True) with Simulator(net): pass assert "Number of state updates: 1" in caplog.text
def test_densenet(Simulator, seed): tf.random.set_seed(seed) model = tf.keras.applications.densenet.DenseNet121(weights=None, include_top=False, input_shape=(112, 112, 3)) conv = converter.Converter(model, allow_fallback=False, max_to_avg_pool=True, inference_only=True) keras_params = 0 for layer in model.layers: if not isinstance(layer, BatchNormalization): for w in layer._trainable_weights: keras_params += np.prod(w.shape) # note: we don't expect any of the verification checks to pass, due to the # max_to_avg_pool swap, so just checking that the network structure has been # recreated with conv.net: # undo the inference_only=True so that parameters will be marked as # trainable (so that the check below will work) config.configure_settings(inference_only=False) with Simulator(conv.net) as sim: assert keras_params == sum( np.prod(w.shape) for w in sim.keras_model.trainable_weights)
def test_learning_phase_warning(Simulator): with nengo.Network() as net: config.configure_settings(inference_only=True) with pytest.raises(BuildError, match="inference_only=True"): with tf.keras.backend.learning_phase_scope(1): with Simulator(net): pass
def test_soft_lif(Simulator, sigma, seed): with nengo.Network(seed=seed) as net: inp = nengo.Node([0.5]) ens = nengo.Ensemble(10, 1, neuron_type=SoftLIFRate(sigma=sigma), intercepts=nengo.dists.Uniform(-1, 0), encoders=nengo.dists.Choice([[1]])) nengo.Connection(inp, ens) p = nengo.Probe(ens.neurons) x = str(ens.neuron_type) if sigma == 1: assert "sigma" not in x else: assert "sigma=%s" % sigma in x with nengo.Simulator(net) as sim: _, nengo_curves = nengo.utils.ensemble.tuning_curves(ens, sim) sim.run_steps(30) with net: config.configure_settings(dtype=tf.float64) with Simulator(net) as sim2: _, nengo_dl_curves = nengo.utils.ensemble.tuning_curves(ens, sim2) sim2.run_steps(30) assert np.allclose(nengo_curves, nengo_dl_curves) assert np.allclose(sim.data[p], sim2.data[p])
def test_soft_lif(Simulator, sigma, seed): with nengo.Network(seed=seed) as net: inp = nengo.Node([0.5]) ens = nengo.Ensemble( 10, 1, neuron_type=SoftLIFRate(sigma=sigma), intercepts=nengo.dists.Uniform(-1, 0), encoders=nengo.dists.Choice([[1]]), ) nengo.Connection(inp, ens) p = nengo.Probe(ens.neurons) x = str(ens.neuron_type) if sigma == 1: assert "sigma" not in x else: assert "sigma=%s" % sigma in x with nengo.Simulator(net) as sim: _, nengo_curves = nengo.utils.ensemble.tuning_curves(ens, sim) sim.run_steps(30) with net: config.configure_settings(dtype="float64") with Simulator(net) as sim2: _, nengo_dl_curves = nengo.utils.ensemble.tuning_curves(ens, sim2) sim2.run_steps(30) assert np.allclose(nengo_curves, nengo_dl_curves) assert np.allclose(sim.data[p], sim2.data[p])
def test_get_tensor(Simulator, use_loop): with nengo.Network() as net: config.configure_settings(use_loop=use_loop) a = nengo.Node([1]) b = nengo.Ensemble(10, 1) c = nengo.Connection(a, b.neurons, transform=np.arange(10)[:, None], synapse=None) p = nengo.Probe(c) # build a signal probe so that the indices get loaded into the sim # (checks that the indices reloading works properly) nengo.Probe(c, "weights") kwargs = dict() if use_loop else dict(unroll_simulation=10) with Simulator(net, **kwargs) as sim: tensor = sim.tensor_graph.get_tensor(sim.model.sig[c]["weights"]) assert np.allclose(tf.keras.backend.get_value(tensor), np.arange(10)[:, None]) sim.run_steps(10) assert np.allclose(sim.data[p], np.arange(10)[None, :])
def TestSimulator(net, *args, **kwargs): kwargs.setdefault("unroll_simulation", unroll) kwargs.setdefault("device", device) if net is not None and config.get_setting(net, "inference_only") is None: with net: config.configure_settings(inference_only=inference_only) if net is not None and config.get_setting(net, "dtype") is None: with net: config.configure_settings(dtype=dtype) return simulator.Simulator(net, *args, **kwargs)
def test_spiking_swap(Simulator, rate, spiking, seed): grads = [] for neuron_type in [rate, spiking]: with nengo.Network(seed=seed) as net: config.configure_settings(dtype="float64") if rate == SoftLIFRate and neuron_type == spiking: config.configure_settings(lif_smoothing=1.0) a = nengo.Node(output=[1]) b = nengo.Ensemble(50, 1, neuron_type=neuron_type()) c = nengo.Ensemble(50, 1, neuron_type=neuron_type(amplitude=0.1)) nengo.Connection(a, b, synapse=None) # note: we avoid decoders, as the rate/spiking models may have # different rate implementations in nengo, resulting in different # decoders nengo.Connection(b.neurons, c.neurons, synapse=None, transform=dists.He()) p = nengo.Probe(c.neurons) with Simulator(net) as sim: if not sim.tensor_graph.inference_only: # TODO: this works in eager mode # with tf.GradientTape() as tape: # tape.watch(sim.tensor_graph.trainable_variables) # inputs = [ # tf.zeros((1, sim.unroll * 2, 1)), # tf.constant([[sim.unroll * 2]]), # ] # outputs = sim.tensor_graph(inputs, training=True) # g = tape.gradient(outputs, sim.tensor_graph.trainable_variables) # note: not actually checking gradients, just using this to get the # gradients # TODO: why does the gradient check fail? if not sim.tensor_graph.inference_only: g = sim.check_gradients(atol=1e10)[p]["analytic"] grads.append(g) sim.run(0.5) # check that the normal output is unaffected by the swap logic with nengo.Simulator(net) as sim2: sim2.run(0.5) assert np.allclose(sim.data[p], sim2.data[p]) # check that the gradients match assert all(np.allclose(g0, g1) for g0, g1 in zip(*grads))
def test_spiking_swap(Simulator, rate, spiking, seed): grads = [] for neuron_type in [rate, spiking]: with nengo.Network(seed=seed) as net: config.configure_settings(dtype="float64") if rate == SoftLIFRate and neuron_type == spiking: config.configure_settings(lif_smoothing=1.0) a = nengo.Node(output=[1]) b = nengo.Ensemble(50, 1, neuron_type=neuron_type()) c = nengo.Ensemble(50, 1, neuron_type=neuron_type(amplitude=0.1)) nengo.Connection(a, b, synapse=None) # note: we avoid decoders, as the rate/spiking models may have # different rate implementations in nengo, resulting in different # decoders nengo.Connection(b.neurons, c.neurons, synapse=None, transform=dists.He()) p = nengo.Probe(c.neurons) with Simulator(net) as sim: if not sim.tensor_graph.inference_only: with tf.GradientTape() as tape: tape.watch(sim.tensor_graph.trainable_variables) inputs = [ tf.zeros((1, sim.unroll * 2, 1)), tf.constant([[sim.unroll * 2]]), ] outputs = sim.tensor_graph(inputs, training=True) g = tape.gradient(outputs, sim.tensor_graph.trainable_variables) grads.append(g) sim.run(0.5) # check that the normal output is unaffected by the swap logic with nengo.Simulator(net) as sim2: sim2.run(0.5) if not isinstance(neuron_type(), compat.PoissonSpiking): # we don't expect these to match for poissonspiking, since we have # different rng implementations in numpy vs tensorflow assert np.allclose(sim.data[p], sim2.data[p]) # check that the gradients match assert all(np.allclose(g0, g1) for g0, g1 in zip(*grads))
def test_keep_history(Simulator, seed): with Network(seed=seed) as net: config.configure_settings(keep_history=True) a = Ensemble(30, 1) p = Probe(a.neurons, synapse=0.1) with Simulator(net) as sim: sim.run_steps(10) with net: net.config[p].keep_history = False with Simulator(net) as sim2: sim2.run_steps(10) assert sim.data[p].shape == (10, 30) assert sim2.data[p].shape == (1, 30) assert np.allclose(sim.data[p][[-1]], sim2.data[p])
def test_session_config(Simulator, as_model): with Network() as net: config.configure_settings(session_config={ "graph_options.optimizer_options.opt_level": 21, "gpu_options.allow_growth": True}) if as_model: # checking that config settings work when we pass in a model instead of # network model = Model(dt=0.001, builder=builder.NengoBuilder()) model.build(net) net = None else: model = None with Simulator(net, model=model) as sim: assert sim.sess._config.graph_options.optimizer_options.opt_level == 21 assert sim.sess._config.gpu_options.allow_growth
def test_keep_history(Simulator, seed): with Network(seed=seed) as net: config.configure_settings(keep_history=True) a = Ensemble(30, 1) p = Probe(a.neurons, synapse=0.1) with Simulator(net) as sim: sim.run_steps(10) with net: net.config[p].keep_history = False with Simulator(net) as sim2: sim2.run_steps(10) assert sim.data[p].shape == (10, 30) assert sim2.data[p].shape == (1, 30) assert np.allclose(sim.data[p][[-1]], sim2.data[p])
def test_simulator_fixture(Simulator, pytestconfig): with Simulator(nengo.Network()) as sim: assert sim.tensor_graph.dtype == ( tf.float32 if pytestconfig.getoption("--dtype") == "float32" else tf.float64) assert sim.unroll == pytestconfig.getoption("--unroll-simulation") assert sim.tensor_graph.device == pytestconfig.getoption("--device") assert (config.get_setting(sim.model, "inference_only") == pytestconfig.getoption("--inference-only")) # check that manually specified values aren't overridden with nengo.Network() as net: config.configure_settings(dtype=tf.float64, inference_only=True) with Simulator(net, unroll_simulation=5, device="/cpu:0") as sim: assert sim.tensor_graph.dtype == tf.float64 assert sim.unroll == 5 assert sim.tensor_graph.device == "/cpu:0" assert config.get_setting(sim.model, "inference_only")
def test_keep_history(Simulator, use_loop, seed): with Network(seed=seed) as net: config.configure_settings(keep_history=True, use_loop=use_loop) a = Ensemble(30, 1) p = Probe(a.neurons, synapse=0.1) kwargs = dict() if use_loop else dict(unroll_simulation=10) with Simulator(net, **kwargs) as sim: sim.run_steps(10) with net: net.config[p].keep_history = False with Simulator(net, **kwargs) as sim2: sim2.run_steps(10) assert sim.data[p].shape == (10, 30) assert sim2.data[p].shape == (1, 30) assert np.allclose(sim.data[p][[-1]], sim2.data[p])
def test_random_spiking(Simulator, inference_only, seed): with nengo.Network() as net: config.configure_settings(inference_only=inference_only) inp = nengo.Node([1]) ens0 = nengo.Ensemble(100, 1, neuron_type=nengo.Tanh(), seed=seed) ens1 = nengo.Ensemble( 100, 1, neuron_type=nengo.StochasticSpiking(nengo.Tanh()), seed=seed, ) ens2 = nengo.Ensemble( 100, 1, neuron_type=nengo.PoissonSpiking(nengo.Tanh()), seed=seed, ) nengo.Connection(inp, ens0, synapse=None) nengo.Connection(inp, ens1, synapse=None) nengo.Connection(inp, ens2, synapse=None) p0 = nengo.Probe(ens0.neurons) p1 = nengo.Probe(ens1.neurons) p2 = nengo.Probe(ens2.neurons) with pytest.warns(None) as recwarns: with Simulator(net, seed=seed) as sim: sim.run_steps(10000) assert not any("native TensorFlow implementation" in str(w.message) for w in recwarns) assert np.allclose(sim.data[p0][0], np.mean(sim.data[p1], axis=0), atol=1, rtol=2e-1) assert np.allclose(sim.data[p0], np.mean(sim.data[p2], axis=0), atol=1, rtol=1e-1)
def test_session_config(Simulator, as_model): with Network() as net: config.configure_settings( session_config={ "graph_options.optimizer_options.opt_level": 21, "gpu_options.allow_growth": True }) if as_model: # checking that config settings work when we pass in a model instead of # network model = Model(dt=0.001, builder=builder.NengoBuilder()) model.build(net) net = None else: model = None with Simulator(net, model=model) as sim: assert sim.sess._config.graph_options.optimizer_options.opt_level == 21 assert sim.sess._config.gpu_options.allow_growth
def test_neuron_gradients(Simulator, neuron_type, seed, rng): # avoid intercepts around zero, which can cause errors in the # finite differencing in check_gradients intercepts = np.concatenate( (rng.uniform(-0.5, -0.2, size=25), rng.uniform(0.2, 0.5, size=25)) ) kwargs = {"sigma": 0.1} if neuron_type == SoftLIFRate else {} with nengo.Network(seed=seed) as net: config.configure_settings(dtype="float64") net.config[nengo.Ensemble].intercepts = intercepts a = nengo.Node(output=[0, 0]) b = nengo.Ensemble(50, 2, neuron_type=neuron_type(**kwargs)) c = nengo.Ensemble(50, 2, neuron_type=neuron_type(amplitude=0.1, **kwargs)) nengo.Connection(a, b, synapse=None) nengo.Connection(b, c, synapse=None) nengo.Probe(c) with Simulator(net, seed=seed) as sim: sim.check_gradients()
def test_configure_trainable(): with Network() as net: conf = net.config config.configure_settings(trainable=None) assert conf[Ensemble].trainable is None assert conf[Connection].trainable is None assert conf[ensemble.Neurons].trainable is None # check that we can set trainable after it is set up for configuration conf[Ensemble].trainable = True # check that boolean value is enforced with pytest.raises(ValidationError): conf[Ensemble].trainable = 5 assert conf[Ensemble].trainable is True # check that calling configure again overrides previous changes with net: config.configure_settings(trainable=None) assert conf[Ensemble].trainable is None # check that non-None defaults work with net: config.configure_settings(trainable=False) assert conf[Ensemble].trainable is False # check that calling configure outside network context is an error with pytest.raises(NetworkContextError): config.configure_settings(trainable=None) # check that passing an invalid parameter raises an error with net: with pytest.raises(ConfigError): config.configure_settings(troinable=None)
def test_configure_trainable(): with Network() as net: conf = net.config config.configure_settings(trainable=None) assert conf[Ensemble].trainable is None assert conf[Connection].trainable is None assert conf[ensemble.Neurons].trainable is None # check that we can set trainable after it is set up for configuration conf[Ensemble].trainable = True # check that boolean value is enforced with pytest.raises(ValidationError): conf[Ensemble].trainable = 5 assert conf[Ensemble].trainable is True # check that calling configure again overrides previous changes with net: config.configure_settings(trainable=None) assert conf[Ensemble].trainable is None # check that non-None defaults work with net: config.configure_settings(trainable=False) assert conf[Ensemble].trainable is False # check that calling configure outside network context is an error with pytest.raises(NetworkContextError): config.configure_settings(trainable=None) # check that passing an invalid parameter raises an error with net: with pytest.raises(ConfigError): config.configure_settings(troinable=None)
def test_spiking_swap(Simulator, rate, spiking, seed): grads = [] for neuron_type in [rate, spiking]: with nengo.Network(seed=seed) as net: config.configure_settings(dtype=tf.float64) if rate == SoftLIFRate and neuron_type == spiking: config.configure_settings(lif_smoothing=1.0) a = nengo.Node(output=[1]) b = nengo.Ensemble(50, 1, neuron_type=neuron_type()) c = nengo.Ensemble(50, 1, neuron_type=neuron_type(amplitude=0.1)) nengo.Connection(a, b, synapse=None) # note: we avoid decoders, as the rate/spiking models may have # different rate implementations in nengo, resulting in different # decoders nengo.Connection(b.neurons, c.neurons, synapse=None, transform=dists.He()) p = nengo.Probe(c.neurons) with Simulator(net) as sim: grads.append(sim.sess.run( tf.gradients(sim.tensor_graph.probe_arrays[p], tf.trainable_variables()), feed_dict=sim._fill_feed(10, training=True))) sim.soft_reset() sim.run(0.5) # check that the normal output is unaffected by the swap logic with nengo.Simulator(net) as sim2: sim2.run(0.5) assert np.allclose(sim.data[p], sim2.data[p]) # check that the gradients match assert all(np.allclose(g0, g1) for g0, g1 in zip(*grads))
def test_learning_phase(Simulator): with nengo.Network() as net: inp = nengo.Node([0]) ens = nengo.Ensemble(1, 1, gain=[0], bias=[1], neuron_type=nengo.SpikingRectifiedLinear()) nengo.Connection(inp, ens, synapse=None) p = nengo.Probe(ens.neurons) with net: config.configure_settings(learning_phase=True) with Simulator(net) as sim: sim.run_steps(10) assert np.allclose(sim.data[p], 1) with net: config.configure_settings(learning_phase=None) with Simulator(net) as sim: sim.run_steps(10) assert np.allclose(sim.data[p], 0)
def __call__( self, input, transform=default_transform, shape_in=None, synapse=None, return_conn=False, **layer_args ): """ Apply the TensorNode layer to the given input object. Parameters ---------- input : ``NengoObject`` Object providing input to the layer. transform : `~numpy.ndarray` Transform matrix to apply on connection from ``input`` to this layer. shape_in : tuple of int If not None, reshape the input to the given shape. synapse : float or `~nengo.synapses.Synapse` Synapse to apply on connection from ``input`` to this layer. return_conn : bool If True, also return the connection linking this layer to ``input``. layer_args : dict These arguments will be passed to `.TensorNode` if ``layer_func`` is a callable or Keras Layer, or `~nengo.Ensemble` if ``layer_func`` is a `~nengo.neurons.NeuronType`. Returns ------- obj : `.TensorNode` or `~nengo.ensemble.Neurons` A TensorNode that implements the given layer function (if ``layer_func`` was a callable/Keras layer), or a Neuron object with the given neuron type, connected to ``input``. conn : `~nengo.Connection` If ``return_conn`` is True, also returns the connection object linking ``input`` and ``obj``. Notes ----- The input connection created for the new TensorNode will be marked as non-trainable by default. """ if shape_in is not None and all(x is not None for x in shape_in): size_in = np.prod(shape_in) elif isinstance(transform, np.ndarray) and transform.ndim == 2: size_in = transform.shape[0] else: size_in = input.size_out if isinstance(self.layer_func, NeuronType): obj = Ensemble( size_in, 1, neuron_type=self.layer_func, **layer_args ).neurons else: obj = TensorNode( self.layer_func, shape_in=(size_in,) if shape_in is None else shape_in, pass_time=False, **layer_args, ) conn = Connection(input, obj, synapse=synapse, transform=transform) # set connection to non-trainable cfg = Config.context[0][conn] if not hasattr(cfg, "trainable"): configure_settings(trainable=None) cfg.trainable = False return (obj, conn) if return_conn else obj
def test_mark_signals_config(): with nengo.Network() as net: config.configure_settings(trainable=None) net.config[nengo.Ensemble].trainable = False with nengo.Network(): # check that object in subnetwork inherits config from parent ens0 = nengo.Ensemble(10, 1, label="ens0") # check that ens.neurons can be set independent of ens net.config[ens0.neurons].trainable = True with nengo.Network(): with nengo.Network() as subnet: # check that subnetworks can override parent configs # net.config[nengo.Ensemble].trainable = True net.config[subnet].trainable = True ens1 = nengo.Ensemble(10, 1, label="ens1") with nengo.Network(): # check that subnetworks inherit the trainable settings # from parent networks ens3 = nengo.Ensemble(10, 1, label="ens3") # check that instances can be set independent of class ens2 = nengo.Ensemble(10, 1, label="ens2") net.config[ens2].trainable = True model = nengo.builder.Model() model.build(net) progress = utils.NullProgressBar() tg = tensor_graph.TensorGraph(model, None, None, tf.float32, 1, None, progress) tg.mark_signals() assert not model.sig[ens0]["encoders"].trainable assert model.sig[ens0.neurons]["bias"].trainable assert model.sig[ens1]["encoders"].trainable assert model.sig[ens2]["encoders"].trainable assert model.sig[ens3]["encoders"].trainable # check that learning rule connections can be manually set to True with nengo.Network() as net: config.configure_settings(trainable=None) a = nengo.Ensemble(10, 1) b = nengo.Ensemble(10, 1) conn0 = nengo.Connection(a, b, learning_rule_type=nengo.PES()) net.config[conn0].trainable = True model = nengo.builder.Model() model.build(net) tg = tensor_graph.TensorGraph(model, None, None, tf.float32, 1, None, progress) with pytest.warns(UserWarning): tg.mark_signals() assert model.sig[conn0]["weights"].trainable with nengo.Network() as net: config.configure_settings(trainable=None) a = nengo.Node([0]) ens = nengo.Ensemble(10, 1) nengo.Connection(a, ens, learning_rule_type=nengo.Voja()) net.config[nengo.Ensemble].trainable = True model = nengo.builder.Model() model.build(net) tg = tensor_graph.TensorGraph(model, None, None, tf.float32, 1, None, progress) with pytest.warns(UserWarning): tg.mark_signals() assert model.sig[ens]["encoders"].trainable # check that models with no toplevel work sig = nengo.builder.signal.Signal([0]) op = nengo.builder.operator.Reset(sig, 1) model = nengo.builder.Model() model.add_op(op) tg = tensor_graph.TensorGraph(model, None, None, tf.float32, 1, None, progress) with pytest.warns(UserWarning): tg.mark_signals() assert not sig.trainable
def test_remove_reset_inc_functional(Simulator, seed): with nengo.Network(seed=seed) as net: config.configure_settings( simplifications=[remove_zero_incs, remove_unmodified_resets]) # reset+simprocess on the noise ens = nengo.Ensemble(1, 1, noise=nengo.processes.WhiteNoise(), neuron_type=nengo.Direct()) node0 = nengo.Node(size_in=1, label="node0") # reset+elementwiseinc (weights) # reset+copy (to node input) nengo.Connection(ens, node0, transform=1, synapse=None) node1 = nengo.Node(size_in=3, label="node1") # reset+dotinc (weights) # reset+copy (to node input) nengo.Connection(node0, node1, transform=np.ones((3, 1)), synapse=None) # reset+elementwiseinc (weights, in nengo<3.1) # reset+copy (to probe input) p = nengo.Probe(node1) with Simulator(net) as sim: extra_op = LooseVersion(nengo.__version__) < "3.1.0" assert len(sim.tensor_graph.plan) == 8 + extra_op # check that we have all the resets we expect resets = sim.tensor_graph.plan[1] assert isinstance(resets[0], Reset) assert len(resets) == 6 + extra_op # check that all the ops are incs like we expect incs = sim.tensor_graph.plan[2:] for ops in incs: for op in ops: assert len(op.incs) == 1 assert len(op.sets) == 0 sim.run_steps(100) with net: config.configure_settings(simplifications=[ remove_zero_incs, remove_unmodified_resets, remove_reset_incs, ]) with Simulator(net) as sim_remove: # check that resets have been removed assert len(sim_remove.tensor_graph.plan) == 7 + extra_op assert (len([ x for x in sim_remove.tensor_graph.plan if isinstance(x[0], Reset) ]) == 0) # check that all the ops are sets like we expect incs = sim_remove.tensor_graph.plan[1:] for ops in incs: for op in ops: assert len(op.incs) == 0 assert len(op.sets) == 1 sim_remove.run_steps(100) assert np.allclose(sim.data[p], sim_remove.data[p])
def test_mark_signals_config(): with nengo.Network() as net: config.configure_settings(trainable=None) net.config[nengo.Ensemble].trainable = False with nengo.Network(): # check that object in subnetwork inherits config from parent ens0 = nengo.Ensemble(10, 1, label="ens0") # check that ens.neurons can be set independent of ens net.config[ens0.neurons].trainable = True with nengo.Network(): with nengo.Network(): # check that subnetworks can override parent configs config.configure_settings(trainable=True) ens1 = nengo.Ensemble(10, 1, label="ens1") with nengo.Network(): # check that subnetworks inherit the trainable settings # from parent networks ens3 = nengo.Ensemble(10, 1, label="ens3") # check that instances can be set independent of class ens2 = nengo.Ensemble(10, 1, label="ens2") net.config[ens2].trainable = True model = nengo.builder.Model() model.build(net) progress = utils.NullProgressBar() tg = tensor_graph.TensorGraph(model, None, None, 1, None, progress, None) tg.mark_signals() assert not model.sig[ens0]["encoders"].trainable assert model.sig[ens0.neurons]["bias"].trainable assert model.sig[ens1]["encoders"].trainable assert model.sig[ens2]["encoders"].trainable assert model.sig[ens3]["encoders"].trainable # check that learning rule connections can be manually set to True with nengo.Network() as net: config.configure_settings(trainable=None) a = nengo.Ensemble(10, 1) b = nengo.Ensemble(10, 1) conn0 = nengo.Connection(a, b, learning_rule_type=nengo.PES()) net.config[conn0].trainable = True model = nengo.builder.Model() model.build(net) tg = tensor_graph.TensorGraph(model, None, None, 1, None, progress, None) with pytest.warns(UserWarning): tg.mark_signals() assert model.sig[conn0]["weights"].trainable with nengo.Network() as net: config.configure_settings(trainable=None) a = nengo.Node([0]) ens = nengo.Ensemble(10, 1) nengo.Connection(a, ens, learning_rule_type=nengo.Voja()) net.config[nengo.Ensemble].trainable = True model = nengo.builder.Model() model.build(net) tg = tensor_graph.TensorGraph(model, None, None, 1, None, progress, None) with pytest.warns(UserWarning): tg.mark_signals() assert model.sig[ens]["encoders"].trainable # check that models with no toplevel work sig = nengo.builder.signal.Signal([0]) op = nengo.builder.operator.Reset(sig, 1) model = nengo.builder.Model() model.add_op(op) tg = tensor_graph.TensorGraph(model, None, None, 1, None, progress, None) with pytest.warns(UserWarning): tg.mark_signals() assert not sig.trainable