An implementation of the Semantic Pointer Architecture for Nengo
Implementation of the Semantic Pointer Architecture for Nengo
The Semantic Pointer Architecture provides an approach to building cognitive models implemented with large-scale spiking neural networks.
Write arbitrarily complex expressions with type checking involving neurally represented and static Semantic Pointers like dot((role * filler + BiasVector) * tag, cmp) >> target. NengoSPA will take care of implementing the required neural networks.
Quickly implement action selection systems based on a biological plausible model of the basal ganglia and thalamus.
Neural representations are optimized for representing Semantic Pointers.
Support for using different binding methods with algebras. NengoSPA ships with implementations of circular convolution (default) and vector-derived transformation binding (VTB), which is particularly suitable for deep structures. Different binding operations/algebras can be mixed in a single model.
Seamless integration with non-SPA Nengo models.
Binding powers and fractional bindings.
All of the core functionality is implemented and the API is stable.
While basic integration with the NengoGUI works, it should be improved in the future. However, this will not be pursued until major improvements to NengoGUI are released.
NengoSPA depends on Nengo 2.7+, and we recommend that you install Nengo before installing NengoSPA.
To install NengoSPA:
pip install nengo-spa
NengoSPA is tested to work on Python 3.6+.
If you need support for Python 2.7 or 3.4, NengoSPA 0.6.2 is the last version with support for these earlier Python versions.
The documentation can be found here.
Questions relating to Nengo and NengoSPA, whether it’s use or it’s development, should be asked on the Nengo forum at https://forum.nengo.ai.
1.3.0 (November 30, 2021)
Support for (fractional) binding powers and the notion of signs in algebras and for SemanticPointer instances. (#271, #286)
EquallySpacedPositiveUnitaryHrrVectors and VectorsWithProperties vector generators. (#284, #285)
Example of how to use learning connections between State modules. (#16, #288)
Scalar arrays like np.array(1) will now be treated as scalars as intended. (#289)
1.2.0 (November 15, 2020)
Transposed Vector-derived Transformation Binding (TVTB) algebra which has essentially the same properties as the existing VTB algebra, but has two-sided identities and inverses (opposed to VTB where these are right-sided only). The only difference in the math is that TVTB transposes the matrix used in the binding operation. (#266)
Differentiation between left, right, and two-sided special elements (identity, zero, absorbing element, inverse) of an algebra. (#265)
Added linv and rinv methods to SemanticPointer for the left and right inverse, respectively. (#265)
Add support for the normalized and unitary methods on Semantic Pointer symbols. (#265)
Creating special elements (identity, zero, absorbing element, inverse) of the VtbAlgebra without sidedness argument has been deprecated because these are only right-sided special element. Add the sidedness=ElementSidedness.RIGHT argument to update your code. (#265)
The ~ operator has been deprecated for the VtbAlgebra. Use the rinv() method instead. (#265)
Improved automatic names for SemanticPointer that only contain parenthesis where actually needed. In addition, syntax is considered when shortening a name exceeding the maximum length. (#255, #270)
1.1.1 (November 3, 2020)
1.1.0 (June 23, 2020)
Make AbstractAlgebra an actual abstract base class (using ABCMeta as meta-class). While still supported, this deprecates pure duck-typing for algebras. (#240)
Raise an exception when a Semantic Pointer is added to a vocabulary with a differing algebra. (#239, #240)
All examples now have seeds to ensure that occasional “bad seeds” do not create problems in the documentation. (#248)
SemanticPointer.translate and PointerSymbol.translate now use the keys argument; previously, this argument was mistakenly ignored. (#248)
Fixed an issue where the names of iteratively generated semantic pointers could grow exponentially in length, by truncating them at 1 KB. (#244, #246)
Allow NumPy scalars in place of Python scalars for binary operations on SemanticPointer instances. (#250, #257)
The SPA sequence example was not working properly due to a missing connection. (#258, #259)
1.0.1 (December 14, 2019)
1.0.0 (December 12, 2019)
Modules and networks no longer set a default label. This will give more useful labels by default in Nengo GUI (assuming the latest dev version). (#234, #235)
All networks have been converted to classes. This will give more useful labels by default in Nengo GUI (assuming the latest dev version). (#234, #235)
0.6.2 (June 21, 2019)
Add previously missing documentation on the vector_generation module as well as the reinterpret and translate methods of SemanticPointer. (#228, #229)
0.6.1 (April 26, 2019)
0.6.0 (September 17, 2018)
Support for algebras that allow to use binding operations other than circular convolution. This includes an implementation of vector-derived transformation binding (VTB) and the nengo_spa.networks.VTB network to perform this particular binding operation. (#69, #198)
Added generators for vectors with different properties that can be used to define how vectors are created in a vocabulary (e.g., axis-aligned, orthogonal, unitary). (#201, #129)
Added a matrix multiplication network nengo_spa.networks.MatrixMult based on the nengo-extras implementation. (#198)
Allow to connect to the utility node returned by ifmax with the SPA >> operator. (#190, #194)
The Semantic Pointer names AbsorbingElement, Identity, and Zero now have a special meaning in Vocabulary and nengo_spa.sym and will return the respective special Semantic Pointers. (#195, #176)
SemanticPointer instance can now track names for improved labeling in Nengo GUI. (#202, #184)
Label the utility nodes for the action selection. (#202)
A number of module names have been changed for better naming consistency. In particular,
nengo_spa.actions to nengo_spa.action_selection,
nengo_spa.pointer to nengo_spa.semantic_pointer,
nengo_spa.vocab to nengo_spa.vocabulary,
and nengo_spa.modules.assoc_mem to nengo_spa.modules.associative_memory.
Require the mapping argument for associative memories. In addition to dictionaries and the string 'by-key', a sequence of strings can be passed in to create an auto-associative memory. (#177)
Changed the rng argument for Vocabulary to pointer_gen. (#201)
Renamed input_a and input_b of the nengo_spa.Bind module to input_left and input_right to account for non-commutative binding methods where the order of operands matters. Also, renamed the invert_a and invert_b arguments to unbind_left and unbind_right to reflect that some binding methods might not have inverse vectors, but might still be able to do unbinding. (#69, #198)
Renamed the nengo_spa.State parameter represent_identity to represent_cc_identity to reflect that it only optimizes for the circular convolution identity, but not the identity for other binding operations. (#212)
Removed nengo_spa.networks.circularconvolution.circconv because nengo_spa.algebras.CircularConvolutionAlgebra provides the same functionality. (#198)
The SemanticPointer class does no longer accept a single integer as dimensionality to create a random vector. Use the new generators in nengo_spa.vector_generation instead. (#201)
Raise an exception instead of returning incorrect results from prob_cleanup. Also, fix the function’s incorrect documentation. (#203, #206)
Fix nengo_spa.ActionSelection.keys() when no named actions have been provided. (#210)
Do not create an unnecessary compare network when computing a dot product with a SemanticPointer instance. (#202)
Handle SemanticPointer instances correctly as first argument to nengo_spa.dot. (#202)
0.5.2 (July 6, 2018)
SPA modules will use the same default vocabularies even if not instantiated in the context of a spa.Network. (#174, #185)
Disallow Python keywords, including None, True, and False, as well as unicode characters from Python names. (#188, #187)
Allow action rules without name to have no effects. (#189, #191)
Raise exception when using NumPy arrays in SPA operations which would give unexpected results. (#192, #193)
0.5.1 (June 7, 2018)
0.5.0 (June 1, 2018)
One-dimensional outputs of Nengo objects can be used as scalars in action rules. (#139, #157)
Syntactic sugar for complex symbolic expressions: nengo_spa.sym('A + B * C'). (#138, #159)
Include the achieved similarity in warning issued when desired maximum similarity could not be obtained. (#117, #158)
Possibility to name Vocabulary instances for debugging. (#163, #165)
0.4.1 (May 18, 2018)
This release fixes problems with the online documentation. Local installs are not affected.
0.4.0 (May 17, 2018)
This release increases the minimum required Nengo version to Nengo 2.7 (previously Nengo 2.4).
Added documentation and build tools for the documentation. (#68)
This release introduces a new syntax for SPA action rules. (#114)
Unnecessary vocab argument from Transcode. (#68)
0.3.2 (November 17, 2017)
0.3.1 (November 7, 2017)
Clearer error message as a SpaTypeError something is used as input/output in an action rule without being declared as such. (#82, #89)
Fixed warning produce by the create_inhibit_node function. (#90)
Prevent whitespace from being completely removed in action rules. (#92, #93)
Have the intercept_width argument of IA actually take effect. (#94, #97)
0.3.0 (October 16, 2017)
Add add_output and add_neuron_output methods to IdentityEnsembleArray to provide the full API that is provided by the regular Nengo EnsembleArray. (#61, #28)
Add create_inhibit_node function to create nodes that inhibit complete Nengo networks. (#65, #26)
Add a solver argument to the action rule’s translate to use a solver instead of an outer product to obtain the transformation matrix which can give slightly better results. (#62, #57)
Actions rules do not require module to be assigned to the model any longer. They will access exactly the same variables as are available in the surrounding Python code. This means that existing action rules need to be changed to reference the correct names. (#63)
Actions will be build automatically without an explicit call to build(). (#59, #45, #55)
Consolidated the functionality of Encode and Decode into Transcode. (#67, #58)
Fix some operations changing the dimensionality of semantic pointers with an odd initial dimensionality. (#52, #53)
When building actions the basal ganglia and thalamus will only be created when actually required. (#60, #42)
The vocabulary translate mechanism will properly ignore missing keys in the target vocabulary when populate=False. (#62, #56)
Allow empty string as argument to Vocabulary.populate. (#73)
0.2 (June 22, 2017)
Tutorial explaining what has changed in nengo_spa compared to the legacy SPA implementation. (#46)
Examples can be extracted with python -m nengo_spa extract-examples <destination>. (#49, #7)
Replaced input_keys and output_keys arguments of associative memories with a single mapping argument. (#29, #8)
Replaced ampa_config and gaba_config parameters of the BasalGanglia with ampa_synapse and gaba_synapse parameters. Removed the general_config parameter. (#30, #23)
0.1.1 (May 19, 2017)
Updated the 0.1 changelog.
0.1 (May 19, 2017)
Initial release of Nengo SPA with core functionality, but excluding
updates and completion the documentation,
proper integration with Nengo GUI.
The API is still conisdered unstable in some parts of it are likely to change in the future.
Main features compared to the SPA implementation shipped with Nengo are:
neural representations have been optimized for higher accuracy,
support for arbitrarily complex action rules,
SPA networks can be used as normal Nengo networks,
and SPA networks can be nested.
Release history Release notifications | RSS feed
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Hashes for nengo_spa-1.3.0-py2.py3-none-any.whl