String representations

This should be an exhaustive list of the objects that can be created with Nengo, and their string representations.

In [1]:
import numpy as np
import nengo

Core objects

In [2]:
with nengo.Network() as net1:

    a = nengo.Ensemble(100, 2)
    with nengo.Network(label="net2") as net2:
        b = nengo.Ensemble(100, 2, label="b")

    ap = nengo.Probe(a)
    bp = nengo.Probe(b)

    c1 = nengo.Connection(a, b)
    c2 = nengo.Connection(a, b, function=np.square)

    n1 = nengo.Node(output=np.sin)
    n2 = nengo.Node(output=np.cos, label="n2")

print("  str(obj)")
print("============")
print("--- Network")
print("    %s" % net1)
print("    %s" % net2)
print("--- Ensemble")
print("    %s" % a)
print("    %s" % b)
print("--- Probe")
print("    %s" % ap)
print("    %s" % bp)
print("--- Connection")
print("    %s" % c1)
print("    %s" % c2)
print("--- Node")
print("    %s" % n1)
print("    %s" % n2)
print("--- Neurons")
print("    %s" % a.neurons)
print("--- ObjView")
print("    %s" % b[:1])
print("")

print("  repr(obj)  ")
print("=============")
print("--- Network")
print("    %r" % net1)
print("    %r" % net2)
print("--- Ensemble")
print("    %r" % a)
print("    %r" % b)
print("--- Probe")
print("    %r" % ap)
print("    %r" % bp)
print("--- Connection")
print("    %r" % c1)
print("    %r" % c2)
print("--- Node")
print("    %r" % n1)
print("    %r" % n2)
print("--- Neurons")
print("    %r" % a.neurons)
print("--- ObjView")
print("    %r" % b[:1])
  str(obj)
============
--- Network
    <Network (unlabeled) at 0x7f4202fd0320>
    <Network "net2">
--- Ensemble
    <Ensemble (unlabeled) at 0x7f4202fd0390>
    <Ensemble "b">
--- Probe
    <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>
    <Probe of 'decoded_output' of <Ensemble "b">>
--- Connection
    <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>
    <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>
--- Node
    <Node (unlabeled) at 0x7f42038a7828>
    <Node "n2">
--- Neurons
    <Neurons of <Ensemble (unlabeled) at 0x7f4202fd0390>>
--- ObjView
    <Ensemble "b">[:1]

  repr(obj)
=============
--- Network
    <Network (unlabeled) at 0x7f4202fd0320>
    <Network "net2" at 0x7f4202fd04a8>
--- Ensemble
    <Ensemble (unlabeled) at 0x7f4202fd0390>
    <Ensemble "b" at 0x7f4202fd0518>
--- Probe
    <Probe at 0x7f4202fd0630 of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>
    <Probe at 0x7f4202fd0668 of 'decoded_output' of <Ensemble "b">>
--- Connection
    <Connection at 0x7f4202fd06a0 from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>
    <Connection at 0x7f42131f7128 from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>
--- Node
    <Node (unlabeled) at 0x7f42038a7828>
    <Node "n2" at 0x7f4217431fd0>
--- Neurons
    <Neurons at 0x7f4213208128 of <Ensemble (unlabeled) at 0x7f4202fd0390>>
--- ObjView
    <Ensemble "b" at 0x7f4202fd0518>[:1]

Neuron types

In [3]:
print(nengo.Direct())
print(nengo.RectifiedLinear())
print(nengo.Sigmoid())
print(nengo.Sigmoid(tau_ref=0.001))
print(nengo.LIFRate())
print(nengo.LIFRate(tau_rc=0.01, tau_ref=0))
print(nengo.LIF())
print(nengo.LIF(tau_rc=0.01, tau_ref=0))
print(nengo.AdaptiveLIFRate())
print(nengo.AdaptiveLIFRate(tau_rc=0.01, tau_n=0.5, inc_n=0.02))
print(nengo.AdaptiveLIF())
print(nengo.AdaptiveLIF(tau_rc=0.01, tau_n=0.5, inc_n=0.02))
print(nengo.Izhikevich())
print(
    nengo.Izhikevich(
        tau_recovery=0.01, coupling=0.5, reset_voltage=-60, reset_recovery=6))
Direct()
RectifiedLinear()
Sigmoid()
Sigmoid(tau_ref=0.001)
LIFRate()
LIFRate(tau_rc=0.01, tau_ref=0)
LIF()
LIF(tau_rc=0.01, tau_ref=0)
AdaptiveLIFRate()
AdaptiveLIFRate(tau_rc=0.01, tau_n=0.5, inc_n=0.02)
AdaptiveLIF()
AdaptiveLIF(tau_rc=0.01, tau_n=0.5, inc_n=0.02)
Izhikevich()
Izhikevich(tau_recovery=0.01, coupling=0.5, reset_voltage=-60, reset_recovery=6)

Learning rules

In [4]:
print(nengo.PES())
print(nengo.PES(learning_rate=1e-6, pre_synapse=0.01))
print(nengo.BCM())
print(nengo.BCM(
    learning_rate=1e-8, pre_synapse=0.01, post_synapse=0.005, theta_synapse=10.0))
print(nengo.Oja())
print(nengo.Oja(learning_rate=1e-5, pre_synapse=0.01, post_synapse=0.005, beta=0.5))
print(nengo.Voja())
print(nengo.Voja(learning_rate=1e-5, post_synapse=None))
PES()
PES(learning_rate=1e-06, pre_synapse=Lowpass(0.01))
BCM()
BCM(learning_rate=1e-08, pre_synapse=Lowpass(0.01), post_synapse=Lowpass(0.005), theta_synapse=Lowpass(10.0))
Oja()
Oja(learning_rate=1e-05, pre_synapse=Lowpass(0.01), post_synapse=Lowpass(0.005), beta=0.5)
Voja()
Voja(learning_rate=1e-05, post_synapse=None)

Distributions

In [5]:
print(nengo.dists.PDF([1, 2], [0.4, 0.6]))
print(nengo.dists.Uniform(0, 1))
print(nengo.dists.Uniform(0, 5, integer=True))
print(nengo.dists.Gaussian(1, 0.1))
print(nengo.dists.UniformHypersphere())
print(nengo.dists.UniformHypersphere(surface=True))
print(nengo.dists.Choice([1, 2, 3]))
print(nengo.dists.Choice([1, 2, 3], weights=[0.1, 0.5, 0.4]))
print(nengo.dists.SqrtBeta(3))
print(nengo.dists.SqrtBeta(3, 2))
print(nengo.dists.SubvectorLength(3))
PDF(x=array([1., 2.]), p=array([0.4, 0.6]))
Uniform(low=0, high=1)
Uniform(low=0, high=5, integer=True)
Gaussian(mean=1, std=0.1)
UniformHypersphere()
UniformHypersphere(surface=True)
Choice(options=array([1., 2., 3.]))
Choice(options=array([1., 2., 3.]), weights=array([0.1, 0.5, 0.4]))
SqrtBeta(n=3, m=1)
SqrtBeta(n=3, m=2)
SubvectorLength(3, subdimensions=1)

Synapses

In [6]:
print(nengo.synapses.Lowpass(0.01))
print(nengo.synapses.Alpha(0.02))
print(nengo.synapses.Triangle(0.03))
print(nengo.synapses.LinearFilter([1], [0.03, 1]))
Lowpass(0.01)
Alpha(0.02)
Triangle(0.03)
LinearFilter([1.], [0.03 1.  ], analog=True)

Processes

In [7]:
gaussian = nengo.dists.Gaussian(1, 2)
print(nengo.processes.WhiteNoise(gaussian, scale=False))
print(nengo.processes.FilteredNoise(nengo.synapses.Alpha(0.2), gaussian))
print(nengo.processes.BrownNoise(gaussian))
print(nengo.processes.WhiteSignal(0.2, 10, rms=0.3))
WhiteNoise(Gaussian(mean=1, std=2), scale=False)
FilteredNoise(synapse=Alpha(0.2), dist=Gaussian(mean=1, std=2), scale=True)
BrownNoise(Gaussian(mean=1, std=2))
WhiteSignal(period=0.2, high=10, rms=0.3)

Signals

In [8]:
print(nengo.builder.signal.Signal(np.array([0.])))
print(nengo.builder.signal.Signal(np.array([1., 1.]), name="one"))
Signal(None, shape=(1,))
Signal(one, shape=(2,))

Operators

In [9]:
sig = nengo.builder.signal.Signal(np.array([0.]), name="sig")
print(nengo.builder.operator.TimeUpdate(sig, sig))
print(nengo.builder.operator.TimeUpdate(sig, sig, tag="tag"))
print(nengo.builder.operator.Reset(sig))
print(nengo.builder.operator.Reset(sig, tag="tag"))
print(nengo.builder.operator.Copy(sig, sig))
print(nengo.builder.operator.Copy(sig, sig, tag="tag"))
print(nengo.builder.operator.Copy(sig, sig, [0], slice(0, 1)))
print(nengo.builder.operator.Copy(sig, sig, [0], slice(0, 1), tag="tag"))
print(nengo.builder.operator.ElementwiseInc(sig, sig, sig))
print(nengo.builder.operator.ElementwiseInc(sig, sig, sig, tag="tag"))
print(nengo.builder.operator.DotInc(sig, sig, sig))
print(nengo.builder.operator.DotInc(sig, sig, sig, tag="tag"))
print(nengo.builder.operator.SimPyFunc(sig, lambda x: 0.0, True, sig))
print(nengo.builder.operator.SimPyFunc(sig, lambda x: 0.0, True, sig, tag="tag"))
print(nengo.builder.learning_rules.SimBCM(sig, sig, sig, sig, 0.1))
print(nengo.builder.learning_rules.SimBCM(sig, sig, sig, sig, 0.1, tag="tag"))
print(nengo.builder.learning_rules.SimOja(sig, sig, sig, sig, 0.1, 1.0))
print(nengo.builder.learning_rules.SimOja(
    sig, sig, sig, sig, 0.1, 1.0, tag="tag"))
print(nengo.builder.neurons.SimNeurons(nengo.LIF(), sig, sig, [sig]))
print(nengo.builder.neurons.SimNeurons(nengo.LIF(), sig, sig, [sig], tag="tag"))
print(nengo.builder.processes.SimProcess(
    nengo.processes.WhiteNoise(), sig, sig, sig))
print(nengo.builder.processes.SimProcess(
    nengo.processes.WhiteNoise(), sig, sig, sig, tag="tag"))
TimeUpdate{}
TimeUpdate{ "tag"}
Reset{Signal(sig, shape=(1,))}
Reset{Signal(sig, shape=(1,))  "tag"}
Copy{Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,)), inc=False}
Copy{Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,)), inc=False  "tag"}
Copy{Signal(sig, shape=(1,))[[0]] -> Signal(sig[(slice(0, 1, None),)], shape=(1,)), inc=False}
Copy{Signal(sig, shape=(1,))[[0]] -> Signal(sig[(slice(0, 1, None),)], shape=(1,)), inc=False  "tag"}
ElementwiseInc{Signal(sig, shape=(1,)), Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))}
ElementwiseInc{Signal(sig, shape=(1,)), Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))  "tag"}
DotInc{Signal(sig, shape=(1,)), Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))}
DotInc{Signal(sig, shape=(1,)), Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))  "tag"}
SimPyFunc{Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,)), fn='<lambda>'}
SimPyFunc{Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,)), fn='<lambda>'  "tag"}
SimBCM{pre=Signal(sig, shape=(1,)), post=Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))}
SimBCM{pre=Signal(sig, shape=(1,)), post=Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))  "tag"}
SimOja{pre=Signal(sig, shape=(1,)), post=Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))}
SimOja{pre=Signal(sig, shape=(1,)), post=Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))  "tag"}
SimNeurons{LIF(), Signal(sig, shape=(1,)), Signal(sig, shape=(1,))}
SimNeurons{LIF(), Signal(sig, shape=(1,)), Signal(sig, shape=(1,))  "tag"}
SimProcess{WhiteNoise(Gaussian(mean=0, std=1), scale=True), Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))}
SimProcess{WhiteNoise(Gaussian(mean=0, std=1), scale=True), Signal(sig, shape=(1,)) -> Signal(sig, shape=(1,))  "tag"}

Simulator

The representation of the Simulator is not particularly illuminating, but you can get a detailed account of the Simulator by printing its sorted list of Operators.

In [10]:
with nengo.Simulator(net1) as sim:
    print('\n'.join("  * %s" % op for op in sim._step_order))
  * Reset{Signal(merged<<Ensemble "b">.signal, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.signal>, shape=(4,))}
  * Reset{Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted>, shape=(4,))}
  * TimeUpdate{}
  * Copy{Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005), shape=(2,)) -> Signal(merged<<Ensemble "b">.signal, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.signal>[(slice(0, 2, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>"}
  * Copy{Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,)) -> Signal(merged<<Ensemble "b">.signal, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.signal>[(slice(0, 2, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>"}
  * SimPyFunc{None -> Signal(<Node "n2">.out, shape=(1,)), fn='cos'}
  * Copy{Signal(merged<<Ensemble "b">.bias, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.bias>, shape=(200,)) -> Signal(merged<<Ensemble "b">.neuron_in, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_in>, shape=(200,)), inc=False}
  * Reset{Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>, shape=(8,))}
  * SimPyFunc{None -> Signal(<Node (unlabeled) at 0x7f42038a7828>.out, shape=(1,)), fn='sin'}
  * BsrDotInc{Signal(bsr_merged<<Ensemble "b">.scaled_encoders, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.scaled_encoders>, shape=(2, 100, 2)), Signal(merged<<Ensemble "b">.signal, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.signal>, shape=(4,)) -> Signal(merged<<Ensemble "b">.neuron_in, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_in>, shape=(200,))}
  * SimNeurons{LIF(), Signal(merged<<Ensemble "b">.neuron_in, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_in>, shape=(200,)), Signal(merged<<Ensemble "b">.neuron_out, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_out>, shape=(200,))}
  * DotInc{Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weights, shape=(2, 100)), Signal(merged<<Ensemble "b">.neuron_out, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_out>[(slice(100, 200, None),)], shape=(100,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(6, 8, None),)], shape=(2,))  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weights_elementwiseinc"}
  * Copy{Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(6, 8, None),)], shape=(2,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(0, 2, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>"}
  * DotInc{Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>.weights, shape=(2, 100)), Signal(merged<<Ensemble "b">.neuron_out, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_out>[(slice(100, 200, None),)], shape=(100,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(4, 6, None),)], shape=(2,))  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>.weights_elementwiseinc"}
  * BsrDotInc{Signal(bsr_merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weights, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weights>, shape=(2, 2, 100)), Signal(merged<<Ensemble "b">.neuron_out, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_out>, shape=(200,)) -> Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted>, shape=(4,))}
  * SimProcess{Lowpass(0.005), Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(4, 6, None),)], shape=(2,)) -> Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,))}
  * Copy{Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted>[(slice(0, 2, None),)], shape=(2,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(2, 4, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>"}
  * SimProcess{Lowpass(0.005), Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted>[(slice(2, 4, None),)], shape=(2,)) -> Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005), shape=(2,))}

The diff of two simulators’ sorted ops tells us how two built models differ. We can use the difflib library (included with Python) to do a diff directly in Python.

In [11]:
import difflib

# Setting labels on all of the Nengo objects ensures the strings
# stay the same across simulator instances.
a.label = 'a'
n1.label = 'n1'

with nengo.Simulator(net1) as sim1:
    sim1_str = sorted(str(op) for op in sim1._step_order)

diff = difflib.unified_diff(
    a=sorted([str(op) for op in sim._step_order]), b=sim1_str)
print('\n'.join(diff))
# Several differences here because labels weren't set on sim
---

+++

@@ -1,18 +1,20 @@

-BsrDotInc{Signal(bsr_merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weights, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weights>, shape=(2, 2, 100)), Signal(merged<<Ensemble "b">.neuron_out, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_out>, shape=(200,)) -> Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted>, shape=(4,))}
-BsrDotInc{Signal(bsr_merged<<Ensemble "b">.scaled_encoders, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.scaled_encoders>, shape=(2, 100, 2)), Signal(merged<<Ensemble "b">.signal, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.signal>, shape=(4,)) -> Signal(merged<<Ensemble "b">.neuron_in, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_in>, shape=(200,))}
-Copy{Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005), shape=(2,)) -> Signal(merged<<Ensemble "b">.signal, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.signal>[(slice(0, 2, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>"}
-Copy{Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,)) -> Signal(merged<<Ensemble "b">.signal, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.signal>[(slice(0, 2, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>"}
-Copy{Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted>[(slice(0, 2, None),)], shape=(2,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(2, 4, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>"}
-Copy{Signal(merged<<Ensemble "b">.bias, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.bias>, shape=(200,)) -> Signal(merged<<Ensemble "b">.neuron_in, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_in>, shape=(200,)), inc=False}
-Copy{Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(6, 8, None),)], shape=(2,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(0, 2, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>"}
-DotInc{Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>.weights, shape=(2, 100)), Signal(merged<<Ensemble "b">.neuron_out, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_out>[(slice(100, 200, None),)], shape=(100,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(4, 6, None),)], shape=(2,))  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>.weights_elementwiseinc"}
-DotInc{Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weights, shape=(2, 100)), Signal(merged<<Ensemble "b">.neuron_out, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_out>[(slice(100, 200, None),)], shape=(100,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(6, 8, None),)], shape=(2,))  "<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weights_elementwiseinc"}
-Reset{Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted>, shape=(4,))}
-Reset{Signal(merged<<Ensemble "b">.signal, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.signal>, shape=(4,))}
-Reset{Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>, shape=(8,))}
-SimNeurons{LIF(), Signal(merged<<Ensemble "b">.neuron_in, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_in>, shape=(200,)), Signal(merged<<Ensemble "b">.neuron_out, ..., <Ensemble (unlabeled) at 0x7f4202fd0390>.neuron_out>, shape=(200,))}
-SimProcess{Lowpass(0.005), Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted>[(slice(2, 4, None),)], shape=(2,)) -> Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005), shape=(2,))}
-SimProcess{Lowpass(0.005), Signal(merged<<Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>, ..., <Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Probe of 'decoded_output' of <Ensemble (unlabeled) at 0x7f4202fd0390>>>.weighted>[(slice(4, 6, None),)], shape=(2,)) -> Signal(<Connection from <Ensemble (unlabeled) at 0x7f4202fd0390> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,))}
+Copy{Signal(<Connection from <Ensemble "a"> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Ensemble "b">.signal>[(slice(2, 4, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble "a"> to <Ensemble "b">>"}
+Copy{Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005)>, shape=(4,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Ensemble "b">.signal>, shape=(4,)), inc=True}
+Copy{Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>[(slice(0, 2, None),)], shape=(2,)) -> Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>[(slice(2, 4, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>"}
+Copy{Signal(merged<<Ensemble "a">.bias, ..., <Ensemble "b">.bias>, shape=(200,)) -> Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>, shape=(200,)), inc=False}
+DotInc{Signal(<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weights, shape=(2, 100)), Signal(<Ensemble "a">.neuron_out, shape=(100,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005)>[(slice(0, 2, None),)], shape=(2,))  "<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weights_elementwiseinc"}
+DotInc{Signal(<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weights, shape=(2, 100)), Signal(<Ensemble "b">.neuron_out, shape=(100,)) -> Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>[(slice(0, 2, None),)], shape=(2,))  "<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weights_elementwiseinc"}
+DotInc{Signal(<Ensemble "a">.scaled_encoders, shape=(100, 2)), Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>[(slice(4, 6, None),)], shape=(2,)) -> Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>[(slice(0, 100, None),)], shape=(100,))  "<Ensemble "a"> encoding"}
+DotInc{Signal(<Ensemble "b">.scaled_encoders, shape=(100, 2)), Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Ensemble "b">.signal>[(slice(2, 4, None),)], shape=(2,)) -> Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>[(slice(100, 200, None),)], shape=(100,))  "<Ensemble "b"> encoding"}
+DotInc{Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weights, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weights>, shape=(4, 100)), Signal(<Ensemble "a">.neuron_out, shape=(100,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>, shape=(4,))}
+Reset{Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>, shape=(4,))}
+Reset{Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005)>[(slice(0, 2, None),)], shape=(2,))}
+Reset{Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>, shape=(6,))}
+Reset{Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Ensemble "b">.signal>, shape=(4,))}
+SimNeurons{LIF(), Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>[(slice(0, 100, None),)], shape=(100,)), Signal(<Ensemble "a">.neuron_out, shape=(100,))}
+SimNeurons{LIF(), Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>[(slice(100, 200, None),)], shape=(100,)), Signal(<Ensemble "b">.neuron_out, shape=(100,))}
+SimProcess{Lowpass(0.005), Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>[(slice(0, 2, None),)], shape=(2,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005)>[(slice(2, 4, None),)], shape=(2,))}
+SimProcess{Lowpass(0.005), Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>[(slice(2, 4, None),)], shape=(2,)) -> Signal(<Connection from <Ensemble "a"> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,))}
+SimPyFunc{None -> Signal(<Node "n1">.out, shape=(1,)), fn='sin'}
 SimPyFunc{None -> Signal(<Node "n2">.out, shape=(1,)), fn='cos'}
-SimPyFunc{None -> Signal(<Node (unlabeled) at 0x7f42038a7828>.out, shape=(1,)), fn='sin'}
 TimeUpdate{}
In [12]:
with nengo.Simulator(net1) as sim2:
    sim2_str = sorted(str(op) for op in sim2._step_order)
diff = difflib.unified_diff(a=sim1_str, b=sim2_str)
print('\n'.join(diff))
# No more differences because labels keep representations stable
---

+++

@@ -1,19 +1,17 @@

-Copy{Signal(<Connection from <Ensemble "a"> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Ensemble "b">.signal>[(slice(2, 4, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble "a"> to <Ensemble "b">>"}
-Copy{Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005)>, shape=(4,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Ensemble "b">.signal>, shape=(4,)), inc=True}
-Copy{Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>[(slice(0, 2, None),)], shape=(2,)) -> Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>[(slice(2, 4, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>"}
+BsrDotInc{Signal(bsr_merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weights, ..., <Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weights>, shape=(2, 2, 100)), Signal(merged<<Ensemble "a">.neuron_out, ..., <Ensemble "b">.neuron_out>, shape=(200,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted>, shape=(4,))}
+BsrDotInc{Signal(bsr_merged<<Ensemble "a">.scaled_encoders, ..., <Ensemble "b">.scaled_encoders>, shape=(2, 100, 2)), Signal(merged<<Ensemble "a">.signal, ..., <Ensemble "b">.signal>, shape=(4,)) -> Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>, shape=(200,))}
+Copy{Signal(<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005), shape=(2,)) -> Signal(merged<<Ensemble "a">.signal, ..., <Ensemble "b">.signal>[(slice(2, 4, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>"}
+Copy{Signal(<Connection from <Ensemble "a"> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,)) -> Signal(merged<<Ensemble "a">.signal, ..., <Ensemble "b">.signal>[(slice(2, 4, None),)], shape=(2,)), inc=True  "<Connection from <Ensemble "a"> to <Ensemble "b">>"}
+Copy{Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted>, shape=(4,)) -> Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Probe of 'decoded_output' of <Ensemble "b">>>, shape=(4,)), inc=True}
 Copy{Signal(merged<<Ensemble "a">.bias, ..., <Ensemble "b">.bias>, shape=(200,)) -> Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>, shape=(200,)), inc=False}
-DotInc{Signal(<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weights, shape=(2, 100)), Signal(<Ensemble "a">.neuron_out, shape=(100,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005)>[(slice(0, 2, None),)], shape=(2,))  "<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weights_elementwiseinc"}
-DotInc{Signal(<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weights, shape=(2, 100)), Signal(<Ensemble "b">.neuron_out, shape=(100,)) -> Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>[(slice(0, 2, None),)], shape=(2,))  "<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weights_elementwiseinc"}
-DotInc{Signal(<Ensemble "a">.scaled_encoders, shape=(100, 2)), Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>[(slice(4, 6, None),)], shape=(2,)) -> Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>[(slice(0, 100, None),)], shape=(100,))  "<Ensemble "a"> encoding"}
-DotInc{Signal(<Ensemble "b">.scaled_encoders, shape=(100, 2)), Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Ensemble "b">.signal>[(slice(2, 4, None),)], shape=(2,)) -> Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>[(slice(100, 200, None),)], shape=(100,))  "<Ensemble "b"> encoding"}
-DotInc{Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weights, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weights>, shape=(4, 100)), Signal(<Ensemble "a">.neuron_out, shape=(100,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>, shape=(4,))}
+DotInc{Signal(<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weights, shape=(2, 100)), Signal(merged<<Ensemble "a">.neuron_out, ..., <Ensemble "b">.neuron_out>[(slice(0, 100, None),)], shape=(100,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>[(slice(0, 2, None),)], shape=(2,))  "<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weights_elementwiseinc"}
+DotInc{Signal(<Connection from <Ensemble "a"> to <Ensemble "b">>.weights, shape=(2, 100)), Signal(merged<<Ensemble "a">.neuron_out, ..., <Ensemble "b">.neuron_out>[(slice(0, 100, None),)], shape=(100,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>[(slice(2, 4, None),)], shape=(2,))  "<Connection from <Ensemble "a"> to <Ensemble "b">>.weights_elementwiseinc"}
 Reset{Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>, shape=(4,))}
-Reset{Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005)>[(slice(0, 2, None),)], shape=(2,))}
-Reset{Signal(merged<<Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted, ..., <Ensemble "a">.signal>, shape=(6,))}
-Reset{Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Ensemble "b">.signal>, shape=(4,))}
-SimNeurons{LIF(), Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>[(slice(0, 100, None),)], shape=(100,)), Signal(<Ensemble "a">.neuron_out, shape=(100,))}
-SimNeurons{LIF(), Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>[(slice(100, 200, None),)], shape=(100,)), Signal(<Ensemble "b">.neuron_out, shape=(100,))}
-SimProcess{Lowpass(0.005), Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>[(slice(0, 2, None),)], shape=(2,)) -> Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005)>[(slice(2, 4, None),)], shape=(2,))}
+Reset{Signal(merged<<Connection from <Ensemble "a"> to <Probe of 'decoded_output' of <Ensemble "a">>>.weighted, ..., <Connection from <Ensemble "b"> to <Probe of 'decoded_output' of <Ensemble "b">>>.weighted>, shape=(4,))}
+Reset{Signal(merged<<Ensemble "a">.signal, ..., <Ensemble "b">.signal>, shape=(4,))}
+Reset{Signal(merged<<Probe of 'decoded_output' of <Ensemble "a">>, ..., <Probe of 'decoded_output' of <Ensemble "b">>>, shape=(4,))}
+SimNeurons{LIF(), Signal(merged<<Ensemble "a">.neuron_in, ..., <Ensemble "b">.neuron_in>, shape=(200,)), Signal(merged<<Ensemble "a">.neuron_out, ..., <Ensemble "b">.neuron_out>, shape=(200,))}
+SimProcess{Lowpass(0.005), Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>[(slice(0, 2, None),)], shape=(2,)) -> Signal(<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted.Lowpass(0.005), shape=(2,))}
 SimProcess{Lowpass(0.005), Signal(merged<<Connection from <Ensemble "a"> to <Ensemble "b"> computing 'square'>.weighted, ..., <Connection from <Ensemble "a"> to <Ensemble "b">>.weighted>[(slice(2, 4, None),)], shape=(2,)) -> Signal(<Connection from <Ensemble "a"> to <Ensemble "b">>.weighted.Lowpass(0.005), shape=(2,))}
 SimPyFunc{None -> Signal(<Node "n1">.out, shape=(1,)), fn='sin'}
 SimPyFunc{None -> Signal(<Node "n2">.out, shape=(1,)), fn='cos'}