💻 computer science

Reliability-aware Gradient Decoupling for Partial Label Learning

The paper proposes RGD-PLL, a reliability-aware gradient decoupling framework that enhances partial label learning by estimating instance-dependent candidate reliability, suppressing uncertain supervision via entropy weighting, and removing conflicting gradient components through asymmetric projection to improve optimization stability and robustness.

Original authors: Zhonghe Wei, Jihang Yin, Fengzhi Zhang, Yan Yan

Published 2026-08-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zhonghe Wei, Jihang Yin, Fengzhi Zhang, Yan Yan

Original paper licensed under CC BY 4.0 (https://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

In the world of artificial intelligence, computers are remarkably good at recognizing patterns, but they are notoriously dependent on perfect instructions. To teach a machine to distinguish a cat from a dog, or a car from a truck, researchers typically need vast libraries of images where every single picture has been meticulously labeled by a human expert. This process is slow, expensive, and often subjective, especially when the differences between objects are subtle. To solve this, scientists developed a method called partial-label learning. Instead of demanding a single, definitive answer for every image, this approach allows the computer to learn from a list of possible candidates. For instance, an image of a bird might come with a list of potential labels like "sparrow," "finch," or "eagle," with the computer's job being to figure out which one is actually correct while ignoring the others. It is a way to train powerful systems using data that is easier and cheaper to collect, mimicking how humans often learn from hints rather than absolute facts.

However, a significant hurdle remains in this process. When a computer is presented with a list of possible labels, not all of them are equally trustworthy. Some candidates are obvious guesses, while others are highly probable. If the computer treats every option on the list with the same level of importance, it can become confused, learning from the wrong clues and reinforcing its own mistakes. This is particularly problematic because the computer must simultaneously learn to recognize the object and learn which label in the list is the right one. These two tasks often pull the computer's learning engine in different directions, creating a conflict where trying to improve one skill actually harms the other.

To address this delicate balance, researchers Zhonghe Wei, Jihang Yin, Fengzhi Zhang, and Yan Yan have proposed a new framework called RGD-PLL. Their work focuses on a specific insight: the computer should not just look for the right label, but also constantly evaluate how reliable each candidate label is for that specific image. They realized that the process of estimating reliability and the process of learning to recognize objects should not simply be mashed together. Instead, they designed a system that separates these two learning streams, allowing them to cooperate without stepping on each other's toes. The core of their method involves a "teacher" model that provides stable, consistent guidance, and a "student" model that learns from it. The teacher looks at a slightly altered version of an image and suggests a target label, while the student looks at a more heavily altered version and tries to match that suggestion. Crucially, the system calculates a confidence score for every candidate label. If the teacher is unsure, the system knows to be cautious; if the teacher is confident, the system pays closer attention.

The researchers discovered that simply using these confidence scores to pick a label was not enough. The real breakthrough came in how they handled the mathematical updates that drive the learning process. When the computer tries to learn from a reliable label, it adjusts its internal settings in a specific direction. When it tries to learn from an unreliable one, it might want to adjust in the opposite direction. The team developed a technique to detect when these two desires conflict. Instead of forcing the computer to compromise or averaging the two directions, their method carefully removes only the part of the reliability signal that fights against the main learning goal. It is like a navigator who, upon receiving a conflicting instruction from a passenger, ignores the part of the instruction that would drive the car off a cliff but keeps the part that helps steer the car toward the destination. This ensures that the primary task of recognizing the image remains the top priority, while the secondary task of figuring out the correct label provides helpful, non-interfering guidance.

To test their idea, the team ran extensive experiments on several standard datasets used to benchmark artificial intelligence, including collections of everyday objects, street numbers, and clothing items. They tested their method under two different conditions: one where the candidate labels were generated based on the specific features of each image, and another where they were chosen more randomly. In every scenario, their new framework outperformed existing methods. On a dataset of 100 different classes, their approach achieved a test accuracy of 79.04 percent, surpassing the previous best results. The improvements were consistent across different types of images and levels of difficulty. The researchers also ran a series of checks to see which parts of their system were most important. They found that removing any single component, such as the confidence weighting or the conflict-removal technique, caused the performance to drop. This confirmed that the different parts of their system worked together to create a robust solution.

The study also looked at the cost of running this new system. While it requires a bit more computing power during the training phase—roughly 1.68 times the time of a standard method and nearly double the memory usage—this overhead disappears once the training is complete. The final model used for making predictions is no larger or more complex than a standard model. This means that the extra effort is only a temporary investment during the learning phase, with no lasting burden on the system's speed or size when it is actually being used. The researchers suggest that their approach offers a reliable way to train powerful AI systems using imperfect data, a common reality in the real world where perfect labels are rare. By teaching the computer to be aware of its own uncertainty and to manage conflicting signals carefully, they have created a more stable and effective way for machines to learn from the messy, ambiguous information that surrounds us.

Technical Summary: Reliability-aware Gradient Decoupling for Partial Label Learning

1. Problem Definition

Partial-label learning (PLL) addresses the challenge of training deep neural networks when each instance is associated with a set of candidate labels, only one of which is the ground truth. While existing methods have improved label disambiguation through representation learning, contrastive learning, and candidate refinement, they primarily treat candidate reliability as a mechanism to modify supervision signals (e.g., selecting pseudo-labels or refining candidate sets).

A critical gap remains in understanding how candidate reliability affects the optimization of shared representations. In PLL, prediction learning (identifying the correct label) and reliability estimation (assessing candidate credibility) often share a feature encoder. When estimated reliability is inaccurate, the resulting optimization signal can conflict with the prediction gradient. Furthermore, even compatible auxiliary gradients can dominate the shared update if their magnitude is excessive. Existing gradient conflict mitigation strategies (e.g., PCGrad, GradNorm) are designed for general multi-objective settings and do not explicitly account for the asymmetric nature of PLL, where prediction is the primary objective and reliability estimation is a variable-trust auxiliary task.

2. Methodology: RGD-PLL

The authors propose RGD-PLL (Reliability-aware Gradient Decoupling for Partial Label Learning), a framework designed to regulate shared parameter optimization based on instance-dependent candidate reliability. The framework consists of three core components:

2.1 Instance-Dependent Candidate Reliability Estimation

RGD-PLL models sample–label interactions to estimate a reliability distribution $q_i$ over the candidate set for each instance.

Architecture: A student network processes strongly augmented views to produce predictions and reliability estimates. A momentum teacher (updated via exponential moving average) processes weakly augmented views to generate stable, candidate-constrained targets ( $\pi_i$ ).
Reliability Weighting: The uncertainty of the teacher target is measured via candidate-constrained entropy ( $H_i$ ). This entropy determines a sample-level reliability coefficient ( $\alpha_i$ ), where lower entropy (higher confidence) yields a higher weight.
Soft Supervision: The learned reliability distribution guides label disambiguation through a soft supervision loss ( $L_{soft}$ ), weighted by $\alpha_i$ and a progressive schedule.

2.2 Asymmetric Gradient Decoupling

To address optimization interference on the shared encoder, RGD-PLL employs an asymmetric strategy rather than symmetric modification of both gradients.

Conflict Removal: If the reliability gradient ( $g_r$ ) conflicts with the prediction gradient ( $g_p$ ) (i.e., negative inner product), the component of $g_r$ opposing $g_p$ is projected out. The remaining compatible information is retained.
Norm Balancing: To prevent large, non-conflicting reliability gradients from dominating the update, a norm-balancing coefficient ( $\gamma_t$ ) scales the auxiliary update based on the ratio of the prediction gradient norm to the decoupled reliability gradient norm.
Asymmetric Scaling: The final shared gradient is computed as $g_\theta = g_p + \beta_t g_r^{dec}$ , where $\beta_t$ is controlled by a scheduled coefficient, batch reliability, and the norm-balancing factor. This ensures the update direction remains a descent direction for the primary prediction objective.

2.3 Progressive Optimization Schedule

The framework utilizes a progressive schedule to activate reliability-guided supervision and gradient regulation only after a warm-up period ( $T_w$ ). This prevents the propagation of unstable early predictions and allows the model to establish a baseline representation before introducing complex reliability constraints.

3. Key Contributions

The paper outlines three primary contributions:

Instance-Dependent Reliability Estimator: A novel estimator based on sample–label interactions that constructs reliable soft supervision using momentum-stabilized targets and entropy-based weighting.
Asymmetric Gradient Decoupling Strategy: A mechanism for the shared encoder that removes only conflicting reliability-gradient components while bounding the auxiliary update magnitude, preserving the primary prediction direction.
Comprehensive Evaluation: Extensive experiments on CIFAR-10, CIFAR-100, SVHN, and Fashion-MNIST under both instance-dependent and instance-independent candidate-label settings, demonstrating effectiveness through comparisons, ablation studies, and gradient diagnostics.

4. Experimental Results

The authors evaluated RGD-PLL against state-of-the-art methods (e.g., PiCO, CAND, CRDPLL, IDGP) across multiple datasets and settings.

Performance: RGD-PLL achieved the highest test accuracy on all datasets.
- Instance-Dependent: On CIFAR-100, RGD-PLL achieved 79.04% accuracy, outperforming the second-best method (CAND, 78.22%) by 0.82 percentage points. On Fashion-MNIST, it reached 93.25%.
- Instance-Independent: RGD-PLL consistently outperformed baselines across varying noise levels ( $q$ ) on CIFAR-10, SVHN, and CIFAR-100.
Ablation Studies: Removing any component (e.g., momentum teacher, entropy weighting, gradient decoupling, or norm balancing) resulted in performance degradation, confirming the complementary roles of these modules.
Gradient Analysis: Diagnostics showed that while gradient conflicts occur in a minority of batches (approx. 8–13%), the conflicting subset exhibits strong negative alignment. The asymmetric projection successfully reduced the cosine similarity of conflicting gradients to zero while preserving compatible directions.
Computational Efficiency: The framework introduces a minimal increase in trainable parameters (~~0.07M) and training time (~~1.68x baseline) due to the momentum teacher and dual gradient computation. Crucially, at inference time, the momentum teacher and reliability estimator are discarded, leaving no additional overhead compared to standard encoder-classifier models.

5. Significance and Claims

The paper claims that RGD-PLL addresses a previously underexplored aspect of partial-label learning: the optimization interference caused by unreliable candidate supervision. By treating candidate reliability not just as a supervision source but as a regulator for shared parameter optimization, the framework mitigates the risk of misleading signals corrupting the feature encoder.

The authors emphasize that their approach connects candidate-level uncertainty with gradient-level regulation. Unlike general multi-objective methods that treat objectives symmetrically, RGD-PLL respects the hierarchical nature of PLL (prediction as primary, reliability as auxiliary). The results suggest that explicitly managing the direction and magnitude of auxiliary gradients is essential for robust learning in ambiguous supervision settings. The work concludes by noting that future research will extend this framework to noisy and open-set partial-label scenarios.