How HDC complements deep learning

In our earlier post on where “meaning” in hypervectors comes from, we showed how a learned text embedding can transfer useful similarity structures into hypervector space. This leads to a larger question: if deep learning can already learn strong representations, what does HDC add, and how can we design systems that leverage the best of both worlds?

The good news is that HDC and deep learning don’t need to solve the same part of the problem. Deep learning is remarkably good at learning useful patterns from large amounts of text, images, audio, and other complex inputs. HDC gives us a different set of tools that can work well around existing approaches: it lets us compose those representations, search them associatively, and update what a system remembers.

Asking the right question

Conversations about HDC often begin by asking whether it can replace an existing deep learning-based approach. This is fundamentally the wrong question to ask.

Deep learning models can learn powerful representations through iterative optimization, whereas HDC gives us explicit operations for composing and updating representations once we have them. Many conventional HDC systems learn by directly updating stored hypervectors as new examples arrive, instead of backpropagating through a large network.

At their core, these are different capabilities. The table below reframes three common questions:

The common question	The more useful question
Which approach is better?	What part of the problem should each approach solve?
Which approach is more efficient?	Are we measuring pretraining, inference, or adaptation after deployment?
Can HDC replace a neural network?	Can HDC operate on representations that a neural network has already learned?

There isn’t a set boundary at which HDC is more suitable than deep learning or vice versa. A neural network’s encoder might be frozen, fine-tuned using a parameter-efficient method such as Low-Rank Adaptation (LoRA)¹ , or trained together with HDC components. The point is not to design a rigid architecture that combines these two systems. As developers, we have the flexibility to decide, on a task-by-task basis, which representations should be learned, and where they should be learned.

The next two sections explore the contrast between HDC and deep learning systems, while also highlighting some complementary aspects.

What deep learning does remarkably well

Deep learning’s greatest strength is that it can learn useful features directly from data. We don’t need to specify every visual pattern that identifies an object or every linguistic cue that relates two sentences. Given enough examples and a suitable training objective, a neural network can shape its internal representations around the distinctions that matter for its task.

This is done through iterative optimization. The model makes a prediction, measures its error against a training signal, and uses backpropagation to adjust its parameters. Across many updates, inputs that the training objective treats similarly can acquire similar representations. This form of training is what makes pretrained models so useful: features learned from a large dataset can be reused for new tasks instead of being designed or learned again from scratch.

Those strengths appear differently at each stage:

Stage	What it does well	Why it matters
Pretraining	Learns rich, reusable representations from large collections of unstructured data	Captures complex patterns that would be impractical to specify by hand and makes them transferable
Inference	Produces rich, task-dependent outputs from new inputs, including text, images, predictions, and multi-step responses	Supports open-ended generation and complex reasoning tasks that conventional HDC systems aren’t designed to perform on their own
Adaptation or fine-tuning	Adapts a pretrained model to a new task, domain, or changing data distribution	Reuses broad capabilities, typically requiring less data and optimization than training from scratch

However, these strengths still come with trade-offs when a model needs to change after deployment. Retraining or fine-tuning can be finicky, and once done, models may require highly specific kernel optimizations to deploy them at scale. Explainability is also challenging because learned behavior is distributed across billions (or trillions) of interacting parameters, making it difficult to explain exactly what changed and why.

How learning works in HDC

We’ve seen before that HDC uses a fixed encoder rather than a learnable one. It determines how inputs are represented, but the encoder itself is not usually where a conventional HDC system learns. Instead, the system often learns by building a separate representation from those fixed hypervectors for each record: in the literature, this is called a prototype.

A prototype is a hypervector that summarizes multiple hypervectors of a given class.² It’s built using the same set of operations (binding, bundling, permutation) that HDC provides. Each incoming example passes through the fixed encoder and is then bundled into the appropriate prototype. The individual record hypervectors remain unchanged, while the prototype evolves into a distributed summary of what the examples have in common. The prototype is the learner’s changing state.

Concept	What it means in a conventional HDC system
Encoder	A fixed mapping that turns an input into a hypervector
Prototype	A stored hypervector that summarizes the examples associated with one class or concept
Learning	Updating a prototype by bundling in a newly encoded example
Memory	The collection of prototypes the system has learned
Recall	Comparing a query hypervector with that memory to find the most similar stored prototype

Because a prototype can be updated with one hypervector at a time, learning can happen online as each example arrives, rather than requiring a separate offline training phase. There is no need to wait for a complete training set, run backpropagation, or retrain the encoder. Updating the memory is a cheap operation, and it’s ready to query immediately.

This gives us a useful contrast. Deep learning usually places learned behavior across the parameters of a model and separates training from inference. Prototype-based HDC keeps the representation rule stable and puts new knowledge in an explicit, updatable memory around it. Updating the prototypes is what we might call “learning,” while comparing a query with them is sometimes referred to as “recall.”

A prototype can refine what the system knows within the space supplied by its encoder, but it cannot discover a feature that the encoder never represented. HDC is therefore strongest when the important features are already known or supplied by another model.

This leads us to how the approaches can work well together.

Bridging the two worlds

An encoder (either in deep learning or in HDC) can turn raw input into a useful representation. When the representation is projected into hypervector space, HDC provides explicit composition, associative search, and the ability to do lightweight updates.

In a hybrid system, the neural network component supplies task-relevant features, while HDC supplies the encoding, composition, retrieval, and memory operations.

Let’s look across the literature to analyze some common patterns that combine the two approaches with increasing degrees of collaboration.

Pattern 1: Transfer learned representations into hypervector space

We’ve already seen the simplest version of this idea in an earlier post . A pretrained embedding model can first map text into a semantic vector, which we then project through a fixed random matrix, producing a bipolar hypervector that can be operated on using MAP.

The separation of concerns is clean: the embedding model supplies the learned similarity structure; HDC supplies the algebra and updatable memory. Once in hypervector space, we can bind roles and values, bundle information together, encode order through permutation, or perform associative search.

Nothing about the original neural network needs to change. It’s worth noting that projection preserves the representation’s geometry only approximately³ , and whatever the source model failed to learn will be carried across with it.

Pattern 2: Pair neural features with associative memory

Here, the two stages work together inside the same classifier. A neural feature extractor, such as a convolutional neural network (CNN), learns useful visual features during its own training and can then remain fixed. HDC encodes those features and learns the task-specific classes by updating the prototype stored for each class from labeled examples.

FSL-HDnn⁴ , for example, implements this pattern for on-device few-shot learning. ImageHD⁵ applies it to continual learning: a quantized CNN supplies visual features, while HDC updates the class prototypes as new examples arrive.

The practical benefit is that the class prototypes can change without retraining the feature extractor. The system can absorb new labeled examples by updating its associative memory alone.

Pattern 3: Bring HDC into the training loop

The collaboration can be tighter still. Selected HDC components can be trained with gradients instead of remaining fixed or being updated only through prototype rules.

LeHDC⁶ showed that an HDC classifier can be expressed as an equivalent binary neural network, allowing its class hypervectors to be optimized through gradient-based learning. THDC⁷ goes further by learning both the base representations and the class representations through backpropagation.

Even the algebra can be designed with this interaction in mind. Hadamard-derived linear binding⁸ , for example, was developed as a VSA binding operation that remains efficient while working inside differentiable systems.

In this pattern, HDC is not simply downstream of a learned model. Its representations or operations participate in optimization while retaining HDC’s compositional algebra.

Taken together, these papers give us concrete integration patterns rather than a single recipe. Choices inside HDC, including binding, readout, and composition, can change computational efficiency and how easily the system integrates with a neural model.⁹ The reported results remain tied to the architectures and workloads tested, so the jury is still out on whether a hybrid would beat either component alone on real-world data.

Conclusions

The most important idea to take away from this post is that HDC and deep learning are good at different kinds of learning.

1. Use deep learning to discover useful representations. When the important structure is hidden inside raw text, images, audio, or other complex data, learned encoders are exceptionally good at finding it.
2. Use HDC when structure should remain explicit. Binding, bundling, and permutation give us direct ways to represent roles, associations, and order instead of asking a model to rediscover those relationships from data.
3. Put fast-changing knowledge in memory, not necessarily in the encoder. If new examples arrive continuously, HDC can update the prototypes stored in its associative memory from one example or a small batch without retraining the representation learner.
4. Choose the boundary appropriate to the use case. The neural model can stop at feature extraction, feed an HDC memory, or even be trained jointly with learnable hypervectors. Different tasks, data distributions, and deployment constraints will lead to different design choices.
5. Judge the whole system, not the individual component. An HDC memory may be cheap to update, but the neural encoder in front of it still has a cost. A hybrid is useful only when the complete pipeline improves something that matters: adaptation, latency, memory, energy, explainability, or accuracy.

The main decision is where learning should happen, where memory should live, and which parts of the system should remain explicit (rather than learned from data).

This is also the perspective we find most interesting at HDC Labs. Rather than replacing deep learning pipelines or embedding models with HDC, we want to ask a more fundamental systems question:

How much of an intelligent system really needs to live inside a trained model, and how much can live in a structured, updatable memory around it?

Deep learning and HDC give us different tools for answering that question. The interesting work lies in finding the right boundary between them.

Footnotes

1. Low-Rank Adaptation (LoRA) ↗ is a parameter-efficient fine-tuning method that keeps a pretrained model’s original weights frozen and learns small low-rank update matrices instead, so far fewer parameters need to be trained for a new task. ↩

2. In “Classification and Recall With Binary Hyperdimensional Computing: Tradeoffs in Choice of Density and Mapping Characteristics” ↗ , Kleyko et al. describe a class prototype as a single hypervector formed by bundling the encoded examples belonging to that class. ↩

3. Moses S. Charikar, “Similarity Estimation Techniques from Rounding Algorithms” ↗ , shows that a random hyperplane gives two vectors the same sign with probability $1 - \theta / \pi$, where $\theta$ is the angle between them. Repeating this test across many hyperplanes preserves angular similarity statistically, not exactly for every pair. ↩

4. FSL-HDnn ↗ pairs a weight-clustered CNN feature extractor with an HDC classifier in an accelerator for on-chip, gradient-free few-shot learning. Its relevance here is the split between learned visual features and lightweight HDC adaptation. ↩

5. ImageHD ↗ combines a quantized CNN front end with HDC encoding, similarity search, and bounded cluster management on an FPGA. It shows how an HDC memory can support streaming, on-device continual learning without iterative optimization. ↩

6. LeHDC ↗ maps an HDC classifier to an equivalent binary neural network and optimizes its class hypervectors against a training loss. It shows that class representations can be learned through gradients rather than constructed only through heuristic HDC updates. ↩

7. THDC ↗ replaces randomly initialized base hypervectors with trainable embeddings and also optimizes the class representations. It moves gradient-based learning into both the encoder and the associative memory. ↩

8. A Walsh Hadamard Derived Linear Vector Symbolic Architecture ↗ introduces a binding operation designed for computational efficiency, classical VSA tasks, and differentiable systems. It shows that the HDC algebra itself can be designed to work within gradient-based models. ↩

9. Practical Lessons on Vector-Symbolic Architectures in Deep Learning-Inspired Environments ↗ compares several VSA choices in deep-learning-inspired settings. The authors measured Multiply-add-permute (MAP) and Hadamard-derived linear binding (HLB) as faster than holographic reduced representations (HRR) in their implementations, tested a linear readout in place of similarity search, and used hierarchical composition to make integration more flexible. The lesson is that the internal HDC design choices matter, not that one VSA family always wins. ↩