A comprehensive Python package for cognitive computing, implementing various brain-inspired computing paradigms for robust, efficient, and adaptive information processing.

The cognitive-computing package provides implementations of several cognitive computing paradigms:

• Sparse Distributed Memory (SDM) ✅ - Fully implemented
• Holographic Reduced Representations (HRR) ✅ - Fully implemented
• Vector Symbolic Architectures (VSA) ✅ - Fully implemented
• Hyperdimensional Computing (HDC) ✅ - Fully implemented

These technologies enable:

• 🧠 Brain-inspired computing - Models based on human memory and cognition
• 🔍 Content-addressable storage - Retrieve data by content, not location
• 🌊 Noise tolerance - Graceful degradation with noisy inputs
• ⚡ Fast approximate computing - Trade precision for speed and robustness
• 🔗 Symbolic reasoning - Combine neural and symbolic approaches

git clone https://github.com/transparentai-tech/cognitive-computing.git
cd cognitive-computing
pip install -e .

pip install -e ".[dev]"

pip install -e ".[viz]"

pip install -e ".[gpu]"

import numpy as np
from cognitive_computing.sdm import create_sdm

# Create a 1000-dimensional SDM
sdm = create_sdm(dimension=1000)

# Generate random binary patterns
address = np.random.randint(0, 2, 1000)
data = np.random.randint(0, 2, 1000)

# Store the pattern
sdm.store(address, data)

# Recall with perfect address
recalled_data = sdm.recall(address)
print(f"Perfect recall accuracy: {np.mean(recalled_data == data):.2%}")

# Recall with noisy address (10% noise)
from cognitive_computing.sdm.utils import add_noise
noisy_address = add_noise(address, noise_level=0.1)
recalled_noisy = sdm.recall(noisy_address)
print(f"Noisy recall accuracy: {np.mean(recalled_noisy == data):.2%}")

from cognitive_computing.sdm import SDM, SDMConfig

# Custom configuration
config = SDMConfig(
    dimension=2000,
    num_hard_locations=5000,
    activation_radius=900,
    storage_method="counters",  # or "binary"
    parallel=True,
    num_workers=4
)

# Create SDM with custom parameters
sdm = SDM(config)

# Use different address decoders
from cognitive_computing.sdm.address_decoder import create_decoder

# Options: 'hamming', 'jaccard', 'random', 'adaptive', 'hierarchical', 'lsh'
decoder = create_decoder('adaptive', config, sdm.hard_locations)

from cognitive_computing.hrr import create_hrr
from cognitive_computing.hrr.encoding import RoleFillerEncoder

# Create HRR system
hrr = create_hrr(dimension=1024)

# Basic binding and unbinding
role = hrr.generate_vector()
filler = hrr.generate_vector()
binding = hrr.bind(role, filler)
retrieved = hrr.unbind(binding, role)
print(f"Similarity: {hrr.similarity(retrieved, filler):.3f}")

# Encode structured information
encoder = RoleFillerEncoder(hrr)
person = encoder.encode_structure({
    "name": hrr.generate_vector(),  # Vector for "John"
    "age": hrr.generate_vector(),    # Vector for "25"
    "city": hrr.generate_vector()    # Vector for "Boston"
})

# Cleanup memory for robust retrieval
from cognitive_computing.hrr.cleanup import CleanupMemory, CleanupMemoryConfig

cleanup = CleanupMemory(CleanupMemoryConfig(threshold=0.3), dimension=1024)
cleanup.add_item("john", hrr.generate_vector())
cleanup.add_item("mary", hrr.generate_vector())

# Clean up noisy vectors
noisy_vector = retrieved + np.random.randn(1024) * 0.2
name, clean_vector, similarity = cleanup.cleanup(noisy_vector, return_similarity=True)

from cognitive_computing.vsa import create_vsa, VSAConfig, VectorType

# Create VSA system
vsa = create_vsa(dimension=10000, vector_type=VectorType.BIPOLAR)

# Basic binding operations
a = vsa.generate_vector()
b = vsa.generate_vector()
bound = vsa.bind(a, b)
recovered = vsa.unbind(bound, a)
print(f"Similarity: {vsa.similarity(recovered, b):.3f}")

# Bundle multiple vectors
vectors = [vsa.generate_vector() for _ in range(5)]
bundled = vsa.bundle(vectors)

# Use different architectures
from cognitive_computing.vsa.architectures import BSC, MAP, FHRR

# Binary Spatter Codes
bsc = BSC(dimension=8192)
x = bsc.generate_vector()
y = bsc.generate_vector()
z = bsc.bind(x, y)  # XOR binding

# Multiply-Add-Permute
map_vsa = MAP(dimension=10000)
bound = map_vsa.bind(a, b)  # Uses multiplication and permutation

# Fourier HRR
fhrr = FHRR(dimension=1024)
complex_bound = fhrr.bind(a, b)  # Complex-valued binding

• Multiple Storage Methods

  • Counter-based (default) - Better noise tolerance
  • Binary - Lower memory usage

• Six Address Decoders

  • Hamming - Classic distance-based
  • Jaccard - For sparse data
  • Random - O(1) hashing
  • Adaptive - Self-adjusting
  • Hierarchical - Multi-level
  • LSH - Locality-sensitive hashing

• Comprehensive Analysis Tools

  • Memory capacity estimation
  • Activation pattern analysis
  • Performance benchmarking
  • Crosstalk measurement

• Data Encoding Utilities

  • Integer encoding
  • Float encoding
  • String encoding
  • Vector encoding

• Visualization Support

  • Memory distribution plots
  • Activation patterns
  • Recall accuracy curves
  • Interactive 3D visualizations

• Core Operations

  • Circular convolution binding
  • Circular correlation unbinding
  • Vector bundling (superposition)
  • Real and complex storage modes

• Encoding Strategies

  • Role-filler binding
  • Sequence encoding (positional/chaining)
  • Hierarchical structures
  • Tree encoding

• Cleanup Memory

  • Item storage and retrieval
  • Similarity-based cleanup
  • Multiple similarity metrics
  • Persistence support

• Analysis Tools

  • Binding capacity analysis
  • Crosstalk measurement
  • Performance benchmarking
  • Vector generation utilities

• Visualization Support

  • Similarity matrices
  • Convolution spectra
  • Cleanup space visualization
  • Performance dashboards

• Vector Types

  • Binary vectors {0, 1}
  • Bipolar vectors {-1, +1}
  • Ternary vectors {-1, 0, +1}
  • Complex unit vectors
  • Integer vectors

• Binding Operations

  • XOR (self-inverse for binary)
  • Element-wise multiplication
  • Circular convolution
  • MAP (Multiply-Add-Permute)
  • Permutation-based binding

• VSA Architectures

  • Binary Spatter Codes (BSC)
  • Multiply-Add-Permute (MAP)
  • Fourier HRR (FHRR)
  • Sparse VSA
  • HRR-compatible mode

• Encoding Strategies

  • Random indexing for text
  • Spatial encoding for coordinates
  • Temporal encoding for sequences
  • Level encoding for continuous values
  • Graph encoding for networks

• Analysis and Utilities

  • Capacity analysis
  • Vector generation utilities
  • Architecture comparison tools
  • Performance benchmarking
  • Cross-architecture conversion

• Hypervector Types

  • Binary hypervectors {0, 1}
  • Bipolar hypervectors {-1, +1}
  • Ternary hypervectors {-1, 0, +1}
  • Level hypervectors (multi-level quantized)

• Core Operations

  • Binding (XOR for binary, multiplication for others)
  • Bundling (majority vote, averaging, weighted)
  • Permutation (cyclic shift, random, block)
  • Similarity (Hamming, cosine, Euclidean, Jaccard)

• Classifiers

  • One-shot learning classifier
  • Adaptive online classifier
  • Ensemble voting classifier
  • Hierarchical multi-level classifier

• Item Memory

  • Associative storage and retrieval
  • Content-based cleanup
  • Similarity queries
  • Merge and update operations

• Encoding Strategies

  • Scalar encoding (thermometer, level)
  • Categorical encoding
  • Sequence encoding (n-gram, positional)
  • Spatial encoding (multi-dimensional)
  • Record encoding (structured data)
  • N-gram text encoding

• Analysis and Utilities

  • Capacity measurement
  • Noise robustness testing
  • Performance benchmarking
  • Binding property analysis
  • Similarity distribution analysis

from cognitive_computing.sdm import create_sdm
from cognitive_computing.sdm.utils import generate_random_patterns, add_noise

# Create SDM
sdm = create_sdm(dimension=1000)

# Generate base pattern and variations
base_pattern = np.random.randint(0, 2, 1000)
variations = [add_noise(base_pattern, 0.05) for _ in range(10)]

# Store all variations with same label
label = np.array([1, 0, 0, 0] + [0] * 996)  # One-hot encoded label
for variant in variations:
    sdm.store(variant, label)

# Recognize noisy input
test_input = add_noise(base_pattern, 0.15)
recalled_label = sdm.recall(test_input)
print(f"Pattern recognized: {np.argmax(recalled_label)}")

# Store sequential patterns
sequence = generate_random_patterns(10, 1000)[0]  # 10 patterns

for i in range(len(sequence) - 1):
    sdm.store(sequence[i], sequence[i + 1])

# Recall sequence
current = sequence[0]
recalled_sequence = [current]

for _ in range(len(sequence) - 1):
    current = sdm.recall(current)
    recalled_sequence.append(current)

from cognitive_computing.sdm.utils import PatternEncoder

encoder = PatternEncoder(dimension=1000)
sdm = create_sdm(dimension=1000)

# Encode and store different data types
# Integer
age = 25
age_encoded = encoder.encode_integer(age)
sdm.store(age_encoded, age_encoded)

# String
name = "Alice"
name_encoded = encoder.encode_string(name)
sdm.store(name_encoded, name_encoded)

# Float array
features = np.array([0.1, 0.5, 0.9, 0.2])
features_encoded = encoder.encode_vector(features)
sdm.store(features_encoded, features_encoded)

SDM operations are highly efficient:

from cognitive_computing.sdm.utils import evaluate_sdm_performance

# Run performance benchmark
results = evaluate_sdm_performance(sdm, test_patterns=100)

print(f"Write time: {results.write_time_mean*1000:.2f} ms")
print(f"Read time: {results.read_time_mean*1000:.2f} ms")
print(f"Recall accuracy: {results.recall_accuracy_mean:.2%}")

For large-scale applications, enable parallel processing:

config = SDMConfig(
    dimension=5000,
    num_hard_locations=10000,
    parallel=True,
    num_workers=8
)
sdm = SDM(config)

from cognitive_computing.sdm.visualizations import (
    plot_memory_distribution,
    plot_recall_accuracy,
    visualize_memory_contents
)

# Analyze memory distribution
fig = plot_memory_distribution(sdm)

# Test and plot recall accuracy
test_results = evaluate_sdm_performance(sdm)
fig = plot_recall_accuracy(test_results)

# Interactive 3D visualization
fig = visualize_memory_contents(sdm, interactive=True)

• Installation Guide
• Contributing Guide

• SDM Overview
• SDM API Reference
• SDM Theory and Mathematics
• SDM Examples
• SDM Performance Guide

• HRR Overview
• HRR API Reference
• HRR Theory and Mathematics
• HRR Examples
• HRR Performance Guide

• VSA Overview
• VSA API Reference
• VSA Theory and Mathematics
• VSA Examples
• VSA Performance Guide

• HDC Overview
• HDC API Reference
• HDC Theory and Mathematics
• HDC Examples
• HDC Performance Guide

Run the test suite:

# Run all tests
pytest

# Run specific module tests
pytest tests/test_sdm/

# Run with coverage
pytest --cov=cognitive_computing

# Run only fast tests
pytest -m "not slow"

We welcome contributions! Please see our Contributing Guide for details.

# Install in development mode with all dependencies
pip install -e ".[dev,viz]"

# Run code formatting
black cognitive_computing tests

# Run linting
flake8 cognitive_computing tests

# Run type checking
mypy cognitive_computing

• ✅ Sparse Distributed Memory (SDM) - Complete

  • Core implementation with counter/binary storage
  • Six address decoder strategies
  • Comprehensive utilities and visualizations
  • Full test coverage (226/226 tests passing)

• ✅ Holographic Reduced Representations (HRR) - Complete

  • Circular convolution/correlation operations
  • Role-filler and sequence encoding
  • Cleanup memory implementation
  • Full test coverage (184/184 tests passing)

• ✅ Vector Symbolic Architectures (VSA) - Complete

  • Five vector types (binary, bipolar, ternary, complex, integer)
  • Five binding operations (XOR, multiplication, convolution, MAP, permutation)
  • Five complete architectures (BSC, MAP, FHRR, Sparse VSA, HRR-compatible)
  • Comprehensive encoding strategies and utilities
  • Near-complete test coverage (294/295 tests passing - 99.7%)

• ✅ Hyperdimensional Computing (HDC) - Complete

  • Four hypervector types (binary, bipolar, ternary, level)
  • Core operations (bind, bundle, permute, similarity)
  • Item memory with associative retrieval
  • Advanced classifiers (one-shot, adaptive, ensemble, hierarchical)
  • Multiple encoding strategies (scalar, categorical, sequence, spatial, n-gram)
  • Full test coverage (193/193 tests passing - 100%)

• Total Tests: 898 (897 passing, 1 skipped - 99.89% success rate)
• Total Modules: 36 core implementation files
• Example Scripts: 20 (all tested and working)
• Documentation: Complete API references, theory guides, and examples

• 🚧 Advanced Integration Features

  • Cross-paradigm operations
  • Neural network interfaces (PyTorch, TensorFlow)
  • GPU acceleration
  • Distributed computing support

• 🚧 Future Enhancements (see planned_development/)

  • Advanced decoders and storage mechanisms for SDM
  • Enhanced convolution operations for HRR
  • Learning and adaptation mechanisms for VSA
  • Extreme-scale operations and quantum integration for HDC
  • Unified cognitive architecture
  • Complementary Technologies

If you use this package in your research, please cite:

@software{cognitive_computing,
  title = {Cognitive Computing: A Python Package for Brain-Inspired Computing},
  author = {Ian Hamilton},
  year = {2025},
  url = {https://github.com/transparentai-tech/cognitive-computing}
}

• Kanerva, P. (1988). Sparse Distributed Memory. MIT Press.
• Kanerva, P. (1993). "Sparse Distributed Memory and Related Models." Associative Neural Memories.

• Plate, T. A. (1995). "Holographic Reduced Representations." IEEE Transactions on Neural Networks.

• Gayler, R. W. (2003). "Vector Symbolic Architectures Answer Jackendoff's Challenges for Cognitive Neuroscience."
• Kanerva, P. (2009). "Hyperdimensional Computing: An Introduction to Computing in Distributed Representation."
• Plate, T. A. (2003). Holographic Reduced Representation: Distributed Representation for Cognitive Structures. CSLI Publications.

This project is licensed under the MIT License - see the LICENSE file for details.

• Inspired by Pentti Kanerva's groundbreaking work on Sparse Distributed Memory
• Thanks to all contributors and the cognitive computing research community

Note: This package is ready for production use! All four core paradigms (SDM, HRR, VSA, HDC) are fully implemented with comprehensive test coverage (99.89%). The package is actively maintained and we welcome contributions for advanced integration features.