VSA Models

The jax_hdc.vsa module provides Vector Symbolic Architecture model implementations.

Base Class

class jax_hdc.vsa.VSAModel(name: str, dimensions: int)[source]

Base class for VSA models defining the interface.

name: str

dimensions: int

bind(x: Array, y: Array) → Array[source]: Bind two hypervectors.

bundle(vectors: Array, axis: int = 0) → Array[source]: Bundle multiple hypervectors.

inverse(x: Array) → Array[source]: Compute the inverse of a hypervector.

similarity(x: Array, y: Array) → Array[source]: Compute similarity between hypervectors.

random(key: Array, shape: tuple) → Array[source]: Generate random hypervectors.

__init__(name: str, dimensions: int) → None

Binary Spatter Codes

class jax_hdc.vsa.BSC(name: str, dimensions: int)[source]

Binary Spatter Codes (BSC).

Binary hypervectors with XOR binding, majority bundling, Hamming similarity.

static create(dimensions: int = 10000) → BSC[source]

Create a BSC model.

Parameters:: dimensions – Dimensionality of hypervectors (default: 10000)
Returns:: Initialized BSC model

bind(x: Array, y: Array) → Array[source]: Bind using XOR.

bundle(vectors: Array, axis: int = 0) → Array[source]: Bundle using majority rule.

inverse(x: Array) → Array[source]: Inverse is identity for XOR.

similarity(x: Array, y: Array) → Array[source]: Compute Hamming similarity.

random(key: Array, shape: tuple) → Array[source]

Generate random binary hypervectors.

Parameters:

key – JAX random key
shape – Shape of output array

Returns:

Random binary hypervectors with ~50% ones

__init__(name: str, dimensions: int) → None

Multiply-Add-Permute

class jax_hdc.vsa.MAP(name: str, dimensions: int)[source]

Multiply-Add-Permute (MAP).

Real-valued vectors with element-wise multiply binding, normalized sum bundling, cosine similarity.

static create(dimensions: int = 10000) → MAP[source]

Create a MAP model.

Parameters:: dimensions – Dimensionality of hypervectors (default: 10000)
Returns:: Initialized MAP model

bind(x: Array, y: Array) → Array[source]: Bind using element-wise multiplication.

bundle(vectors: Array, axis: int = 0) → Array[source]: Bundle using normalized sum.

inverse(x: Array) → Array[source]: Inverse via element-wise reciprocal.

similarity(x: Array, y: Array) → Array[source]: Compute cosine similarity.

random(key: Array, shape: tuple) → Array[source]

Generate random real-valued hypervectors.

Parameters:

key – JAX random key
shape – Shape of output array

Returns:

Random normalized hypervectors sampled from normal distribution

__init__(name: str, dimensions: int) → None

Holographic Reduced Representations

class jax_hdc.vsa.HRR(name: str, dimensions: int)[source]

Holographic Reduced Representations (HRR).

Real-valued vectors with circular convolution binding, normalized sum bundling, cosine similarity.

static create(dimensions: int = 10000) → HRR[source]

Create an HRR model.

Parameters:: dimensions – Dimensionality of hypervectors (default: 10000)
Returns:: Initialized HRR model

bind(x: Array, y: Array) → Array[source]: Bind using circular convolution.

bundle(vectors: Array, axis: int = 0) → Array[source]: Bundle using normalized sum.

inverse(x: Array) → Array[source]: Inverse via element reversal.

similarity(x: Array, y: Array) → Array[source]: Compute cosine similarity.

random(key: Array, shape: tuple) → Array[source]

Generate random real-valued hypervectors.

Parameters:

key – JAX random key
shape – Shape of output array

Returns:

Random normalized hypervectors sampled from normal distribution

__init__(name: str, dimensions: int) → None

Fourier HRR

class jax_hdc.vsa.FHRR(name: str, dimensions: int)[source]

Fourier Holographic Reduced Representations (FHRR).

Complex-valued vectors with element-wise multiply binding, normalized sum bundling.

static create(dimensions: int = 10000) → FHRR[source]

Create an FHRR model.

Parameters:: dimensions – Dimensionality of hypervectors (default: 10000)
Returns:: Initialized FHRR model

bind(x: Array, y: Array) → Array[source]: Bind using element-wise multiplication.

bundle(vectors: Array, axis: int = 0) → Array[source]: Bundle using normalized sum.

inverse(x: Array) → Array[source]: Inverse via complex conjugate.

similarity(x: Array, y: Array) → Array[source]: Compute cosine similarity of complex vectors.

random(key: Array, shape: tuple) → Array[source]

Generate random complex hypervectors on unit circle.

Parameters:

key – JAX random key
shape – Shape of output array

Returns:

Random unit complex hypervectors

__init__(name: str, dimensions: int) → None

Factory Function

jax_hdc.vsa.create_vsa_model(model_type: str = 'map', dimensions: int = 10000) → VSAModel[source]

Factory function to create VSA models.

Parameters:

model_type – Type of VSA model (‘bsc’, ‘map’, ‘hrr’, ‘fhrr’, ‘bsbc’, ‘cgr’, ‘mcr’, ‘vtb’)
dimensions – Dimensionality of hypervectors (default: 10000)

Returns:

Initialized VSA model

Example Usage

Creating models:

from jax_hdc import BSC, MAP, HRR, FHRR
import jax

key = jax.random.PRNGKey(42)

# Binary Spatter Codes
bsc = BSC.create(dimensions=10000)
x = bsc.random(key, (10000,))
y = bsc.random(key, (10000,))
bound = bsc.bind(x, y)

# MAP
map_model = MAP.create(dimensions=10000)
x = map_model.random(key, (10000,))
y = map_model.random(key, (10000,))
bound = map_model.bind(x, y)

Using factory function:

from jax_hdc.vsa import create_vsa_model

model = create_vsa_model('map', dimensions=10000)