def __init__(self,
dimensions,
n_neurons_per_ensemble=50,
mutual_inhib=1.0,
threshold=0.0,
**kwargs):
if "net" in kwargs:
raise ObsoleteError("The 'net' argument is no longer supported.")
kwargs.setdefault("label", "Thalamus")
super().__init__(**kwargs)
with self:
self.actions = EnsembleArray(
n_neurons_per_ensemble,
dimensions,
intercepts=Uniform(threshold, 1),
encoders=Choice([[1.0]]),
label="actions",
)
nengo.Connection(
self.actions.output,
self.actions.input,
transform=(np.eye(dimensions) - 1) * mutual_inhib,
)
self.bias = nengo.Node([1], label="thalamus bias")
nengo.Connection(self.bias,
self.actions.input,
transform=np.ones((dimensions, 1)))
self.input = self.actions.input
self.output = self.actions.output
def __init__(self,
n_neurons,
dimensions,
feedback=1.0,
difference_gain=1.0,
recurrent_synapse=0.1,
difference_synapse=None,
**kwargs):
if 'net' in kwargs:
raise ObsoleteError("The 'net' argument is no longer supported.")
kwargs.setdefault('label', "Input gated memory")
super(InputGatedMemory, self).__init__(**kwargs)
if difference_synapse is None:
difference_synapse = recurrent_synapse
n_total_neurons = n_neurons * dimensions
with self:
# integrator to store value
self.mem = EnsembleArray(n_neurons, dimensions, label="mem")
nengo.Connection(self.mem.output,
self.mem.input,
transform=feedback,
synapse=recurrent_synapse)
# calculate difference between stored value and input
self.diff = EnsembleArray(n_neurons, dimensions, label="diff")
nengo.Connection(self.mem.output, self.diff.input, transform=-1)
# feed difference into integrator
nengo.Connection(self.diff.output,
self.mem.input,
transform=difference_gain,
synapse=difference_synapse)
# gate difference (if gate==0, update stored value,
# otherwise retain stored value)
self.gate = nengo.Node(size_in=1)
self.diff.add_neuron_input()
nengo.Connection(self.gate,
self.diff.neuron_input,
transform=np.ones((n_total_neurons, 1)) * -10,
synapse=None)
# reset input (if reset=1, remove all values, and set to 0)
self.reset = nengo.Node(size_in=1)
nengo.Connection(self.reset,
self.mem.add_neuron_input(),
transform=np.ones((n_total_neurons, 1)) * -3,
synapse=None)
self.input = self.diff.input
self.output = self.mem.output
def validate(self, probe, attr):
super(AttributeParam, self).validate(probe, attr)
if attr in ('decoders', 'transform'):
raise ObsoleteError(
"'decoders' and 'transform' are now combined "
"into 'weights'. Probe 'weights' instead.",
since="v2.1.0")
if attr not in probe.obj.probeable:
raise ValidationError("Attribute %r is not probeable on %s." %
(attr, probe.obj),
attr=self.name,
obj=probe)
def __init__(self, recurrent_tau, n_neurons, dimensions, **kwargs):
if "net" in kwargs:
raise ObsoleteError("The 'net' argument is no longer supported.")
kwargs.setdefault("label", "Integrator")
super().__init__(**kwargs)
with self:
self.input = Node(size_in=dimensions)
self.ensemble = Ensemble(n_neurons, dimensions=dimensions)
Connection(self.ensemble, self.ensemble, synapse=recurrent_tau)
Connection(self.input, self.ensemble, transform=recurrent_tau, synapse=None)
self.output = self.ensemble
def coerce(self, probe, attr):
value = super().coerce(probe, attr)
if attr in ('decoders', 'transform'):
raise ObsoleteError(
"'decoders' and 'transform' are now combined "
"into 'weights'. Probe 'weights' instead.",
since="v2.1.0")
if attr not in probe.obj.probeable:
raise ValidationError("Attribute %r is not probeable on %s.\n"
"Probeable attributes: %s" %
(attr, probe.obj, probe.obj.probeable),
attr=self.name,
obj=probe)
return value
def __init__(self, n_neurons, dimensions, input_magnitude=1.0, **kwargs):
if "net" in kwargs:
raise ObsoleteError("The 'net' argument is no longer supported.")
kwargs.setdefault("label", "Product")
super().__init__(**kwargs)
with self:
self.input_a = nengo.Node(size_in=dimensions, label="input_a")
self.input_b = nengo.Node(size_in=dimensions, label="input_b")
self.output = nengo.Node(size_in=dimensions, label="output")
self.sq1 = EnsembleArray(
max(1, n_neurons // 2),
n_ensembles=dimensions,
ens_dimensions=1,
radius=input_magnitude * np.sqrt(2),
)
self.sq2 = EnsembleArray(
max(1, n_neurons // 2),
n_ensembles=dimensions,
ens_dimensions=1,
radius=input_magnitude * np.sqrt(2),
)
tr = 1.0 / np.sqrt(2.0)
nengo.Connection(self.input_a,
self.sq1.input,
transform=tr,
synapse=None)
nengo.Connection(self.input_b,
self.sq1.input,
transform=tr,
synapse=None)
nengo.Connection(self.input_a,
self.sq2.input,
transform=tr,
synapse=None)
nengo.Connection(self.input_b,
self.sq2.input,
transform=-tr,
synapse=None)
sq1_out = self.sq1.add_output("square", np.square)
nengo.Connection(sq1_out, self.output, transform=0.5, synapse=None)
sq2_out = self.sq2.add_output("square", np.square)
nengo.Connection(sq2_out,
self.output,
transform=-0.5,
synapse=None)
def __init__(self, recurrent_tau, frequency, n_neurons, **kwargs):
if "net" in kwargs:
raise ObsoleteError("The 'net' argument is no longer supported.")
kwargs.setdefault("label", "Oscillator")
super().__init__(**kwargs)
with self:
self.input = Node(label="In", size_in=2)
self.ensemble = Ensemble(n_neurons, dimensions=2, label="Oscillator")
tA = [[1, -frequency * recurrent_tau], [frequency * recurrent_tau, 1]]
Connection(
self.ensemble, self.ensemble, synapse=recurrent_tau, transform=tA
)
Connection(self.input, self.ensemble, synapse=None)
self.output = self.ensemble
def __init__(
self,
n_neurons,
dimensions,
invert_a=False,
invert_b=False,
input_magnitude=1.0,
# fmt: off
**kwargs
# fmt: on
):
if "net" in kwargs:
raise ObsoleteError("The 'net' argument is no longer supported.")
kwargs.setdefault("label", "Circular convolution")
super().__init__(**kwargs)
tr_a = transform_in(dimensions, "A", invert_a)
tr_b = transform_in(dimensions, "B", invert_b)
tr_out = transform_out(dimensions)
with self:
self.input_a = nengo.Node(size_in=dimensions, label="input_a")
self.input_b = nengo.Node(size_in=dimensions, label="input_b")
self.product = Product(n_neurons,
tr_out.shape[1],
input_magnitude=input_magnitude * 2)
self.output = nengo.Node(size_in=dimensions, label="output")
nengo.Connection(self.input_a,
self.product.input_a,
transform=tr_a,
synapse=None)
nengo.Connection(self.input_b,
self.product.input_b,
transform=tr_b,
synapse=None)
nengo.Connection(self.product.output,
self.output,
transform=tr_out,
synapse=None)
def decoders(self):
raise ObsoleteError(
"decoders are now part of 'weights'. "
"Access BuiltConnection.weights instead.",
since="v2.1.0")
def raise_error(self):
raise ObsoleteError(self.short_msg, since=self.since, url=self.url)
def __init__(self,
dimensions,
n_neurons_per_ensemble=100,
output_weight=-3.0,
input_bias=0.0,
ampa_config=None,
gaba_config=None,
**kwargs):
if "net" in kwargs:
raise ObsoleteError("The 'net' argument is no longer supported.")
kwargs.setdefault("label", "Basal Ganglia")
super().__init__(**kwargs)
ampa_config, override_ampa = config_with_default_synapse(
ampa_config, nengo.Lowpass(0.002))
gaba_config, override_gaba = config_with_default_synapse(
gaba_config, nengo.Lowpass(0.008))
# Affects all ensembles / connections in the BG
# unless they've been overridden on `self.config`
config = nengo.Config(nengo.Ensemble, nengo.Connection)
config[nengo.Ensemble].radius = 1.5
config[nengo.Ensemble].encoders = Choice([[1]])
try:
# Best, if we have SciPy
config[nengo.Connection].solver = NnlsL2nz()
except ImportError:
# Warn if we can't use the better decoder solver.
warnings.warn("SciPy is not installed, so BasalGanglia will "
"use the default decoder solver. Installing SciPy "
"may improve BasalGanglia performance.")
ea_params = {
"n_neurons": n_neurons_per_ensemble,
"n_ensembles": dimensions
}
with self, config:
self.strD1 = EnsembleArray(
label="Striatal D1 neurons",
intercepts=Uniform(Weights.e, 1),
**ea_params,
)
self.strD2 = EnsembleArray(
label="Striatal D2 neurons",
intercepts=Uniform(Weights.e, 1),
**ea_params,
)
self.stn = EnsembleArray(
label="Subthalamic nucleus",
intercepts=Uniform(Weights.ep, 1),
**ea_params,
)
self.gpi = EnsembleArray(
label="Globus pallidus internus",
intercepts=Uniform(Weights.eg, 1),
**ea_params,
)
self.gpe = EnsembleArray(
label="Globus pallidus externus",
intercepts=Uniform(Weights.ee, 1),
**ea_params,
)
self.input = nengo.Node(label="input", size_in=dimensions)
self.output = nengo.Node(label="output", size_in=dimensions)
# add bias input (BG performs best in the range 0.5--1.5)
if abs(input_bias) > 0.0:
self.bias_input = nengo.Node(np.ones(dimensions) * input_bias,
label="basal ganglia bias")
nengo.Connection(self.bias_input, self.input)
# spread the input to StrD1, StrD2, and STN
nengo.Connection(
self.input,
self.strD1.input,
synapse=None,
transform=Weights.ws * (1 + Weights.lg),
)
nengo.Connection(
self.input,
self.strD2.input,
synapse=None,
transform=Weights.ws * (1 - Weights.le),
)
nengo.Connection(self.input,
self.stn.input,
synapse=None,
transform=Weights.wt)
# connect the striatum to the GPi and GPe (inhibitory)
strD1_output = self.strD1.add_output("func_str", Weights.str_func)
strD2_output = self.strD2.add_output("func_str", Weights.str_func)
with gaba_config:
nengo.Connection(strD1_output,
self.gpi.input,
transform=-Weights.wm)
nengo.Connection(strD2_output,
self.gpe.input,
transform=-Weights.wm)
# connect the STN to GPi and GPe (broad and excitatory)
tr = Weights.wp * np.ones((dimensions, dimensions))
stn_output = self.stn.add_output("func_stn", Weights.stn_func)
with ampa_config:
nengo.Connection(stn_output, self.gpi.input, transform=tr)
nengo.Connection(stn_output, self.gpe.input, transform=tr)
# connect the GPe to GPi and STN (inhibitory)
gpe_output = self.gpe.add_output("func_gpe", Weights.gpe_func)
with gaba_config:
nengo.Connection(gpe_output,
self.gpi.input,
transform=-Weights.we)
nengo.Connection(gpe_output,
self.stn.input,
transform=-Weights.wg)
# connect GPi to output (inhibitory)
gpi_output = self.gpi.add_output("func_gpi", Weights.gpi_func)
nengo.Connection(gpi_output,
self.output,
synapse=None,
transform=output_weight)
# Return ampa_config and gaba_config to previous states, if changed
if override_ampa:
del ampa_config[nengo.Connection].synapse
if override_gaba:
del gaba_config[nengo.Connection].synapse
def transform(self):
raise ObsoleteError(
"transform is now part of 'weights'. "
"Access BuiltConnection.weights instead.",
since="v2.1.0")
