💻 computer science

HiProto: Hierarchical Prototype Learning for Interpretable Object Detection Under Low-quality Conditions

The paper proposes HiProto, a hierarchical prototype learning framework that enhances interpretable object detection under low-quality imaging conditions by introducing specialized contrastive and regularization losses alongside a scale-aware pseudo-label strategy to improve semantic discrimination without relying on image enhancement or complex architectures.

Original authors: Jianlin Xiang, Linhui Dai, Xue Yang, Chaolei Yang, Yanshan Li

Published 2026-04-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jianlin Xiang, Linhui Dai, Xue Yang, Chaolei Yang, Yanshan Li

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to spot a friend in a crowded, foggy park at night. It's hard, right? The lights are dim, the air is thick with mist, and your eyes might play tricks on you. Now, imagine you are a computer program trying to do the same thing. This is the problem the paper HiProto is trying to solve.

Here is the story of how they fixed it, explained without the heavy math jargon.

The Problem: The "Black Box" Detective

Most computer vision systems today are like super-smart but secretive detectives. They are great at finding things (like cars or people) even in bad weather, but they work like a "black box." You give them a blurry photo, and they say, "I found a car!" But if you ask, "How did you know that was a car and not a weirdly shaped bush?" they can't really explain themselves. They just crunch numbers and give an answer.

Also, many current solutions try to fix the problem by first "cleaning up" the photo (like using Photoshop to brighten a dark image) before looking for objects. But this is like trying to clean a muddy window before looking out; sometimes you just make the window dirtier or distort the view.

The Solution: HiProto (The "Template" Detective)

The authors of this paper, HiProto, decided to change the game. Instead of trying to clean the photo or build a super-complex machine, they gave the computer a set of mental templates (called "prototypes").

Think of it like this:

Old Way: The computer looks at a blurry shape and guesses, "Hmm, that looks 60% like a car."
HiProto Way: The computer has a mental library of what a "Car" looks like at different sizes. It holds up a "Small Car" template against the small blurry shape, and a "Big Car" template against the big blurry shape. If the shape matches the template, it says, "Yes, that's a car!"

This is Interpretable because you can literally see which template the computer matched. It's like showing your work in math class instead of just writing down the answer.

How It Works: The Three Magic Tools

To make this work in bad conditions (darkness, fog, rain), HiProto uses three special tools:

1. The "Spotlight" (RPC-Loss)

Imagine you are looking for a specific type of bird in a forest. You don't want to look at the trees or the sky; you only want to look where the bird could be.
HiProto uses a tool called RPC-Loss to act like a spotlight. It forces the computer to focus its "templates" only on the areas where the object actually is, ignoring the background noise. It teaches the computer: "Don't waste energy matching a car template to a patch of fog; only match it to the actual car."

2. The "Identity Cards" (PR-Loss)

Sometimes, a "Cat" template might look too much like a "Dog" template, causing confusion.
HiProto uses PR-Loss to make sure every template has a unique "Identity Card." It forces the "Car" template to be very different from the "Bicycle" template. This prevents the computer from getting confused when things look blurry. It ensures that the mental library is organized and distinct.

3. The "Size Filter" (SPLGS)

This is the cleverest part. In a photo, a tiny car in the distance looks very different from a giant car right in front of you.

The Problem: If you try to use a "Giant Car" template to find a "Tiny Car" in the distance, it won't match well.
The Fix: HiProto uses a Scale-aware Pseudo Label Generation Strategy (SPLGS). Think of this as a smart filter that says: "Okay, this layer of the brain is for small objects, so only look for small cars here. That other layer is for big objects, so look for big cars there."
This stops the computer from getting confused by trying to use the wrong size template for the wrong job.

Why Is This Better?

The paper tested HiProto on three difficult scenarios:

ExDark: Very dark, low-light images.
RTTS: Real-world foggy scenes.
VOC2012-FOG: Artificially foggy images.

The Results:

It sees better: HiProto found more objects and missed fewer than the other methods, even without "cleaning" the images first.
It explains itself: Because it uses templates, we can see exactly what the computer is "thinking." If it finds a car, we can see the "Car Template" lighting up on the screen.
It's fast: It doesn't need a super-complex brain to do this; it's efficient and runs quickly.

The Big Picture Analogy

Imagine you are teaching a child to recognize animals in a dark forest.

The Old Way: You give the child a flashlight (Image Enhancement) to make the forest bright, but the flashlight might scare the animals or distort their shapes.
The HiProto Way: You give the child a set of clear, distinct flashcards (Prototypes) for a Lion, a Bear, and a Deer. You tell them, "If you see something that looks like the Lion card, it's a Lion. If it looks like the Bear card, it's a Bear." Even if it's dark and foggy, the child can still match the shape to the card. And if you ask, "Why did you say that's a Lion?" the child can point to the card and say, "Because it matches this one!"

In short: HiProto makes object detection smarter, faster, and much easier to understand by teaching computers to match shapes to clear mental templates, rather than just guessing in the dark.

1. Problem Statement

Object detection systems face significant challenges under low-quality imaging conditions (e.g., low light, haze, fog). These conditions degrade visual information, increase prediction uncertainty, and compromise reliability, particularly in safety-critical applications like autonomous driving.

Existing approaches generally fall into two categories, both of which have limitations:

Image Enhancement Approaches: Two-stage pipelines that first enhance image quality (e.g., brightness adjustment, dehazing) before detection. These often distort semantic cues due to a focus on pixel-level appearance and lack interpretability.
Complex Architectures: End-to-end models designed specifically for low-quality inputs. While effective, these often rely on complex structures that act as "black boxes," failing to provide clear interpretability or robust semantic discrimination.

The core challenge is to develop a detection method that is robust to degradation, interpretable (transparent decision-making), and does not rely on image enhancement or overly complex architectures.

2. Methodology: HiProto

The authors propose HiProto, a new paradigm for interpretable object detection based on Hierarchical Prototype Learning. The method integrates prototype learning into standard Feature Pyramid Network (FPN) architectures to create structured, scale-aware semantic representations.

A. Core Architecture

HiProto operates as an end-to-end detector without a separate image enhancement subnetwork. It embeds class-specific prototypes into each feature layer of the FPN.

Hierarchical Modeling: Each feature level ( $l$ ) learns prototypes ( $P^l$ ) corresponding to specific object scales. This allows the model to associate features with class-centered semantics at the appropriate resolution.
Regression Branch: Uses a scale-aware regression range ( $R^l$ ) to reduce cross-scale ambiguity, ensuring different feature levels focus on objects of suitable sizes.

B. Key Components

The method introduces three novel mechanisms to optimize prototype learning:

Region-to-Prototype Contrastive Loss (RPC-Loss):
- Goal: Enhance the semantic focus of prototypes on target regions.
- Mechanism: It generates a class similarity map by matching region features with prototype vectors. It uses a binary cross-entropy loss to supervise the model, forcing features to align with their corresponding class prototypes.
- Scale-aware Pseudo Label Generation Strategy (SPLGS): To prevent noise in low-level features (which have small receptive fields and cannot capture large objects), SPLGS filters bounding boxes. It only generates pseudo-labels for objects that fit within the valid perception range of the specific feature layer, ensuring supervision consistency.
Prototype Regularization Loss (PR-Loss):
- Goal: Improve distinctiveness among class prototypes to prevent semantic entanglement.
- Mechanism: Instead of simple pairwise constraints, HiProto uses Singular Value Decomposition (SVD) to enforce orthogonality on the prototype matrix globally. It regularizes the singular values to be close to 1, promoting a well-conditioned, disentangled feature space.
Interpretability Metrics:
The paper defines specific metrics to quantify interpretability:
- Discriminability Score: Measures how well prototype activation energy concentrates within ground-truth object regions.
- Sparsity Score: Quantifies the independence (low redundancy) between different class prototypes.
- AUCft: Evaluates the separability between foreground and background activations.

3. Key Contributions

New Paradigm: Proposes HiProto, the first hierarchical prototype learning framework specifically designed for interpretable object detection under low-quality conditions, eliminating the need for image enhancement pipelines.
Prototype-Driven Optimization: Introduces a dual-loss system (RPC-Loss and PR-Loss) that optimizes feature focus and prototype distinctiveness simultaneously.
Scale-Aware Supervision: Develops SPLGS to filter supervision signals based on feature layer receptive fields, preserving the robustness of low-level representations.
Comprehensive Evaluation: Provides extensive quantitative and qualitative evidence demonstrating that HiProto improves both detection accuracy and interpretability without increasing computational complexity significantly.

4. Experimental Results

The method was evaluated on three benchmark datasets: ExDark (low light), RTTS (haze), and VOC2012-FOG (synthetic haze).

Detection Accuracy:
- ExDark: HiProto achieved 69.1% mAP, outperforming the baseline (YOLOv8) by 4.7% and the second-best method (Retinexformer) by 2.3%.
- RTTS: Achieved 76.0% mAP, surpassing the baseline by 1.6% and the best competitor (DNMGDT) by 1.4%.
- VOC2012-FOG: Achieved 63.7% mAP, improving over the baseline by 4.8% and MASFNet by 4.5%.
- Normal Conditions: Also achieved state-of-the-art results on standard VOC2012, proving generalizability.
Interpretability:
- HiProto consistently achieved the highest Discriminability Score, Sparsity Score, and AUCft across all datasets.
- Visualizations showed that HiProto produces compact, spatially coherent saliency maps aligned with ground truth, whereas competitors exhibited scattered or noisy activations.
Efficiency:
- HiProto maintained high inference speed (137.23 FPS) and low computational cost (21.266 FLOPs), comparable to or better than the baseline YOLOv8, confirming that the hierarchical prototype mechanism adds negligible overhead.

5. Significance

HiProto addresses a critical gap in computer vision by demonstrating that interpretability and robustness in low-quality conditions do not require complex image restoration or opaque deep architectures. By leveraging hierarchical prototype learning, the model:

Provides transparent decision-making where predictions can be traced back to specific prototype responses.
Enhances semantic discrimination by structuring features across scales, making it resilient to degradation.
Offers a lightweight, end-to-end solution that is practical for real-world deployment in safety-critical systems (e.g., autonomous driving in fog or night).

The work suggests that structured semantic modeling is a more effective strategy for low-quality detection than traditional pixel-level enhancement or architectural complexity.