def test_associativememory_edge_cases(seed, rng):
"""Tests that edge case code runs without error
TODO: In the future, these features should be tested in an integration test.
"""
vocab = make_vocab(4, 64, rng)
out_vectors = rng.uniform(-1, 1, size=(4, 3))
with nengo.Network(seed=seed):
# test that an iterable threshold works
am = AssociativeMemory(vocab, threshold=[0.1, 0.2, 0.3, 0.4])
am.add_threshold_to_outputs()
# test add_output_mapping works when `thresh_ens is not None`
am.add_output_mapping("test", out_vectors)
inp, out = am.thresh_ens.output, am.test
conn = [c for c in am.out_conns if c.pre is inp and c.post is out][0]
assert np.allclose(conn.transform.init, out_vectors.T)
# test add_default_output_vector works when `thresh_ens is not None`
am.add_default_output_vector(np.ones(64))
assert len(am.default_vector_inhibit_conns) == 1
conn = am.default_vector_inhibit_conns[0]
assert conn.pre is am.thresh_ens.output
class AssociativeMemory(Module):
"""Associative memory module.
See :doc:`examples/associative_memory` for an introduction and examples.
Parameters
----------
input_vocab: list or Vocabulary
The vocabulary (or list of vectors) to match.
output_vocab: list or Vocabulary, optional (Default: None)
The vocabulary (or list of vectors) to be produced for each match. If
None, the associative memory will act like an autoassociative memory
(cleanup memory).
input_keys : list, optional (Default: None)
A list of strings that correspond to the input vectors.
output_keys : list, optional (Default: None)
A list of strings that correspond to the output vectors.
default_output_key: str, optional (Default: None)
The semantic pointer string to be produced if the input value matches
none of vectors in the input vector list.
threshold: float, optional (Default: 0.3)
The association activation threshold.
inhibitable: bool, optional (Default: False)
Flag to indicate if the entire associative memory module is
inhibitable (i.e., the entire module can be inhibited).
wta_output: bool, optional (Default: False)
Flag to indicate if output of the associative memory should contain
more than one vector. If True, only one vector's output will be
produced; i.e. produce a winner-take-all (WTA) output.
If False, combinations of vectors will be produced.
wta_inhibit_scale: float, optional (Default: 3.0)
Scaling factor on the winner-take-all (WTA) inhibitory connections.
wta_synapse: float, optional (Default: 0.005)
Synapse to use for the winner-take-all (wta) inhibitory connections.
threshold_output: bool, optional (Default: False)
Adds a threholded output if True.
label : str, optional (Default: None)
A name for the ensemble. Used for debugging and visualization.
seed : int, optional (Default: None)
The seed used for random number generation.
add_to_container : bool, optional (Default: None)
Determines if this Network will be added to the current container.
If None, will be true if currently within a Network.
"""
def __init__(
self,
input_vocab,
output_vocab=None, # noqa: C901
input_keys=None,
output_keys=None,
default_output_key=None,
threshold=0.3,
inhibitable=False,
wta_output=False,
wta_inhibit_scale=3.0,
wta_synapse=0.005,
threshold_output=False,
label=None,
seed=None,
add_to_container=None):
super(AssociativeMemory, self).__init__(label, seed, add_to_container)
if input_keys is None:
input_keys = input_vocab.keys
input_vectors = input_vocab.vectors
else:
input_vectors = input_vocab.create_subset(input_keys).vectors
# If output vocabulary is not specified, use input vocabulary
# (i.e autoassociative memory)
if output_vocab is None:
output_vocab = input_vocab
output_vectors = input_vectors
else:
if output_keys is None:
output_keys = input_keys
output_vectors = output_vocab.create_subset(output_keys).vectors
if default_output_key is None:
default_output_vector = None
else:
default_output_vector = output_vocab.parse(default_output_key).v
# Create nengo network
with self:
self.am = AssocMem(input_vectors=input_vectors,
output_vectors=output_vectors,
threshold=threshold,
inhibitable=inhibitable,
label=label,
seed=seed,
add_to_container=add_to_container)
if default_output_vector is not None:
self.am.add_default_output_vector(default_output_vector)
if wta_output:
self.am.add_wta_network(wta_inhibit_scale, wta_synapse)
if threshold_output:
self.am.add_threshold_to_outputs()
self.input = self.am.input
self.output = self.am.output
if inhibitable:
self.inhibit = self.am.inhibit
self.utilities = self.am.utilities
if threshold_output:
self.thresholded_utilities = self.am.thresholded_utilities
self.inputs = dict(default=(self.input, input_vocab))
self.outputs = dict(default=(self.output, output_vocab))
def test_am_complex(Simulator, plt, seed, rng):
"""Complex auto-associative memory test.
Has a default output vector, outputs utilities, and becomes inhibited.
"""
D = 64
vocab = make_vocab(6, D, rng)
vocab2 = vocab[:4, :]
def input_func(t):
if t < 0.25:
return vocab[0, :] + 0.31 * vocab[1, :]
elif t < 0.5:
return 0.31 * vocab[0, :] + vocab[1, :]
else:
return vocab[4, :]
def inhib_func(t):
return int(t > 0.75)
with nengo.Network('model', seed=seed) as m:
am = AssociativeMemory(vocab2, inhibitable=True)
am.add_default_output_vector(vocab[5, :])
am.add_threshold_to_outputs()
in_node = nengo.Node(output=input_func, label='input')
inhib_node = nengo.Node(output=inhib_func, label='inhib')
nengo.Connection(in_node, am.input)
nengo.Connection(inhib_node, am.inhibit)
in_p = nengo.Probe(in_node)
out_p = nengo.Probe(am.output, synapse=0.03)
utils_p = nengo.Probe(am.utilities, synapse=0.05)
utils_th_p = nengo.Probe(am.thresholded_utilities, synapse=0.05)
sim = Simulator(m)
sim.run(1.0)
t = sim.trange()
# Input: A+0.8B
more_a = (t >= 0.2) & (t < 0.25)
# Input: 0.8B+A
more_b = (t >= 0.45) & (t < 0.5)
# Input: E (but E isn't in the memory vocabulary, so should output F)
all_e = (t >= 0.7) & (t < 0.75)
# Input: E (but inhibited, so should output nothing)
inhib = (t >= 0.95)
def plot(i, y, ylabel):
plt.subplot(4, 1, i)
plt.plot(t, y)
plt.axvline(0.25, c='k')
plt.axvline(0.5, c='k')
plt.axvline(0.75, c='k')
plt.ylabel(ylabel)
plot(1, np.dot(sim.data[in_p], vocab.T), "Input")
plot(2, sim.data[utils_p], "Utilities")
plot(3, sim.data[utils_th_p], "Thresholded utilities")
plot(4, np.dot(sim.data[out_p], vocab.T), "Output")
# Check that the output utilities (non-thresholded) are to be expected
assert all(np.mean(sim.data[utils_p][more_a], axis=0)[:2] > [0.9, 0.35])
assert all(np.mean(sim.data[utils_p][more_a], axis=0)[2:] < [0.01, 0.01])
assert all(np.mean(sim.data[utils_p][more_b], axis=0)[:2] > [0.35, 0.9])
assert all(np.mean(sim.data[utils_p][more_b], axis=0)[2:] < [0.01, 0.01])
assert similarity(sim.data[utils_p][all_e], np.ones((1, 4))) < 0.05
assert similarity(sim.data[utils_p][inhib], np.ones((1, 4))) < 0.05
# Check that the thresholded output utilities are to be expected
assert all(np.mean(sim.data[utils_th_p][more_a], axis=0)[:2] > [0.9, 0.9])
assert all(
np.mean(sim.data[utils_th_p][more_a], axis=0)[2:] < [0.01, 0.01])
assert all(np.mean(sim.data[utils_th_p][more_b], axis=0)[:2] > [0.9, 0.9])
assert all(
np.mean(sim.data[utils_th_p][more_b], axis=0)[2:] < [0.01, 0.01])
assert similarity(sim.data[utils_th_p][all_e], np.ones((1, 4))) < 0.05
assert similarity(sim.data[utils_th_p][inhib], np.ones((1, 4))) < 0.05
# Check that the output values are to be expected
assert similarity(sim.data[out_p][more_a], vocab[0, :]) > 0.9
assert similarity(sim.data[out_p][more_a], vocab[1, :]) > 0.9
assert similarity(sim.data[out_p][more_b], vocab[0, :]) > 0.9
assert similarity(sim.data[out_p][more_b], vocab[1, :]) > 0.9
assert similarity(sim.data[out_p][all_e], vocab[5, :]) > 0.9
assert similarity(sim.data[out_p][inhib], np.ones((1, D))) < 0.05
def test_am_complex(Simulator, plt, seed, rng):
"""Complex auto-associative memory test.
Has a default output vector, outputs utilities, and becomes inhibited.
"""
D = 64
vocab = make_vocab(6, D, rng)
vocab2 = vocab[:4]
def input_func(t):
if t < 0.25:
return 0.6 * vocab[0] + 0.4 * vocab[1]
elif t < 0.5:
return 0.4 * vocab[0] + 0.6 * vocab[1]
else:
return vocab[4]
def inhib_func(t):
return int(t > 0.75)
with nengo.Network("model", seed=seed) as m:
am = AssociativeMemory(vocab2, inhibitable=True)
am.add_default_output_vector(vocab[5])
am.add_threshold_to_outputs()
in_node = nengo.Node(output=input_func, label="input")
inhib_node = nengo.Node(output=inhib_func, label="inhib")
nengo.Connection(in_node, am.input)
nengo.Connection(inhib_node, am.inhibit)
in_p = nengo.Probe(in_node)
out_p = nengo.Probe(am.output, synapse=0.03)
utils_p = nengo.Probe(am.utilities, synapse=0.05)
utils_th_p = nengo.Probe(am.thresholded_utilities, synapse=0.05)
with Simulator(m) as sim:
sim.run(1.0)
t = sim.trange()
# Input: 0.6A + 0.4B
more_a = (t >= 0.2) & (t < 0.25)
# Input: 0.4A + 0.6B
more_b = (t >= 0.45) & (t < 0.5)
# Input: D (but D isn't in the memory vocabulary, so should output E)
all_e = (t >= 0.7) & (t < 0.75)
# Input: D (E) (but inhibited, so should output nothing)
inhib = t >= 0.95
def plot(i, y, ylabel):
plt.subplot(4, 1, i)
plt.plot(t, y)
plt.axvline(0.25, c="k")
plt.axvline(0.5, c="k")
plt.axvline(0.75, c="k")
plt.ylabel(ylabel)
plot(1, np.dot(sim.data[in_p], vocab.T), "Input")
plot(2, sim.data[utils_p], "Utilities")
plot(3, sim.data[utils_th_p], "Thresholded utilities")
plot(4, np.dot(sim.data[out_p], vocab.T), "Output")
# Check that the output utilities (non-thresholded) are to be expected
assert all(np.mean(sim.data[utils_p][more_a], axis=0)[:2] > [0.9, 0.35])
assert all(np.mean(sim.data[utils_p][more_a], axis=0)[2:] < [0.01, 0.01])
assert all(np.mean(sim.data[utils_p][more_b], axis=0)[:2] > [0.35, 0.9])
assert all(np.mean(sim.data[utils_p][more_b], axis=0)[2:] < [0.01, 0.01])
assert similarity(sim.data[utils_p][all_e], np.ones((1, 4))) < 0.05
assert similarity(sim.data[utils_p][inhib], np.ones((1, 4))) < 0.05
# Check that the thresholded output utilities are to be expected
assert all(np.mean(sim.data[utils_th_p][more_a], axis=0)[:2] > [0.9, 0.9])
assert all(np.mean(sim.data[utils_th_p][more_a], axis=0)[2:] < [0.01, 0.01])
assert all(np.mean(sim.data[utils_th_p][more_b], axis=0)[:2] > [0.9, 0.9])
assert all(np.mean(sim.data[utils_th_p][more_b], axis=0)[2:] < [0.01, 0.01])
assert similarity(sim.data[utils_th_p][all_e], np.ones((1, 4))) < 0.05
assert similarity(sim.data[utils_th_p][inhib], np.ones((1, 4))) < 0.05
# Check that the output values are to be expected
assert similarity(sim.data[out_p][more_a], vocab[0]) > 0.7
assert similarity(sim.data[out_p][more_a], vocab[1]) > 0.7
assert similarity(sim.data[out_p][more_b], vocab[0]) > 0.7
assert similarity(sim.data[out_p][more_b], vocab[1]) > 0.7
assert similarity(sim.data[out_p][all_e], vocab[5]) > 0.7
assert similarity(sim.data[out_p][inhib], np.ones((1, D))) < 0.05
class AssociativeMemory(Module):
"""Associative memory module.
Parameters
----------
input_vocab: list of numpy.array, spa.Vocabulary
The vocabulary (or list of vectors) to match.
output_vocab: list of numpy.array, spa.Vocabulary, optional
The vocabulary (or list of vectors) to be produced for each match. If
not given, the associative memory will act like an auto-associative
memory (cleanup memory).
input_keys: list of strings, optional
List of keys (ordered) from the input vocabulary to use as the input
semantic pointers for the associative memory.
output_keys: list of strings, optional
List of keys (ordered) from the output vocabulary to use as the output
semantic pointers for the associative memory.
default_output_vector: numpy.array, spa.SemanticPointer, optional
The vector to be produced if the input value matches none of vectors
in the input vector list.
threshold: float, optional
The association activation threshold.
inhibitable: boolean, optional
Flag to indicate if the entire associative memory module is
inhibitable (entire thing can be shut off).
wta_output: boolean, optional
Flag to indicate if output of the associative memory should contain
more than one vectors. Set to True if only one vectors output is
desired -- i.e. a winner-take-all (wta) output. Leave as default
(False) if (possible) combinations of vectors is desired.
wta_inhibit_scale: float, optional
Scaling factor on the winner-take-all (wta) inhibitory connections.
wta_synapse: float, optional
Synapse to use for the winner-take-all (wta) inhibitory connections.
cleanup_output: boolean, optional
Create the associative memory with cleaned outputs as well as the
standard outputs.
replace_output_with_cleaned_output: boolean, optional
Set to true to use the cleaned outputs as the default output of the
associative memory module.
label : str, optional
A name to assign this AssociativeMemory. Used for visualization and
debugging. Also used as a label prefix for each of the internal
ensembles in the AssociativeMemory network.
Additional network parameters are passed to the Network constructor through
**module_kwargs
"""
def __init__(self, input_vocab, output_vocab=None, # noqa: C901
input_keys=None, output_keys=None,
default_output_key=None, threshold=0.3,
inhibitable=False, wta_output=False,
wta_inhibit_scale=3.0, wta_synapse=0.005,
cleanup_output=False,
replace_output_with_cleaned_output=True,
label=None, **module_kwargs):
super(AssociativeMemory, self).__init__(label=label, **module_kwargs)
if input_keys is None:
input_keys = input_vocab.keys
input_vectors = input_vocab.vectors
else:
input_vectors = input_vocab.create_subset(input_keys).vectors
# If output vocabulary is not specified, use input vocabulary
# (i.e autoassociative memory)
if output_vocab is None:
output_vocab = input_vocab
output_vectors = input_vectors
else:
if output_keys is None:
output_keys = input_keys
output_vectors = output_vocab.create_subset(output_keys).vectors
if default_output_key is None:
default_output_vector = None
else:
default_output_vector = output_vocab.parse(default_output_key).v
# Create nengo network
with self:
self.am = AssocMem(input_vectors=input_vectors,
output_vectors=output_vectors,
threshold=threshold,
inhibitable=inhibitable,
label=label, **module_kwargs)
if default_output_vector is not None:
self.am.add_default_output_vector(default_output_vector)
if wta_output:
self.am.add_wta_network(wta_inhibit_scale, wta_synapse)
if cleanup_output:
self.am.add_cleanup_output(
replace_output=replace_output_with_cleaned_output)
self.input = self.am.input
self.output = self.am.output
if cleanup_output and not replace_output_with_cleaned_output:
self.cleaned_output = self.am.cleaned_output
if inhibitable:
self.inhibit = self.am.inhibit
self.utilities = self.am.output_utilities
if cleanup_output:
self.cleaned_utilities = self.am.cleaned_output_utilities
self.inputs = dict(default=(self.input, input_vocab))
self.outputs = dict(default=(self.output, output_vocab))
class AssociativeMemory(Module):
"""Associative memory module.
See :doc:`examples/associative_memory` for an introduction and examples.
Parameters
----------
input_vocab: list or Vocabulary
The vocabulary (or list of vectors) to match.
output_vocab: list or Vocabulary, optional (Default: None)
The vocabulary (or list of vectors) to be produced for each match. If
None, the associative memory will act like an autoassociative memory
(cleanup memory).
input_keys : list, optional (Default: None)
A list of strings that correspond to the input vectors.
output_keys : list, optional (Default: None)
A list of strings that correspond to the output vectors.
default_output_key: str, optional (Default: None)
The semantic pointer string to be produced if the input value matches
none of vectors in the input vector list.
threshold: float, optional (Default: 0.3)
The association activation threshold.
inhibitable: bool, optional (Default: False)
Flag to indicate if the entire associative memory module is
inhibitable (i.e., the entire module can be inhibited).
wta_output: bool, optional (Default: False)
Flag to indicate if output of the associative memory should contain
more than one vector. If True, only one vector's output will be
produced; i.e. produce a winner-take-all (WTA) output.
If False, combinations of vectors will be produced.
wta_inhibit_scale: float, optional (Default: 3.0)
Scaling factor on the winner-take-all (WTA) inhibitory connections.
wta_synapse: float, optional (Default: 0.005)
Synapse to use for the winner-take-all (wta) inhibitory connections.
threshold_output: bool, optional (Default: False)
Adds a threholded output if True.
label : str, optional (Default: None)
A name for the ensemble. Used for debugging and visualization.
seed : int, optional (Default: None)
The seed used for random number generation.
add_to_container : bool, optional (Default: None)
Determines if this Network will be added to the current container.
If None, will be true if currently within a Network.
"""
def __init__(self, input_vocab, output_vocab=None, # noqa: C901
input_keys=None, output_keys=None,
default_output_key=None, threshold=0.3,
inhibitable=False, wta_output=False,
wta_inhibit_scale=3.0, wta_synapse=0.005,
threshold_output=False, label=None, seed=None,
add_to_container=None):
super(AssociativeMemory, self).__init__(label, seed, add_to_container)
if input_keys is None:
input_keys = input_vocab.keys
input_vectors = input_vocab.vectors
else:
input_vectors = input_vocab.create_subset(input_keys).vectors
# If output vocabulary is not specified, use input vocabulary
# (i.e autoassociative memory)
if output_vocab is None:
output_vocab = input_vocab
output_vectors = input_vectors
else:
if output_keys is None:
output_keys = input_keys
output_vectors = output_vocab.create_subset(output_keys).vectors
if default_output_key is None:
default_output_vector = None
else:
default_output_vector = output_vocab.parse(default_output_key).v
# Create nengo network
with self:
self.am = AssocMem(input_vectors=input_vectors,
output_vectors=output_vectors,
threshold=threshold,
inhibitable=inhibitable,
label=label, seed=seed,
add_to_container=add_to_container)
if default_output_vector is not None:
self.am.add_default_output_vector(default_output_vector)
if wta_output:
self.am.add_wta_network(wta_inhibit_scale, wta_synapse)
if threshold_output:
self.am.add_threshold_to_outputs()
self.input = self.am.input
self.output = self.am.output
if inhibitable:
self.inhibit = self.am.inhibit
self.utilities = self.am.utilities
if threshold_output:
self.thresholded_utilities = self.am.thresholded_utilities
self.inputs = dict(default=(self.input, input_vocab))
self.outputs = dict(default=(self.output, output_vocab))
class AssociativeMemory(Module):
"""Associative memory module.
Parameters
----------
input_vocab: list of numpy.array, spa.Vocabulary
The vocabulary (or list of vectors) to match.
output_vocab: list of numpy.array, spa.Vocabulary, optional
The vocabulary (or list of vectors) to be produced for each match. If
not given, the associative memory will act like an auto-associative
memory (cleanup memory).
default_output_vector: numpy.array, spa.SemanticPointer, optional
The vector to be produced if the input value matches none of vectors
in the input vector list.
threshold: float, optional
The association activation threshold.
input_scale: float, optional
Scaling factor to apply on the input vectors.
inhibitable: boolean, optional
Flag to indicate if the entire associative memory module is
inhibitable (entire thing can be shut off).
inhibit_scale: float, optional
Scaling factor on the gating connections (must have inhibitable =
True). Setting a larger value will ensure that the cleanup memory
output is inhibited at a faster rate, however, recovery of the
network when inhibition is released will be slower.
wta_output: boolean, optional
Flag to indicate if output of the associative memory should contain
more than one vectors. Set to True if only one vectors output is
desired -- i.e. a winner-take-all (wta) output. Leave as default
(False) if (possible) combinations of vectors is desired.
wta_inhibit_scale: float, optional
Scaling factor on the winner-take-all (wta) inhibitory connections.
wta_synapse: float, optional
Synapse to use for the winner-take-all (wta) inhibitory connections.
output_utilities: boolean, optional
Flag to indicate if the direct utilities (in addition to the vectors)
are output as well.
output_thresholded_utilities: boolean, optional
Flag to indicate if the direct thresholded utilities (in addition to
the vectors) are output as well.
neuron_type: nengo.Neurons, optional
Neuron type to use in the associative memory. Defaults to
n_neurons_per_ensemble: int, optional
Number of neurons per ensemble in the associative memory. There is
one ensemble created per vector being compared.
"""
def __init__(self, input_vocab, output_vocab=None, # noqa: C901
input_keys=None, output_keys=None,
default_output_key=None, threshold=0.3,
inhibitable=False, wta_output=False,
wta_inhibit_scale=3.0, wta_synapse=0.005,
threshold_output=False, label=None, seed=None,
add_to_container=None):
super(AssociativeMemory, self).__init__(label, seed, add_to_container)
if input_keys is None:
input_keys = input_vocab.keys
input_vectors = input_vocab.vectors
else:
input_vectors = input_vocab.create_subset(input_keys).vectors
# If output vocabulary is not specified, use input vocabulary
# (i.e autoassociative memory)
if output_vocab is None:
output_vocab = input_vocab
output_vectors = input_vectors
else:
if output_keys is None:
output_keys = input_keys
output_vectors = output_vocab.create_subset(output_keys).vectors
if default_output_key is None:
default_output_vector = None
else:
default_output_vector = output_vocab.parse(default_output_key).v
# Create nengo network
with self:
self.am = AssocMem(input_vectors=input_vectors,
output_vectors=output_vectors,
threshold=threshold,
inhibitable=inhibitable,
label=label, seed=seed,
add_to_container=add_to_container)
if default_output_vector is not None:
self.am.add_default_output_vector(default_output_vector)
if wta_output:
self.am.add_wta_network(wta_inhibit_scale, wta_synapse)
if threshold_output:
self.am.add_threshold_to_outputs()
self.input = self.am.input
self.output = self.am.output
if inhibitable:
self.inhibit = self.am.inhibit
self.utilities = self.am.utilities
if threshold_output:
self.thresholded_utilities = self.am.thresholded_utilities
self.inputs = dict(default=(self.input, input_vocab))
self.outputs = dict(default=(self.output, output_vocab))
class AssociativeMemory(Module):
"""Associative memory module.
Parameters
----------
input_vocab: list of numpy.array, spa.Vocabulary
The vocabulary (or list of vectors) to match.
output_vocab: list of numpy.array, spa.Vocabulary, optional
The vocabulary (or list of vectors) to be produced for each match. If
not given, the associative memory will act like an auto-associative
memory (cleanup memory).
input_keys: list of strings, optional
List of keys (ordered) from the input vocabulary to use as the input
semantic pointers for the associative memory.
output_keys: list of strings, optional
List of keys (ordered) from the output vocabulary to use as the output
semantic pointers for the associative memory.
default_output_vector: numpy.array, spa.SemanticPointer, optional
The vector to be produced if the input value matches none of vectors
in the input vector list.
threshold: float, optional
The association activation threshold.
inhibitable: boolean, optional
Flag to indicate if the entire associative memory module is
inhibitable (entire thing can be shut off).
wta_output: boolean, optional
Flag to indicate if output of the associative memory should contain
more than one vectors. Set to True if only one vectors output is
desired -- i.e. a winner-take-all (wta) output. Leave as default
(False) if (possible) combinations of vectors is desired.
wta_inhibit_scale: float, optional
Scaling factor on the winner-take-all (wta) inhibitory connections.
wta_synapse: float, optional
Synapse to use for the winner-take-all (wta) inhibitory connections.
cleanup_output: boolean, optional
Create the associative memory with cleaned outputs as well as the
standard outputs.
replace_output_with_cleaned_output: boolean, optional
Set to true to use the cleaned outputs as the default output of the
associative memory module.
label : str, optional
A name to assign this AssociativeMemory. Used for visualization and
debugging. Also used as a label prefix for each of the internal
ensembles in the AssociativeMemory network.
Additional network parameters are passed to the Network constructor through
**module_kwargs
"""
def __init__(
self,
input_vocab,
output_vocab=None, # noqa: C901
input_keys=None,
output_keys=None,
default_output_key=None,
threshold=0.3,
inhibitable=False,
wta_output=False,
wta_inhibit_scale=3.0,
wta_synapse=0.005,
cleanup_output=False,
replace_output_with_cleaned_output=True,
label=None,
**module_kwargs):
super(AssociativeMemory, self).__init__(label=label, **module_kwargs)
if input_keys is None:
input_keys = input_vocab.keys
input_vectors = input_vocab.vectors
else:
input_vectors = input_vocab.create_subset(input_keys).vectors
# If output vocabulary is not specified, use input vocabulary
# (i.e autoassociative memory)
if output_vocab is None:
output_vocab = input_vocab
output_vectors = input_vectors
else:
if output_keys is None:
output_keys = input_keys
output_vectors = output_vocab.create_subset(output_keys).vectors
if default_output_key is None:
default_output_vector = None
else:
default_output_vector = output_vocab.parse(default_output_key).v
# Create nengo network
with self:
self.am = AssocMem(input_vectors=input_vectors,
output_vectors=output_vectors,
threshold=threshold,
inhibitable=inhibitable,
label=label,
**module_kwargs)
if default_output_vector is not None:
self.am.add_default_output_vector(default_output_vector)
if wta_output:
self.am.add_wta_network(wta_inhibit_scale, wta_synapse)
if cleanup_output:
self.am.add_cleanup_output(
replace_output=replace_output_with_cleaned_output)
self.input = self.am.input
self.output = self.am.output
if cleanup_output and not replace_output_with_cleaned_output:
self.cleaned_output = self.am.cleaned_output
if inhibitable:
self.inhibit = self.am.inhibit
self.utilities = self.am.output_utilities
if cleanup_output:
self.cleaned_utilities = self.am.cleaned_output_utilities
self.inputs = dict(default=(self.input, input_vocab))
self.outputs = dict(default=(self.output, output_vocab))
