Encoding Robust Topological Signatures for Hyperdimensional Computing

This paper proposes a robust hyperdimensional computing framework that encodes rotation, translation, and scale-invariant topological primitives—specifically outer shapes and holes—into hypervectors, demonstrating significantly improved resilience to pixel-level corruptions compared to standard pixel-based encoders and compact CNNs while maintaining competitive clean accuracy.

The Gist

Imagine you are trying to teach a computer to recognize handwritten numbers, like the digits on a piece of paper. Usually, computers do this by looking at every single pixel (the tiny dots that make up the image) and memorizing exactly what the ink looks like.

The paper argues that this "pixel-by-pixel" approach is like trying to recognize a friend by the exact pattern of freckles on their face. If that friend puts on a hat, gets a tan, or stands in a different light, the computer gets confused and fails. It's too fragile.

The authors propose a new way to teach the computer, called Hyperdimensional Computing (HDC). Instead of looking at the pixels, they teach the computer to look at the shape's skeleton and its holes.

Here is how their method works, broken down into simple concepts:

1. The "Shape Detective" vs. The "Pixel Photographer"

Think of a standard computer vision model as a Pixel Photographer. It takes a snapshot of every dot. If you rotate the photo or add some static (noise) to the image, the pattern of dots changes completely, and the photographer gets lost.

The authors' method acts like a Shape Detective. Instead of counting dots, the detective asks two simple questions:

• What is the outline? (The big shape of the number).
• Where are the holes? (The empty spaces inside the shape, like the hole in the middle of an "8" or the top of a "6").

In math terms, these "holes" are called topological primitives. The cool thing about holes is that they are stubborn. If you stretch, rotate, or shrink a rubber band shaped like an "8," it still has two holes. The number of holes doesn't change just because the shape got wobbly.

2. Building the "ID Card"

To make this work, the computer builds a special "ID card" (a hypervector) for every image. It does this in three steps:

• Step A: The Outer Frame (The Silhouette):
  The computer looks at the main outline of the number. To make sure it recognizes the number whether it's tilted or zoomed in, it uses a mathematical tool called Zernike moments.

  • Analogy: Imagine taking a photo of a building. If you rotate the camera, the building looks different. But if you describe the building by its "mass distribution" (how heavy the walls are on the left vs. the right) rather than the exact angle of the roof, you can still recognize it even if the camera spins. This step creates a description of the outer shape that stays the same even if you rotate or resize the image.

• Step B: The Inner Holes (The Topology):
  The computer finds the holes inside the number. It measures the shape of the hole and where it sits relative to the outside edge.

  • Analogy: Think of a donut. Whether the donut is big, small, or tilted, it always has one hole in the middle. The computer learns to say, "Ah, this shape has a hole in the center," regardless of how messy the edges of the donut are.

• Step C: The "Trust Score" (Reliability Weights):
  Sometimes the image is so dirty (noisy) that the computer can't see the outline well, but it can still see the holes. Other times, the outline is clear, but the holes are blurry.
  The system learns to assign a "trust score" to each clue. If the image is noisy, it trusts the hole count more. If the image is clear, it trusts the outline more. It combines these clues into one final answer.

3. Why This Matters: The "Noise" Test

The authors tested their "Shape Detective" against the standard "Pixel Photographer" and a modern Deep Learning model (a Compact CNN) using the MNIST dataset (handwritten numbers).

They didn't just test on clean images; they threw "corruptions" at the computer:

• Gaussian Noise: Like adding TV static to the image.
• Salt-and-Pepper: Like sprinkling black and white specks on the paper.
• Zooming: Making the number huge or tiny.
• Cutouts: Covering part of the number with a black square.

The Results:

• The Pixel Photographer (Naive HDC): When they added noise or rotated the numbers, its accuracy crashed. It went from being 95% accurate on clean images to less than 10% accurate on noisy ones. It was like a person who only recognizes a friend by their exact freckle pattern; if the freckles are covered by a hat, they don't know who it is.
• The Deep Learning Model (CNN): It was great at recognizing clean numbers (99% accuracy), but when noise was added, it also collapsed, dropping to near-random guessing (around 11%).
• The Shape Detective (Topology-guided HDC): It stayed strong. Even with heavy noise or rotation, it maintained high accuracy (around 70–88%). It didn't need to be retrained to handle the noise; its method of looking at "holes and outlines" was naturally resistant to the mess.

The Bottom Line

The paper claims that by explicitly teaching the computer to look at topological features (like holes and the overall shape) rather than just raw pixels, we can build AI that is much tougher and more reliable.

It's the difference between trying to memorize a specific photograph of a face versus memorizing the fact that "this person has two eyes and a nose." If you take a photo of them in the dark or from a weird angle, the photo changes, but the fact that they have two eyes and a nose remains true. This approach makes the computer robust against the "noise" of the real world.

Technical Summary

Technical Summary: Encoding Robust Topological Signatures for Hyperdimensional Computing

Problem Statement
Hyperdimensional (HD) computing offers a resource-efficient alternative to deep neural networks for edge learning, characterized by fast prototype-based inference and compatibility with online updates. However, standard HD encoders, which rely on naive pixel-based representations (binding position and intensity vectors), exhibit significant brittleness. As demonstrated in the paper's introduction, small distribution shifts—such as rotation, Gaussian noise, salt-and-pepper noise, or zooming—can cause catastrophic accuracy drops (e.g., from 95% to 9% on MNIST with Gaussian noise). While deep learning systems have largely traded efficiency for depth, they remain fragile to structured perturbations. The core problem addressed is the lack of explicit topological encoding in HD frameworks, which limits their robustness against corruptions that disrupt local pixel statistics while preserving global shape structure.

Methodology
The authors propose a "Topology-guided HD" framework that explicitly extracts discrete topological primitives from binarized shapes and encodes them into high-dimensional hypervectors. The methodology proceeds through the following stages:

1. Primitive Extraction: The image is processed to identify a multiset of primitives: the outer contour (global shape) and internal holes (topological features).
2. RTS-Invariant Descriptors:
   • Outer Shape: The outer contour is normalized using a Rotation, Translation, and Scale (RTS) canonical frame derived from the principal axis and centroid of the shape. The shape is then described using a Spatial Pyramid Zernike Moment descriptor. This combines global mass distribution (via Zernike magnitudes for rotation invariance) with local spatial layout (via a grid decomposition) to capture both global geometry and coarse structural details. A Histogram of Oriented Gradients (HOG) is also included to capture local edge structures often missed by global moments.
   • Holes: For each detected hole, the method computes:
     • Relative Geometry: The hole's centroid is mapped to RTS-canonical coordinates relative to the outer shape's frame.
     • Intrinsic Shape: The hole's boundary is resampled and parameterized. A radial signature is computed, and its Fourier magnitudes (excluding the DC component) are used as a rotation-invariant shape descriptor.
3. HD Encoding:
   • Each primitive is mapped to a bipolar hypervector ($\{-1, +1\}^D$) via randomized projection and role binding (using type-specific role vectors).
   • Variable-cardinality sets of holes are aggregated using permutation-invariant bundling (element-wise summation followed by sign thresholding) to form a single image hypervector.
4. Reliability Weighting: To prevent over-weighting unreliable cues, the system learns non-negative reliability weights ($\alpha, \beta$) for the Zernike and hole channels relative to the HOG channel. These weights are optimized on a validation set by fusing cosine similarity scores from the separate feature channels.
5. Classification: Classification is performed via prototype learning, where class prototypes are accumulated from training data and updated online.

Key Contributions

• Explicit Topological Encoding: The paper introduces the first explicit integration of discrete topological primitives (specifically holes and their relative geometry) into the HD computing paradigm.
• RTS-Stable Descriptors: It constructs descriptors that are mathematically invariant to rotation, translation, and scale by construction, utilizing Zernike moments for global shape and Fourier descriptors for hole shapes.
• Robustness via Topology: The work demonstrates that topological features (hole count, connectivity, relative placement) provide complementary information to pixel-based features, particularly when local appearance is corrupted.
• Lightweight Online Learning: The framework maintains the core HD advantage of lightweight online training, allowing prototypes to adapt without retraining from scratch.

Results
Experiments were conducted on MNIST and EMNIST datasets under controlled corruptions (rotation, Gaussian noise, salt-and-pepper, cutout, and zoom).

• Vs. Naive HD: The Topology-guided HD significantly outperforms the naive pixel-based HD baseline across all corruption types. For instance, under Gaussian noise ($\sigma=0.1$), naive HD accuracy drops to ~7%, while the proposed method maintains ~83% (before online training) and ~89% (after training).
• Vs. Compact CNN: When compared to a compact CNN trained on clean data:
  • Clean Data: The CNN achieves higher accuracy on clean datasets (e.g., 99.1% on MNIST vs. 97.68% for Topology-guided HD).
  • Corrupted Data: The Topology-guided HD demonstrates markedly superior robustness. Under Gaussian noise ($\sigma=0.1$), the CNN collapses to near-chance performance (~11%), whereas the Topology-guided HD retains ~89% accuracy. Similar trends are observed for salt-and-pepper noise and cutout occlusions.
  • EMNIST: On the more complex EMNIST letters dataset, the Topology-guided HD substantially outperforms the CNN under noise conditions (e.g., 57.7% vs. 3.84% under Gaussian noise before training).

Significance and Claims
The paper claims that explicit topological structure is a practical route to achieving robust HD representations. The significance lies in demonstrating that HD computing can achieve competitive clean-data accuracy while offering "markedly stronger robustness" to pixel-level corruptions compared to deep learning models, without requiring corruption-specific data augmentation. The authors argue that by leveraging invariance properties inherent to topology (homeomorphism), the system can maintain class separability even when local pixel statistics are severely degraded.

Limitations
The authors acknowledge that the method relies on the stability of the initial binarization and primitive extraction steps. Severe noise or low contrast can lead to fragmented boundaries or spurious holes, which negatively impacts downstream accuracy. Furthermore, the theoretical guarantees cover similarity transforms (RTS) but do not extend to non-rigid deformations, perspective effects, or heavy domain shifts involving background clutter. The preprocessing stage (segmentation and contour extraction) is also noted as a potential computational bottleneck depending on implementation.