Can hypervectors learn the hardware they run on?

Hyperdimensional Computing (HDC) is often described as robust because information is distributed across many dimensions. Damage a modest portion of a hypervector and the remaining dimensions can still carry enough evidence for a useful comparison. That graceful degradation is one reason HDC is attractive for efficient systems.

But there is a difference between losing scattered pieces of evidence and changing the geometry of the whole space. What happens when a hardware operation does not introduce a few independent errors, but instead bends similarities in the same direction every time?

In Robust Reasoning and Learning with Brain-Inspired Representations under Hardware-Induced Nonlinearities, William Youngwoo Chung, Hamza Errahmouni Barkam, Tamoghno Das, and Mohsen Imani study that question for HDC running through modeled compute-in-memory (CIM) behavior.¹ Their answer is to place the hardware response inside the training loop. Rather than expecting a fixed hypervector space to survive any transformation, they learn an encoder whose distorted geometry still supports the task.

The paper is most interesting not as a warning that HDC is fragile, but as a more precise account of robustness. A classifier may remain correct if its nearest-prototype ordering survives. A binding-based retrieval system may need unrelated hypervectors to stay separated so that unbinding can recover one relation from a bundle. Different operations ask the geometry to preserve different things.

Robust does not mean geometry-blind

Classical HDC benefits from distributed evidence. When component errors are dispersed, their effects can average out, and a wide similarity margin can preserve a decision.³ A coherent nonlinear transformation is a different failure mode.

Failure mode	What changes	What the task may lose
Random local corruption	A subset of components is independently damaged	Some distributed evidence
Systematic nonlinearity	Many representations undergo one consistent distortion	Neighborhoods, rankings, orthogonality, or inverse relations

Imagine a set of nearly orthogonal item hypervectors. Random errors may add noise around their pairwise similarities while leaving the items broadly distinguishable. A saturating response can instead push many of those similarities toward the same value. The vectors are still high-dimensional, but the hardware can no longer see the distinctions that the operation expected.

This is a conceptual 2D projection of cosine geometry, not a literal view of a high-dimensional space or a measured hardware transfer curve. Orange marks the selected query; gray marks unrelated items.

This does not contradict the holographic nature of hypervectors . Distribution gives us graceful degradation under many forms of local damage; it does not make a representation invariant to every global remapping. The useful question is not “Is HDC robust?” in the abstract. It is “Which relationship must remain reliable after the complete computation path has acted on the hypervectors?”

The geometry the hardware actually sees

The paper models the path from an input to a hardware similarity score as:

$$x \xrightarrow{\phi_\theta} \mathbf{v} \xrightarrow{f} \widetilde{\mathbf{v}} \xrightarrow{\Psi} S_{\mathrm{hw}}.$$

Here, $\phi_\theta$ is a learnable encoder that maps input $x$ into a hypervector. The function $f$ represents distortion during hardware encoding or storage, while $\Psi$ represents the hardware’s similarity operation. For two inputs, the hardware-perceived similarity becomes:

$$S_{\mathrm{hw}}(x_i,x_j) = \Psi\!\left( f(\phi_\theta(x_i)), f(\phi_\theta(x_j)) \right).$$

That equation is the paper’s central idea. Training does not optimize a representation under ideal cosine or Hamming similarity and then hand it to a device with different behavior. It evaluates the representation through the modeled device path, so the encoder can adapt to what the hardware will actually perceive.

This is an extension of a broader trend toward learnable HDC encoders.⁴ As we discussed in Where does meaning in a hypervector come from? , high dimensionality supplies a representational canvas; the encoder determines which inputs become similar, separated, or composable within it. This paper adds another constraint: those relationships should survive the intended deployment path.

Train the space, not just the decision

The authors specify a target similarity matrix $\mathbf{S}^*$ and penalize disagreement between that target and the similarities seen after modeled hardware distortion:

$$\mathcal{L}_{\mathrm{sim}} = \sum_{i,j} \left( S_{\mathrm{hw}}(x_i,x_j)-S^*_{ij} \right)^2.$$

They then describe a general objective that can combine task performance, similarity preservation, and representation regularization:

$$\mathcal{L} = \mathcal{L}_{\mathrm{task}} +\alpha\mathcal{L}_{\mathrm{sim}} +\beta\mathcal{R}.$$

The task loss rewards correct decisions. The similarity loss shapes the pairwise geometry perceived through the hardware model. The regularizer is intended to encourage useful properties such as normalization, sparsity, and avoiding saturated regions.

This is more than post-hoc calibration of an output score. The representation itself becomes a design variable. If the device consistently compresses or expands some part of the similarity range, the encoder may place items so that the transformed result, rather than the ideal intermediate vector, has the desired structure.

The paper presents this as a general framework, but it does not give enough implementation detail to reproduce the exact training procedure. The encoder architecture, optimizer, learning rate, loss weights, regularizer, and precise parameters of the modeled transformations are not specified. The conceptual contribution is clear; the recipe still needs to be made concrete.

Classification and retrieval need different geometry

The paper’s most valuable lesson appears when we compare prototype classification with binding-based retrieval. Both use similarity, but they do not need similarity to behave in exactly the same way.

For nearest-prototype classification, a query $\mathbf{q}$ is assigned to the class whose prototype $\mathbf{p}_c$ has the highest hardware-perceived score:

$$\widehat{c} = \arg\max_c S_{\mathrm{hw}}(\mathbf{q},\mathbf{p}_c).$$

Every score can be numerically wrong while the decision remains correct. What must survive is the ordering: the correct prototype should still rank first, ideally with a positive margin over the runner-up.

Relational retrieval asks for more. GrapHD binds a node hypervector to a memory of its neighbors and bundles those bound terms into a graph representation.⁵ Querying the graph uses the node hypervector to unbind the corresponding neighborhood. That works when the desired term behaves like a signal and cross-terms involving unrelated nodes behave like noise.

The paper summarizes the distorted query in a form like:

$$\mathbf{H}_i * \mathbf{G} \approx \frac{1}{2} \sum_j s_{ij}\mathbf{M}_j,$$

where $s_{ij}$ reflects similarity between node hypervectors and $\mathbf{M}_j$ represents neighborhood memories. If $s_{ii}$ is large while most $s_{ij}$ values for $i\ne j$ remain small, the intended neighborhood can stand out. If a nonlinearity pushes nearly all $s_{ij}$ values toward one, the query retrieves a mixture of many neighborhoods.

Operation	Geometry that must survive
Nearest-prototype classification	Relative score ordering and a positive class margin
Associative cleanup	Separation between the desired item and distractors
Binding and unbinding	Distinct roles and a reliable inverse or self-inverse operation
Graph reconstruction	Separation of present and absent edges after composition

This is why there is no single task-independent quantity called “HDC robustness.” A transformation can preserve enough ordering for a classifier while destroying the separation needed for unbinding. A later paper from overlapping authors makes a related distinction between correlated representations for learning and separable representations for cognitive retrieval.⁶ That 2026 work is useful subsequent context, not evidence that was available to the authors when this 2025 conference paper was published.

What the authors tested

The evaluation proceeds as a ladder from similarity shape to downstream behavior.

Experiment	Model and data	Question
Kernel approximation	20 synthetic points with 30 features	Can learning recover a target similarity pattern after modeled distortion?
Classification	QuantHD on ISOLET and Fashion-MNIST, $D=512$	Can prototype decisions recover under exponential, logarithmic, and tanh maps?
Graph reconstruction	GrapHD on one random 20-node, 10-edge graph	Can the separation needed for unbinding and edge recovery be restored?
Node classification	RelHD on Cora, $D\in\{512,1024,2048\}$	Does an optimized relational representation recover downstream accuracy?

The authors report implementing the experiments in PyTorch, repeating them ten times, and plotting mean results. These are software experiments with mathematical exponential, logarithmic, and hyperbolic-tangent transformations. They are not measurements from a fabricated CIM device, a circuit simulator, or a transfer function calibrated from physical hardware.

That scope is still useful. The experiments test whether joint optimization can respond to controlled geometry distortions across several HDC operations. They should be read as demonstrations of a co-design principle, not as four independent validations across CIM platforms.

The strongest reported results

The kernel experiment makes the optimization objective visible. With nonlinear search alone, the unadapted hardware kernel becomes too narrow. Optimizing the similarity operation partially restores the desired radial-basis-function pattern, while joint adaptation of encoding and similarity better recovers its broader structure. When the modeled distortion affects both encoding and search, the jointly optimized version most clearly recovers the target diagonal pattern. The evidence here is visual; the paper does not report a numerical kernel-error table.

The QuantHD experiment tests whether this geometric recovery helps prototype classification. Under tanh distortion at both encoding and search, the authors report the following values:

Dataset	Unadapted QuantHD	Optimized QuantHD	Normal QuantHD shown in figure
ISOLET	About 37%	84%	About 90%
Fashion-MNIST	36%	73%	About 75%

On ISOLET, that is a recovery of roughly 47 percentage points, depending on how the plotted unadapted bar is read. On Fashion-MNIST, it is 37 percentage points. The result does not make specialized hardware necessary for QuantHD; normal QuantHD is the high reference bar in the authors’ own figure. It shows that if QuantHD is deliberately mapped onto the modeled non-ideal path, adapting the representation can recover much of the lost accuracy.

GrapHD provides the clearest mechanism example. In normal operation, node similarities occupy a useful range. Under the modeled nonlinearity, they collapse into a narrow spike near one. The resulting reconstruction connects almost every node to every other node. After optimization, the similarity distribution again resembles the normal case and the target 10-edge graph is visually recovered.

This is a small synthetic test involving one random 20-node graph. It is not evidence that graph reasoning has been solved under arbitrary hardware behavior. Its value is explanatory. It shows exactly how a systematic change in pairwise similarity can turn cross-terms from noise into coherent interference.

Finally, the RelHD experiment brings the idea back to a downstream graph task. On Cora under the modeled nonlinear condition, optimized RelHD reports 67% accuracy at $D=512$ and 70% at $D=2048$. The three tested optimized dimensions differ only modestly in the plotted results. Those direct values are more informative than the paper’s broader summaries of percentage quality loss or its abstract’s improvement multiplier, whose derivations are not fully tabulated.

What the evidence establishes

Taken together, the experiments support a favorable but bounded conclusion: a learnable encoder can be optimized against a differentiable distortion model, and the authors report substantial recovery over unadapted QuantHD, GrapHD, and RelHD under the tested transformations. GrapHD makes the failure mechanism especially clear, while QuantHD shows that decision ordering can remain partly useful even under severe score distortion.

The paper also extends a real hardware and algorithm co-design lineage. Prior HDC work has implemented in-memory operations, modeled device nonidealities, and used hardware-aware retraining.^{7 8 9} The distinctive move here is to make the hardware-perceived similarity geometry an explicit shared objective across classification and relational examples.

Several questions remain open:

• Physical validation: No measured CIM device behavior is evaluated.
• Transfer: The experiments do not test unseen devices, temperatures, aging states, or array-to-array variation.
• Uncertainty: Ten-run means are reported without standard deviations, confidence intervals, or hypothesis tests.
• Reproducibility: No code is linked, and important architecture, training, and distortion parameters are missing.
• Algebra: The exposition moves among complex FHRR, bipolar self-binding, binary QuantHD, and a real-valued learnable encoder without fully specifying the representation and inverse operation used in each experiment.
• Efficiency: The speed and energy figures in the paper’s introductory comparison table come from prior systems on different hardware and baselines; they are not measurements of this framework.

These limits do not negate the idea. They tell us what kind of claim the current evidence supports: a promising optimization principle demonstrated in software, rather than a deployment-ready hardware result or a universal solution for every HDC algebra.

The HDC Labs perspective

For most HDC experiments and proof-of-concept systems, we would begin with the ordinary software path. It is simpler, accessible, and sufficient for learning whether an encoder, memory, classifier, or relational operation solves the problem. Hardware-aware training becomes relevant only after a deployment choice introduces a stable and consequential distortion.

Within that narrower setting, the paper points to five useful design principles.

First, geometry is a design surface. The encoder determines where inputs land, and the hardware response determines how those positions are perceived. Co-design means shaping both as one system.

Second, robustness needs an invariant. A classifier needs the same winner. A retrieval system may need the same top neighborhood, the same signal/noise separation, or the same unbinding result. Reporting only component error or final accuracy can hide the mechanism.

Third, the device can become part of the representation. If its response is stable enough to model, software may not need to force it to reproduce ideal arithmetic exactly. The learned coordinates can anticipate the transformation. This could reduce the burden of digital correction, although the paper does not measure that trade-off.

Fourth, specialization creates a portability question. A representation carefully adapted to one transfer curve may become less reliable on another array or at another temperature. The paper mentions sampling ensembles of hardware or noise conditions, but does not evaluate whether that produces a representation robust across a family of devices.

Fifth, HDC makes the trade-off unusually inspectable. Binding, bundling, similarity, cleanup, and prototype decisions are explicit operations. We can ask whether a failure came from collapsed similarities, weakened orthogonality, bundle interference, or an unreliable inverse. That makes HDC a useful laboratory for hardware and algorithm co-design. It does not make HDC a framework that depends on special hardware to be useful.

Experiments we would run next

The next study should connect the clean mathematical idea to measured behavior.

1. Calibrate the hardware model. Fit $f$ and $\Psi$ to measured FeFET, PCM, or RRAM transfer curves and array-level variation.
2. Hold out hardware conditions. Train across some devices, temperatures, noise levels, and aging states, then test on unseen conditions.
3. Separate the failure sources. Apply distortion independently during encoding, storage, binding, bundling, and similarity search.
4. Measure geometry directly. Track prototype margin, pairwise rank correlation, orthogonality, signal/noise overlap, and unbinding error alongside task accuracy.
5. Compare adaptation strategies. Evaluate fixed HDC, search-only calibration, encoder-only adaptation, joint adaptation, and conventional digital correction.
6. Scale the relational test. Sweep graph size, degree, bundled-relation count, and dimensionality instead of relying on one 20-node graph.
7. Test software baselines first. Establish the useful accuracy and latency available on ordinary CPU and GPU implementations before attributing value to specialized hardware.
8. Publish uncertainty and artifacts. Release per-run results, seeds, measured hardware models, encoder definitions, and ablations.
9. Measure the cost of adaptation. Report training overhead, inference latency, memory, energy, and digital support required by the learned encoder.

The most informative result would be a phase diagram with three regions: where ordinary unadapted HDC is already sufficient, where hardware-aware geometry recovers the task on a chosen device, and where the distortion destroys too much information for adaptation to compensate.

Closing position

This paper moves the HDC hardware discussion beyond generic noise tolerance. Its central idea is that a hypervector space need not passively endure a known device response; the encoder can be trained so the post-distortion geometry still preserves the ordering or separation the operation needs.

That is an option for deployment co-design, not an entry requirement for HDC. Researchers can continue to build meaningful HDC experiments, proof-of-concept systems, and applications on ordinary computers. If a later deployment calls for non-ideal compute-in-memory hardware, this paper offers a promising way for the representation and the device to meet each other halfway.

The authors demonstrate that possibility in software under modeled nonlinearities. The next step is to show that the learned geometry remains useful on a real device whose behavior changes across time and conditions.

Footnotes

1. William Youngwoo Chung, Hamza Errahmouni Barkam, Tamoghno Das, and Mohsen Imani, “Robust Reasoning and Learning with Brain-Inspired Representations under Hardware-Induced Nonlinearities” ↗ , Proceedings of the Great Lakes Symposium on VLSI (2025). Open arXiv version ↗ . ↩

2. Mike Heddes et al., “TorchHD: An Open Source Python Library to Support Research on Hyperdimensional Computing and Vector Symbolic Architectures” ↗ , Journal of Machine Learning Research 24, no. 255 (2023): 1-10. ↩

3. Pentti Kanerva, “Hyperdimensional Computing: An Introduction to Computing in Distributed Representation with High-Dimensional Random Vectors” ↗ , Cognitive Computation 1 (2009): 139-159. ↩

4. Alejandro Hernández-Cano et al., “FLASH: A Fast, Learnable, Adaptive and Structured Hyperdimensional Encoding Approach for Emerging Applications” ↗ , Frontiers in Artificial Intelligence 7 (2024). ↩

5. Atin S. Poduval et al., “GrapHD: Graph-Based Hyperdimensional Memorization for Brain-Like Cognitive Learning” ↗ , Frontiers in Neuroscience 16 (2022). ↩

6. Atin S. Poduval et al., “Optimal Hyperdimensional Representation for Learning and Cognitive Computation” ↗ , Frontiers in Artificial Intelligence 9 (2026). ↩

7. Geethan Karunaratne et al., “In-Memory Hyperdimensional Computing” ↗ , Nature Electronics 3 (2020): 327-337. ↩

8. Guohao Huang et al., “FeFET-Based In-Memory Hyperdimensional Encoding Design” ↗ , IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (2023). ↩

9. Ali Kazemi et al., “MIMHD: Accurate and Efficient Hyperdimensional Inference Using Multi-Bit In-Memory Computing” ↗ (2021 preprint). ↩