Ambiguity-Induced Contrastive Learning for Instance-Dependent Partial Label Learning

1 Introduction

The remarkable performance of modern deep neural networks (DNNs) owes much to the large amount of fully supervised training data, and the stringent data requirements can be a barrier to the application of DNNs to certain tasks. Researchers therefore often resort to cheap non-expert labelers, but this invariably leads to low-quality data, a typical example of which is the ambiguity of the labels. Label ambiguity is pervasive [Chen et al., 2017] for a simple reason: people have difficulty making exact judgments about tasks that are beyond their expertise, which means that each instance may be labeled with a set of candidate labels (CLs) such that a fixed and unknown candidate is the ground truth. Such supervision constantly has negative impacts on the performance of DNNs, since memorization effects [Feldman and Zhang, 2020] make them prone to overfitting all CLs. Thus, partial label learning (PLL) [Xu et al., 2019; Lv et al., 2020; Feng et al., 2020; Wang et al., 2020b; Wang et al., 2020a; Wang et al., 2022] which can handle the label ambiguity has drawn a lot of attention in recent years. The goal of PLL is to induce the optimal hypothesis which can generalize well for fully supervised data.

∗Corresponding Author

Recent works have presented promising methods on PLL with a common goal to disambiguate incorrect label association [Cour et al., 2011], i.e., purifying the CLs heuristically in the training phase to avoid undesired memorization of incorrect CLs. For this purpose, a strand of works [Yu and Zhang, 2017] regard the ground-truth label as a latent variable and identify it by leveraging the information from feature space. For example, [Xu et al., 2019] construct a weighted graph over the training instances to characterize the structure of feature space, and then migrate this graph to label space to identify the ground-truth label. Average-based PLL approaches [Cour et al., 2011; Zhang and Yu, 2015] treat all the candidate labels equally and average the modeling outputs as the prediction. Deep PLL methods of late [Lv et al., 2020; Feng et al., 2020] capitalize on the inductive bias of the learning model itself. DNNs typically exhibit an important behavior in that they learn patterns first [Arpit et al., 2017]: this means that labels that are remembered first can be considered as the ground-truth labels. Revisiting all previous PLL works, we note that few of them exploited the label ambiguity, since they explicitly or implicitly assume that incorrect CLs are noise independent of the instance.

Unfortunately, this is often the case where human labeling is prone to varying degrees of confusion for instances of varying ambiguity. An overwhelming majority of previous PLL works assume that given the true category (e.g., "Siberian tiger"), each of the other categories (e.g., "Bengaltiger", "leopard" or "cat") has a fixed probability of being the CL [Zhang and Yu, 2015; Feng et al., 2020]. But apparently, human labeling tends to pick CLs related to both the true label and the instance itself. Let us focus on the two input instances (referred to as image.a and image.b respectively) in the upper left of Figure 1. Despite they belong to the same category ("Siberian tiger"), each of the other categories (e.g., "Bengal-tiger", "leopard" or "cat") has a unfixed probability of being the CL which depends on both the true label and the instance itself. This setting is more realistic, i.e., the CLs are instance-dependent, such that it is arguable that each CL tends to describe the instance from some sensory channels, such as physics, geometry and semantics. Therefore, it is natural to conclude that the potentially useful information from label ambiguity should also be exploited rather than eliminated directly in more practical instance-dependent PLL.

In this paper, we leverage such additional information acquired from the ambiguity and propose AmBiguity-induced contrastive LEarning (ABLE) under the framework of contrastive learning [Khosla et al., 2020; Chen et al., 2020]. Specifically, we construct various positives per anchor by considering each CL of this anchor and selecting a group of samples currently predicted as that class as the ambiguityinduced positives. Then each training instance has multiple (the number of its CLs) groups of ambiguity-induced positives for building contrastive losses to pull the anchor and its ambiguity-induced positives closer in the representation space, and push the remaining instances away. Based on them, we learn a representor (RP) to minimize the weighted sum of these contrastive losses, where each contrastive loss serves as a sub-objective, assigned with an ambiguity-induced weight. The weights should be learned, and the larger weights will bias sub-objectives that lead to better representations. To learn the weights and estimate the class of training samples, we train a classifier (CS) that minimizes a classic PLL classification loss [Lv et al., 2020]. It deserves a particular mention that there exists a circular dependency between RP and CS: RP requires the ambiguity-induced positives and weights onthe-fly induced by CS, and CS needs the first half of RP as the representation extractor. ABLE proposes a synchronous update strategy of RP and CS to break the circular dependency hopefully. Our contributions are summarized as follows:

• We consider a more general setting - instance-dependent PLL and for the first time propose the label ambiguity containing valid information should be exploited.
• We introduce a novel instance-dependent PLL method, which for the first time adapts contrastive learning, and propose an end-to-end training strategy.
• Experiments on benchmark datasets demonstrate substantial improvements over state-of-the-art methods for learning from the instance-dependent partially labeled data.

2 RelatedWork

2.1 Partial Label Learning

Most recent PLL methods focus on label disambiguation which aims to identify the ground-truth label from the CL set [Lv et al., 2020; Feng et al., 2020; Xu et al., 2021b]. For averaging-based disambiguation [Cour et al., 2011; Zhang and Yu, 2015], all the CLs of each instance are treated equally and the prediction is made by averaging their modeling outputs. For identification-based disambiguation [Yu and Zhang, 2017], the ground-truth label is regarded as a latent variable and identified. For deep-based methods, [Lv et al., 2020] proposes a classifier-consistent risk estimator and a progressive identification algorithm. [Feng et al., 2020] deduces a risk-consistent method and a classifier-consistent method by proposing a statistical model. These methods corrupt data without considering the CLs are always instance-dependent in practice. [Xu et al., 2021b] firstly considers the instancedependent PLL and proposes VALEN which recovers the latent label distribution via inferring the true posterior density of the latent label distribution [Xu et al., 2021a] by Dirichlet density parameterized with an inference model and deduces the evidence lower bound for optimization. However, we note that few of them exploited the label ambiguity. In this paper, we aim to leverage such potentially useful information acquired from the label ambiguity for learning from the partially labeled data.

2.2 Contrastive Learning

Contrastive learning is an approach which is committed to learning an representation space where representations from the same instance are pulled closer and representations from different instances are pushed apart [Khosla et al., 2020]. Positives and negatives are generated for each instance to construct the loss. A plethora of works have explored the effectiveness in unsupervised representation learning [Chen et al., 2020; He et al., 2020]. Lately, [Khosla et al., 2020] proposes Supervised Contrastive Learning which combines explicit supervision to aggregate data from the same class as the positive set. Recently, the success has stimulated a series of works to utilize contrastive learning to weakly supervised learning problems [Li et al., 2021], etc. In this paper, we aim to construct various positives per anchor by considering each CL of this anchor and selecting ambiguity-induced positives currently predicted as that class. Then each training instance has multiple groups of ambiguity-induced positives for building contrastive losses. We further consider that each group of ambiguity-induced positives contributes differently to learning from the partially labeled instances.

3 Method

In this section, we describe our novel ABLE method in detail. First of all, we give an overview of ABLE (Section 3.1). Then, we describe two key components of ABLE which consists of ambiguity-induced positives selection mechanism (Section 3.2) and ambiguity-induced contrastive learning (Section 3.3). Figure 2 gives an illustration of ABLE.

3.1 Overview of ABLE

First of all, we briefly introduce some necessary notations. Let X be the input space, Y = {1, 2, ..., c} be the label space with c class labels. Given PLL training set D = {(xk, Sk)|1 ≤ k ≤ M} where xk denotes the training instance and Sk ⊆ Y denotes the CL set. The key definition of PLL is that the latent ground-truth label yk ∈ Y of an instance xk is always included in its CL set. And the goal is as the same with supervised classification: learning a classifier h that can make correct predictions on unseen inputs. Here, we get rid of the traditional instance-independent assumption [Feng et al., 2020], i.e., p(Sk|xk, yk) = p(Sk|yk), and consider a more general instance-dependent case.

Given each mini-batch B, {(xk, Sk)|1 ≤ k ≤ n}, we generate two random augmentations [Khosla et al., 2020], i.e., Baug = {(aug(xk), Sk)|1 ≤ k ≤ n} and Baug′ = {(aug′ (xk), Sk)|1 ≤ k ≤ n}, where aug(·) and aug′ (·) represent two augmentation functions. Therefore, for each minibatch B, the corresponding batch used for training consists of 2n samples, {(˜xi, ˜ Si)|1 ≤ i ≤ 2n}, i.e., Baug ⋃ Baug′ . For the remainder of this paper, we refer to the n samples as a "batch" and the 2n samples as an "augmented batch". Within an augmented batch, let I = {1, 2, ..., 2n} be the index set corresponding to the representation pool, i ∈ I be the index of an arbitrary augmented sample. Following [Chen et al., 2020], first of all, both augmented views are separately fed into the same encoder network f(·) which maps

˜xi to an representation ˜ vi = f(˜xi) ∈ Rde , yielding a pair of representations. Note that ˜ vi is normalized to the unit hypersphere in Rde . Afterwards we utilize the projection network, g(·), which maps ˜ vi to a low-dimensional representation ˜ zi = g(˜ vi) ∈ Rdp . ˜ zi is also normalized to the unit hypersphere in Rdp . Now we have representations corresponding to the augmented batch. We call f(·) and g(·) as RP. For each augmented training instance ˜xi, we select multiple groups of ambiguity-induced positives for building contrastive losses. Based on them, we learn the RP to minimize the weighted sum of these contrastive losses which is called weighted ambiguity-induced loss. Meanwhile, CS, i.e., h(·), receives ˜ vi as input and outputs ˜pi = h(˜ vi), which is trained by minimizing a PLL classification loss. It is worth noting that there exists a circular dependency between RP and CS: RP requires the ambiguity-induced positives and weights onthe-fly induced by CS, and CS needs f(·) which is the first half of RP as the representation extractor. To break the circular dependence, we jointly train the classification loss and the weighted ambiguity-induced loss which is a synchronous update strategy of RP and CS.

3.2 Ambiguity-Induced Positives Selection

In more practical and realistic instance-dependent PLL, the potentially useful information from label ambiguity should be exploited rather than eliminated directly. We leverage such additional information acquired from the ambiguity by adopting an ambiguity-induced positives selection mechanism. Given each PLL training sample (˜xi, ˜ Si) in the augmented batch, we construct various positives by considering each CL in ˜ Si and selecting a group of samples currently predicted as that class as the ambiguity-induced positives. Note that we impose limits on the class prediction ˜ yi = argmaxj∈˜ Si ˜ pij to be in the CL set ˜ Si, where ˜ pij denotes the j-th entry of CS output ˜pi. Then each training sample has multiple groups of ambiguity-induced positives and the number of groups equals to the number of CLs. We define ambiguity-induced positives set as Ap (˜xi) = ⋃m∈ ˜ Si Apm(˜xi) for the training instance ˜xi which is composed of multiple ambiguity-induced positives groups. For each CL in ˜ Si, the corresponding ambiguity-induced positives related to ˜xi is defined as follows:

where N(i) = I\{i} be the index set of the other samples originating from the same augmented batch. For efficient consideration, we select the ambiguity-induced positives in the current augmented batch. Despite its simplicity, we obtain superior experimental results. We also consider maintaining a queue to store the most current representations and updated predictions [He et al., 2020], which is left for future research.

3.3 Ambiguity-Induced Contrastive Learning

After completing ambiguity-induced positives selection, each training instance has multiple (the number of its CLs) groups of ambiguity-induced positives. Then we construct ambiguity-induced pairs which include the training instance and its corresponding ambiguity-induced positives for the following contrastive learning. First of all, we build respective contrastive loss to pull the anchor and its ambiguity-induced positives closer in the representation space, and push the remaining instances away. Given the training representation ˜ zi and an arbitrary ambiguity-induced positive ˜ zp which is selected from its ambiguity-induced positives set, we define the contrastive loss as follows:

where N(i) = I\{i} be the index set of the other representations originating from the same augmented batch, τ is the temperature parameter and · denotes the dot product. We further consider that each group of ambiguity-induced positives contributes differently to learning from the partially labeled instances. In other words, we consider learning a progressively contrastive representation space to facilitate the process of learning from the partially labeled data. We tackle it using the labeling confidences of CLs for progressively putting more weights on more reliable ambiguity-induced pairs. Specifically, we define the ambiguity-induced weight in a progressive fashion:

where j denotes the indices of CLs. We initialize wij with uniform weights, i.e., wij = 1/|˜ Si| if j ∈ ˜ Si, otherwise wij = 0.

Given each training representation ˜ zi and its ambiguityinduced positives set Ap (˜xi), we define a novel weighted ambiguity-induced loss Lwcon(˜ zi, ˜ Si,Ap ,N, τ) as follows:

Algorithm 1 Pseudo code of ABLE (one epoch)

Input: The PLL training dataset D, encoder network f(·), projection network g(·), classifier h(·), uniform ambiguityinduced weights w, constant α.

Output: Parameters of encoder network f(·) and classifier h(·).

• 1: for iter = 1, 2, .., do
• 2: Sample a mini-batch {(xk, Sk)}nk=1 fromD.
• 3: for k = 1 to n do
• 4: ˜pk = h(f(aug(xk)))
• 5: ˜x2k-1, ˜x2k = aug(xk), aug′ (xk)
• 6: ˜ z2k-1, ˜ z2k = g(f(˜x2k-1)), g(f(˜x2k))
• 7: ˜ S2k-1 = ˜ S2k = Sk, ˜p2k-1 = ˜p2k = ˜pk
• 8: end for
• 9: for k = 1 to 2n do
• 10: ˜ yk = argmaxj∈˜ Sk ˜ pkj
• 11: N(k) = {1, 2, ..., 2n}\{k}
• 12: Ap (˜xk) = ⋃m∈˜ Sk {k′ |k′ ∈ N(k), ˜ yk′ =m}
• 13: end for

• 15: Lc = - 1n ∑nk=1 ∑cj=1 wkj · log(hj(f(aug(xk))))
• 16: Minimize Ltotal = Lc +αLw.
• 17: Update ambiguity-induced weights w.
• 18: end for

where τ is the temperature parameter and · denotes the dot product. We minimize the weighted ambiguity-induced loss which is the weighted sum of these contrastive losses to train the RP, where each contrastive loss serves as a sub-objective to pull the anchor and its ambiguity-induced positives closer in the representation space, and push the remaining instances away. And the larger ambiguity-induced weights will bias sub-objectives that lead to better representations. To learn the weights and estimate the class of training samples, we train the CS that minimizes a classic PLL classification loss [Lv et al., 2020] for each training instance xi:

It is worth mentioning in particular that there exists a circular dependency between RP and CS: RP requires the ambiguity-induced positives and weights on-the-fly induced by CS, and CS needs the first half of RP as the representation extractor. To break the circular dependency, we propose a synchronous update strategy of RP and CS. Specifically, we jointly train the RP and CS. Therefore, the overall loss Ltot for each training instance xi is defined as:

where α is the trade-off parameter for the classification loss and the weighted ambiguity-induced loss. The pseudo-code of our ABLE is shown in Algorithm 1.

4 Experiments

4.1 Setup

Datasets. We adopt four widely used benchmark datasets including MNIST [LeCun et al., 1998], FashionMNIST [Xiao et al., 2017], Kuzushiji-MNIST [Clanuwat et al., 2018], CIFAR-10 1 . To generate the instance-dependent candidate labels, we set the flipping probability of each incorrect label corresponding to each instance by using the confidence prediction of a neural network trained with clean labels [Xu et al., 2021b]. We run five trials and record the mean accuracy as well as standard deviation for all comparing methods.

Baselines. We compare the performance of ABLE against five methods, each configured with parameters suggested in respective literature: 1) VALEN [Xu et al., 2021b]:An instance-dependent PLL method which recovers the label distribution and deduces the evidence lower bound for optimization; 2) PRODEN [Lv et al., 2020]: A progressive identification PLL method which approximately minimizes a risk estimator and identifies the true labels in a seamless manner; 3) RC [Feng et al., 2020]: A risk-consistent PLL method which employs the importance reweighting strategy to converge the true risk minimizer; 4) CC [Feng et al., 2020]: A classifierconsistent PLL method which uses a transition matrix to form an empirical risk estimator; 5) D2CNN [Yao et al., 2020]: A deep PLL method which designs an entropy-based regularizer to maximize the margin between the potentially correct label and the unlikely ones.

Implementation details. For the encoder network f(·), we experiment with ResNet-18 [He et al., 2016]. The normalized activations of the final pooling layer (de = 512) are used as the representation. For the projection network g(·), we instantiate g(·) as a multi-layer perceptron with a single hidden layer of size 512 (as well as ReLU activation) and output representation of size 128. We also normalize the low-dimensional representation to lie on the unit hypersphere. For the classifier h(·), we instantiate h(·) as a single linear layer. We use two data augmentation modules following [Khosla et al., 2020; Wang et al., 2022]. The trade-off parameter is set as α = 1.0. The temperature parameter is set as τ = 0.1. The mini-batch size, the number of training epochs, the initial learning rate and the weight decay are set to 64, 500, 0.01 and 1e-3, respectively. We adopt cosine learning rate scheduling. The optimizer is stochastic gradient descent (SGD) with momentum 0.9. We implement ABLE with PyTorch. Source code is available at https://github.com/AlphaXia/ABLE. We also want to use ABLE on MindSpore 2 , which is a new deep learning framework. These problems are left for future work.

1 https://www.cs.toronto.edu/∼kriz/cifar.html

4.2 Experimental Results

ABLE achieves SOTA results. We report the classification accuracy of each method in Table 1. · indicates whether ABLE is statistically superior to the comparing method on each dataset (pairwise t-test at 0.05 significance level). In addition, the best results are highlighted in bold. As shown in Table 1, we can observe that ABLE always outperforms all the compared methods by a significant margin on all datasets, which validates the effectiveness of our ABLE. Finally, we observe that ABLE achieves results that are comparable to the fully supervised learning model on some datasets, showing that exploiting label ambiguity facilitates the process of learning from the instance-dependent partially labeled data.

Effect of exploiting label ambiguity and utilizing contrastive learning. We ablate the contributions of two key components of ABLE: ambiguity-induced positives selection mechanism and ambiguity-induced contrastive learning. Specifically, we compare ABLE with three weakened versions: (1)Version1: ABLE w/o weighted ambiguityinduced positives which removes the ambiguity-induced weights. (2)Version2: ABLE w/o ambiguity-induced positives which removes the ambiguity-induced positives. (3)Version3: ABLE w/o utilizing contrastive learning which removes the contrastive learning part. As shown in Table 2, we can observe that ABLE obtains more superior results than Version1 (e.g., +2% on CIFAR-10) and Version2 (e.g., +3%

2 https://www.mindspore.cn/

on CIFAR-10), which verifies the effectiveness of two key components of ABLE.

Effect of trade-off factor α. As illustrated in Figure 3, we also report the performance of ABLE with varying α values that trade-off the classification loss and our weighted ambiguity-induced loss. In our setting, α is selected from {0.01, 0.1, 0.5, 1.0, 5.0, 10.0}. We can find that the result is stable when performing on Fashion-MNIST and CIFAR10. Similar empirical results were also found on other benchmark datasets. We also want to use dynamic trade-off factor to balance the classification loss and our weighted ambiguityinduced loss, which is left for future work.

ABLE benefits from longer training. We report the impact of mini-batch size when models are trained for different numbers of training epochs in Figure 4. We observe that training longer progressively puts more ambiguity-induced weights on more reliable ambiguity-induced pairs, which improves the results. We also find that larger mini-batch size has a significant advantage over the smaller one when the number of training epochs is small (e.g. 200 epochs). With more training epochs, the gaps between different mini-batch sizes decrease or disappear.

Bigger encoder networks promote ABLE. We report that ABLE benefits from bigger encoder networks as illustrated in Table 3 while similar findings hold for supervised learning. We consider that means the power of contrastive learning can be released by using bigger encoder networks.

Nonlinear projection networks improve ABLE. We then study the necessity of designing a suitable projection network for ABLE, i.e. g(·). Figure 5 shows results using different settings for the projection network: (1) None, i.e., no projection network. (2) Linear projection network with one linear layer. (3) Nonlinear projection network with one additional hidden layer and ReLU activation. We find that a nonlinear projection network achieves better results than a linear projection network (e.g., +2% on CIFAR-10), and also much better than no projection network (e.g., +7% on CIFAR-10). We consider that more knowledge which benefits training can be obtained by utilizing the nonlinear projection network.

5 Conclusion

In this paper, we considered a more practical case of PLL than those have been well-studied. We rethought label ambiguity in instance-dependent PLL and pointed out that it contains valid information which may help in representation learning and deep classifier training. To leverage such useful information, we proposed a novel method named ABLE that extended the contrastive loss by selecting ambiguityinduced positives, and updated the representor and classifier synchronously within a coherent framework. To the best of our knowledge, this is the first time to apply contrastive learning to instance-dependent PLL. Experiments on benchmark datasets validated the effectiveness of our method.

Acknowledgments

This research was supported by the National Key Research & Development Plan of China (No. 2018AAA0100104, No. 2018AAA0100100), the National Science Foundation of China (62125602, 62076063), China Postdoctoral Science Foundation (2021M700023), Jiangsu Province Science Foundation for Youths (BK20210220).