Building a Holographic Digit Classifier with NumPy and MNIST

 In this post, we’ll explore how to build a simple, yet powerful, holographic memory system to classify handwritten digits from the popular MNIST dataset. Using NumPy, we’ll create a system that represents digits as holographic encodings—dense vector representations—and compares new images using cosine similarity.

This approach draws inspiration from vector symbolic architectures (VSAs) and holographic reduced representations (HRRs) used in associative memory and cognitive modeling.

---

📦 Step 1: Organizing the Dataset

Assume you have MNIST digit data where each digit (0 to 9) is stored in its own folder. Each image has been preprocessed and saved as a .npy file (a NumPy array), possibly as a vector encoding or 2D array.

Folder structure:

python-repl
/mnist_vectors/
├── 0/
│   ├── img_0.npy
│   └── ...
├── 1/
│   └── ...
...
├── 9/

---

🧪 Step 2: Create the Holographic Memory File

We’ll create a single file (digit_holograms.npz) that stores a prototype vector for each digit. This is done by summing all the vectors in each folder and normalizing the result.

python
import numpy as np
import os

def create_digit_hologram_model_from_folders(root_folder, output_file):
    digit_holograms = {}

    for digit in range(10):
        digit_str = str(digit)
        folder_path = os.path.join(root_folder, digit_str)
        vectors = []

        for fname in os.listdir(folder_path):
            if fname.endswith('.npy'):
                vector = np.load(os.path.join(folder_path, fname))
                vectors.append(vector.flatten())  # Flatten to 1D

        if vectors:
            summed = np.sum(vectors, axis=0)
            normalized = summed / np.linalg.norm(summed)
            digit_holograms[digit_str] = normalized

    np.savez(output_file, **digit_holograms)
    print(f"Model saved to {output_file}")

This gives us a single .npz file with 10 normalized vectors—one per digit.

---

🔍 Step 3: Classify a New Image

To classify a new handwritten digit, we compare it to each digit vector in the hologram model using cosine similarity.

python
def cosine_similarity(a, b):
    a = a.flatten()
    b = b.flatten()
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def predict_digit(hologram_file, model_file):
    query = np.load(hologram_file).flatten()
    model = np.load(model_file)

    scores = {digit: cosine_similarity(query, model[digit]) for digit in model.files}
    best_digit = max(scores, key=scores.get)

    for digit, score in scores.items():
        print(f"Similarity with {digit}: {score:.4f}")
    print(f"\n✅ Predicted digit: {best_digit}")
    return best_digit

---

🧪 Step 4: Run It

python
model_file = "digit_holograms.npz"
new_image_file = "test_image.npy"

predict_digit(new_image_file, model_file)

---

🧠 Why This Works

This method leverages distributed representation—each digit is represented not by a single example, but by a summed, normalized memory vector that generalizes over 100s of examples.

Advantages:

• Fast comparisons (just a dot product!)

• Compact model file

• Easy to interpret and extend

---

📈 Next Steps

• Integrate with a real MNIST loader like tensorflow.keras.datasets.mnist.

• Replace .npy vectors with encodings from an autoencoder or other neural net.

• Apply to non-digit domains like gestures, audio, or other symbol-based input.

---

🔚 Conclusion

By combining simple tools like NumPy with ideas from holographic memory, we can build elegant and effective classifiers for high-dimensional symbolic data. This approach shows how cognitive science and machine learning can come together in practical, scalable ways.

Here is the results of using the MNST testing set: