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))