Training Neural Networks on Data Sources with Unknown Reliability

## Abstract

Abstract When data is generated by multiple sources, conventional training methods update models assuming equal reliability for each source and do not consider their individual data quality during training. However, in many applications, sources have varied levels of reliability that can have negative effects on the performance of a neural network. A key issue is that often the quality of data for individual sources is not known during training. Focusing on supervised learning, this work presents a solution that aims to train neural networks on each data source for a number of steps proportional to the source’s estimated relative reliability. This way, we allow training on all sources during the warm-up, and reduce learning on less reliable sources during the final training stages, when it has been shown models overfit to noise. We show through diverse experiments, this can significantly improve model performance when trained on mixtures of reliable and unreliable data sources, and maintain performance when models are trained on reliable sources only.

## 1 Introduction

Data sources can have differing levels of noise but in many applications, are merged together to form a single dataset.
In healthcare, for example, data sources (such as different devices or sites) are often combined together [, ], but may not provide the same level of data quality and could contain noisy features, incorrect labelling, or missing values. These problems, if unaddressed, can have detrimental effects on the performance and robustness of machine learning models [, , ].

In this work, we consider the supervised learning case, in which a neural network is trained on data from multiple sources that are (ideally) producing unique features and labels from the same distribution, but where some sources are producing noisy features or labels at an unknown rate(^1^11Training with missing data using our method could be achieved by randomly generating features or labels in place of missing values, but this is not a focus of our work.).

Two possible solutions for this context naturally arise: Preprocessing can be used to remove out-of-distribution observations from training [, , ] but, this requires the user to define “out-of-distribution" for the features and labels, and eliminating data assumes nothing can be learnt from noisy examples [].
Secondly, techniques for training neural networks on noisy data can be applied, of which many exist [, ]. In this case however, we are not utilising the information gained from knowing an observation’s data source – which we show is useful, especially within settings of considerable noise.

We therefore propose Loss Adapted Plasticity (LAP); inspired by ideas from the literature, and loss tempering,
it is a general method for training neural networks on multi-source data with mixed reliability.
As we do not know the sources’ true noise level a priori, we maintain a history of the empirical risk on data from each source that is used to temper the likelihood during training. This is done such that the number of steps a model is trained on a source is proportional to its estimated reliability.
Hence, a model trained with LAP will benefit from seeing examples from all sources during early training, and reduce learning on less reliable data later in training, when the model is prone to memorising noisy data points [, , , ].
To illustrate our method’s effectiveness, we present results on diverse settings and datasets, in which we implemented or adapted baseline code from Han et al. [], Wang et al. [], Li et al. [] and Li et al. [].
We find: (1) The proposed method, LAP, improves the performance of a neural network trained on data generated by sources with mixed reliability, and (2) maintains performance when no unreliability is present. We also show that (3) LAP is applicable to a variety of contexts and different noise types, and (4) we provide implementation details and code for further development and use (see Appendix A.1).

## 2 Background

Noisy labels can be introduced at any point during collection and
when human experts are involved, are practically inevitable [, , , ]: An expert might have insufficient information [, ];
expert labels are incorrect []; the labelling is subjective []; or there are communication problems []. Further, noisy features can be introduced through data processing, or faulty measurements [].
With each of these issues affecting data sources differently, we can observe varied data quality.

The majority of the work on noisy data focuses on noisy labels where solutions usually target a combination of four aspects [, ]: sample selection, model architecture, regularisation, or training loss.
IDPA [] explores instance dependent noise, where label noise depends on an observation’s features, in which they estimate the true label of confusing instances using model confidence during training.
Han et al. [] propose “Co-teaching", a sample selection method, in which two neural networks are trained simultaneously. Data for which one model achieves a low training loss is selected to “teach" the other network, as they are assumed to be more reliable. This work exploits the fact that neural networks learn clean data patterns and filter noisy instances in early training [, ], a fact that our work will take advantage of. Noisy inputs are additionally studied in Li et al. [], where they present RRL, employing two contrastive losses and a noise cleaning method using model confidence during training. This approach requires modifications to the model architecture and a $k$ nearest neighbours search at each epoch.
However, these methods do not consider multi-source data.

In federated learning, a server trains a global model using local updates on each source [], but when sources are noisy, these algorithms often fail [].
To tackle varied data quality, Li et al. [] propose ARFL, which learns global and local weight updates simultaneously.
The weighted sum of empirical risk of clients’ loss is minimised, where the weights are distributed by comparing each client’s empirical risk to the average empirical risk of the best $k$ clients.
The contribution to weight updates from the clients with higher losses are minimised with respect to the updates from other clients – forcing the global model to learn more from clients that achieve lower losses.

Further, Murphy [] discusses sensor fusion, where multiple observations from sensors with differing (but known) noise are taken, with the goal to calculate the true values.
This is connected to our setting, but in our case, sources generate multiple unique observations, and source reliability is unknown.

Therefore, we are exploring a context between many; federated learning, sensor fusion, and learning with noisy data, but differing enough such that methods do not apply or under-perform compared to our source-aware solution. Nevertheless, Co-teaching, IDPA, and ARFL will form our baselines.

### Motivation for new methods

We observe that work has so far focused on the problem of noisy data without considering individual sources.
To see why this could be helpful, consider $10$ data sources $\{s_{i}\}_{i=1}^{10}$ where one source, $s_{c}$, is producing noisy data with a probability of $0.5$ and all other sources are producing clean data.
Given a new observation from the noisy source, $x^{c}\in s_{c}$, consider the probability that $x^{c}$ is noisy: $p(x^{c}\notin\mathrm{R})$, where $\mathrm{R}$ is the set of reliable data and assume we know the noise rate of $s_{c}$: $p(x\notin\mathrm{R}~{}|~{}x\in s_{c})=0.5$.

Without knowing the data point’s source: The probability that a data point $x$ is unreliable (since $p(x\notin\mathrm{R}~{}|~{}x\notin s_{c})=0$) is: $p(x\notin\mathrm{R})=p(x\in s_{c})p(x\notin\mathrm{R}~{}|~{}x\in s_{c})=0.05$.

When knowing the data point’s source: The probability that a data point $x^{c}$ is unreliable ($x^{c}\in s_{c}$) is $p(x^{c}\notin\mathrm{R}~{}|~{}x^{c}\in s_{c})=0.5$.
Similarly, $p(x^{s\neq c}\notin\mathrm{R}~{}|~{}x^{s\neq c}\notin s_{c})=0$.

Clearly, the source value can provide information about noise that is helpful during model training.

## 3 Methods

Inspired by Co-teaching, ARFL, and loss tempering, we propose Loss Adapted Plasticity (LAP):
Briefly, we update a source reliability score as a function of the historical training empirical risk, which is used to re-weight loss such that the more reliable a source is, the longer the model trains on data from that source.
Importantly, we use the fact that when training, neural networks learn non-noisy patterns before noisy data [, , , , , ] and are observed fitting to noisy examples only after substantial progress is made in fitting to clean examples []. Therefore, in early training the empirical risk on clean data is lower than noisy data (Appendix A.2).

### Tempered likelihood

In our setting, we have a dataset $\mathcal{D}$ collected from sources in $S$ with $\mathcal{D}=\bigcup_{s\in S}\mathcal{D}_{s}$ and $s$ as either a noisy source $s\notin\mathrm{R}$ or a non-noisy source $s\in\mathrm{R}$, where $\mathrm{R}$ represents the reliable sources.
An optimal model on non-noisy data $\mathcal{D}_{R}$ (parameterised by $\theta$) would have log-likelihood: $\max_{\theta}\log p(\mathcal{D}_{R}|\theta)$.
However, since $R$ is unknown during training, we propose to use the tempered log-likelihood on all data $\mathcal{D}$. With $f(\cdot):[0,+\infty)\rightarrow[1,+\infty)$ as a positive and monotonically increasing function:

$$ $\log p(\mathcal{D}_{R}|\theta)=\sum_{s\in R}\log p(\mathcal{D}_{s}|\theta) \approx\sum_{s\in S}\frac{1}{f(C_{s})}\log p(\mathcal{D}_{s}|\theta)=\log p_{ \text{temp}}(\mathcal{D}|\theta)$ (1) $$

Where $C_{s}$ is the number of training steps that we believe source $s$ contains noise harmful to training, minus the number of steps it is considered non-noisy (clipped at 0 0). Therefore during late training, $C_{s}$ is large for noisy sources and $C_{s}=0$ for non-noisy sources, giving: a large temperature $f(C_{s})>>1$ for $s\notin\mathrm{R}$, and a low temperature $f(C_{s})=1$ for $s\in\mathrm{R}$, providing an approximation of $\log p(\mathcal{D}_{R}|\theta)$.

### Source reliability estimation

To calculate $C_{s}$, we use the assumption (discussed above) that neural networks achieve a lower empirical risk on clean data than noisy data in early training. Given a source $s$ for which we wish to update $C_{s}$, with all other sources as $s^{\prime}$; using $p_{\theta}(\cdot)=p(\cdot|\theta)$; and setting $\lambda>0$, we perform:

$$ $\displaystyle\begin{array}[]{c}C_{s}=\begin{cases}C_{s}+1,&\log p_{\theta}(D_{ s})<\texttt{exptvar}_{s^{\prime}}(\log p_{\text{temp},\theta}(D_{s^{\prime}}), \lambda)\\ C_{s}-1,&\text{otherwise}\end{cases}\vspace{0.5em}\\ C_{s}=\max\{0,C_{s}\}\vspace{0.5em}\\ \texttt{exptvar}_{\vartriangle}(\blacktriangle,\lambda)=\mathbb{E}_{ \vartriangle}[\blacktriangle]-\lambda\sqrt{\text{Var}_{\vartriangle}[ \blacktriangle]}\end{array}$ (5) $$

Intuitively, we increase $C_{s}$ and therefore the source’s temperature, if its log-likelihood is at most $\lambda$ standard deviations less than the expected tempered log-likelihood on all other sources.
Consequently, if no sources are noisy, and the distribution of negative log-likelihoods (NLLs) from the data sources forms a normal distribution, then we incorrectly increase the temperature of a non-noisy source $s$ with probability $p_{\theta}(\hat{L_{s}}\geq\lambda)$ where $L_{s}=-\log p_{\theta}(\mathcal{D}_{s})$ is the NLL on data from source $s$, and $\hat{L_{s}}$ refers to the standardisation of the NLL using the mean and variance of the NLLs of all other sources, $L_{s^{\prime}}$.
When we have noisy sources, we expect that their temperature is large, $f(C_{s})>>1$, after a number of steps that is representative of their relative noise level – naturally enabling learning from noisy sources for a number of steps that reflects their “usefulness".

### Implementation details

In the following, we present the implementation of our method as gradient scaling for clarity. Given a dataset $\mathcal{D}$ of features and labels
that is generated by $S$ sources, $\mathcal{S}=\{s_{1},...,s_{S}\}$. We denote a subset of $\mathcal{D}$ generated by source $s$ as $\mathcal{D}_{s}\subset\mathcal{D}$,
with each data point corresponding to a single source.

On a single update step of a model: we have the perceived unreliability for each source $C=\{C_{s}\}_{1}^{S}$ (initially, all sources are considered reliable and so $C_{s}=0~{}\forall s$); a batch of features, labels, and source values from $\mathcal{D}$; and a history of training losses, $L$ with length $H$ for all sources. Here, $L\in\mathbb{R}^{S\times H}$, and $l_{H}^{s}\in L$ denotes the mean loss of data from source $s$ over the most recent batch containing data in $\mathcal{D}_{s}$ (hence, subscript $H$).
A larger $C_{s}$ denotes a larger estimated noise level for source $s$.
Each step, we update the value $C_{s}$ (and hence, temperature) for a source $s$ using the empirical risk of all other sources $s^{\prime}$ as in Algorithm 1.
Further, we define $f(C_{s})$ from Equation 1:

$$ $1/f(C_{s})=(1-d_{s})=1-\tanh^{2}(0.005\cdot\delta\cdot C_{s})$ $$

This choice of $f$ has some nice properties discussed in this section and in Appendix A.3.
We refer to $d_{s}$ as the depression value; and $\delta$ is the depression strength, controlling the rate of depression.

Figure: Algorithm 1 Calculating $C_{s}$ at a given step

During training, gradient contributions from source $s$ are then scaled as follows:

$$ $\hat{g_{s}}=(1-d_{s})g_{s},~{}~{}d_{s}=\tanh^{2}(0.005\cdot\delta\cdot C_{s})$ (6) $$

Where $\hat{g_{s}}$ is the gradient update contribution from a source $s$.
As $(1-d_{s})$ is a scalar, this method can be interpreted as scaling gradient contributions (presented here), loss re-weighting as in Figure 1, or likelihood tempering as discussed previously in this section.
Additionally, a model evidence interpretation of LAP can be found in Appendix A.4.

We use $0.005$ to scale the depression strength $\delta$ for easier interpretation, whilst the use of $\tanh^{2}$ ensures that the scaling applied to $g_{s}$ is in $(0,1]$ and small perturbations of $C_{s}$ around 0 0 do not have a significant effect on $\hat{g_{s}}$, making it more robust to randomness. For more detail, see Appendix A.3.

Figure: Figure 1: Visualisation of Equation 5. Each colour represents the loss values from a single source over a small number of steps, with its density weighted by its temperature, $w(s)={1}/{f(C_{s})}$. This shows how sources contribute to $\mu_{s^{\prime}}$ and $\sigma_{s^{\prime}}^{2}$ as their $C_{s}$ changes during training and given the leniency $\lambda$. These values are synthetic and for demonstration.
Refer to caption: x1.png

### Intuitions

Figure 1 shows how the training process evolves over time when using LAP. At first, all sources are considered equally reliable and so the weighted mean of the loss values is the mean of all sources. As the source temperature changes, the weighed mean plus $\lambda$ standard deviations of the losses moves towards the sources with lower expected losses, allowing for more learning from the these over time.

Figure: Figure 2: Effect of the introduced parameters on training. Section 3, introduces three parameters that control the effects of LAP. $1-d_{s}$ is multiplied by the gradient (equivalently, loss) contribution from a given source before the model is updated. Here, we show these values for each source (the different coloured lines) during model training on synthetic data (Appendix A.5). Unless stated in the title of a given plot, the parameters of LAP were set to $H=25$, $\delta=1.0$, $\lambda=1.0$. We had $5$ sources with noise levels of $0.0$, $0.025$, $0.05$, $0.25$, and $1.0$ (a darker colour indicates a higher noise rate).
Refer to caption: x2.png

Figure 2 illustrates how $1-d_{s}$ (reciprocal of the temperature) in Equation 6 develops during training for each source and different $H$, $\delta$, and $\lambda$ values. The first row shows how varying the depression strength, $\delta$ affects the rate at which the learning on a source is reduced. The second row shows how the history length, $H$ influences $1-d_{s}$, where we can see that a larger value allows for a “smoother" transition. With the exception of small or large values, this parameter has the least effect on training. The third row illustrates how the leniency, $\lambda$ in Equation 5 and Algorithm 1 affects the training. Small values of $\lambda$ reduce noisy sources’ impacts influence earlier, whilst larger values miss some noisy sources all together. Here, the sources are coloured by their noise level, demonstrating that LAP reduced a source’s influence on training in a number of steps corresponding to a sources noise level.

In our experiments, LAP parameters were set at $H=25$, $\delta=1.0$, $\lambda=0.8$ unless otherwise stated in Appendix A.7. These were chosen based on the synthetic experiments presented in Figure 2 and the validation results on CIFAR-10 (Appendix A.7).

## 4 Experiments

### Baseline methods

To contextualise our approach, we evaluate varied baseline methods: (1) ARFL, designed to tackle label and input noise in a federated learning setting []; (2) a probabilistic method for instance dependent label noise (referred to here as IDPA) [] which modifies the training loss; (3) “Co-teaching", which trains two models simultaneously to perform sample selection based on loss values during training []; (4) RRL, which uses contrastive learning and a $k$ nearest neighbours search to enforce a smoothness constraint on learnt representations [], modifying model architecture and training loss; and (5) an identical model but without any specific modifications for tackling noise. Baseline methods were selected based on the availability of code, their use as baselines in the literature, and for variety in the methods used to evaluate the performance of LAP. Although our setting assumes noise is independent of features, we felt it was still beneficial to include IDPA, which is designed for instance dependent label noise. Additionally, for fair comparisons with federated learning, when models are compared to ARFL, they are trained on data that is structured such that each mini-batch contains a single source (in Appendix A.8 we study this restriction). This only concerns Table 1 since each batch in all other experiments contain multiple sources.

All baselines were implemented using the available code and trained using the recommended parameters with the model and data we test. For further details, see Appendix A.7.

### Experimental design

To evaluate LAP, we employ various techniques to produce noisy data, extending the methods in Li et al. [], Wang et al. [], Han et al. [], Li et al. [] and test on nine datasets from computer vision, healthcare time-series, natural language processing, and tabular regression for diverse experiments.

**Table 1: Comparison of LAP with the baselines. Mean ± standard deviation of accuracy (%) of $10$ repeats of the baselines and LAP on synthetic data with different noisy types. For CIFAR-100 these numbers represent the top 5 accuracy. For CIFAR-10, CIFAR-100, and F-MNIST, the number of noisy sources are $4$, $2$, and $6$ out of $10$ respectively. Unreliable sources are each 100% noisy. Note there are non-significant differences in results on “Original Data" between Standard and LAP training since here the data is non-noisy.**
|  |  | Model Types |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
|  | Noise Type | Standard | ARFL | IDPA | Co-teaching | LAP (Ours) |
| CIFAR-10 | Original Data | 67.89 ± 1.16 | 61.32 ± 1.13 | 64.17 ± 1.92 | 67.19 ± 0.86 | 67.76 ± 1.61 |
| Chunk Shuffle | 63.78 ± 1.17 | 58.01 ± 1.54 | 58.11 ± 1.30 | 62.39 ± 0.65 | 64.22 ± 2.06 |  |
| Random Label | 57.47 ± 1.52 | 57.71 ± 2.32 | 51.02 ± 2.10 | 54.35 ± 1.48 | 62.74 ± 1.84 |  |
| Batch Label Shuffle | 57.48 ± 1.48 | 59.38 ± 1.25 | 51.71 ± 1.59 | 58.66 ± 0.67 | 63.06 ± 1.90 |  |
| Batch Label Flip | 51.83 ± 2.41 | 59.21 ± 1.35 | 49.58 ± 1.67 | 51.82 ± 1.41 | 63.21 ± 2.35 |  |
| Added Noise | 57.54 ± 1.48 | 51.57 ± 2.21 | 53.43 ± 2.14 | 57.64 ± 0.71 | 59.62 ± 1.91 |  |
| Replace With Noise | 61.11 ± 2.60 | 55.19 ± 1.72 | 59.22 ± 1.66 | 62.27 ± 1.02 | 61.52 ± 1.87 |  |
| CIFAR-100 | Original Data | 64.46 ± 0.93 | 58.25 ± 1.19 | 58.64 ± 0.96 | 61.42 ± 0.99 | 64.46 ± 0.93 |
| Chunk Shuffle | 61.87 ± 1.16 | 57.12 ± 0.90 | 53.49 ± 1.22 | 54.74 ± 2.15 | 62.56 ± 0.61 |  |
| Random Label | 55.90 ± 1.11 | 56.49 ± 1.83 | 44.03 ± 1.31 | 45.08 ± 1.61 | 61.26 ± 1.02 |  |
| Batch Label Shuffle | 57.67 ± 0.86 | 56.85 ± 1.13 | 46.37 ± 1.17 | 50.32 ± 1.00 | 61.62 ± 1.34 |  |
| Batch Label Flip | 48.94 ± 2.13 | 56.34 ± 1.20 | 26.55 ± 7.71 | 24.97 ± 3.29 | 59.98 ± 1.06 |  |
| Added Noise | 56.83 ± 0.91 | 53.49 ± 1.01 | 48.35 ± 1.48 | 50.58 ± 0.99 | 59.56 ± 0.99 |  |
| Replace With Noise | 60.06 ± 0.97 | 55.00 ± 1.08 | 50.44 ± 2.24 | 53.00 ± 1.31 | 59.99 ± 1.26 |  |
| F-MNIST | Original Data | 82.86 ± 1.51 | 80.95 ± 1.40 | 83.07 ± 1.06 | 77.85 ± 1.94 | 82.86 ± 1.51 |
| Chunk Shuffle | 76.90 ± 2.00 | 76.10 ± 1.15 | 76.82 ± 1.88 | 73.79 ± 3.12 | 81.03 ± 2.27 |  |
| Random Label | 73.47 ± 5.78 | 77.58 ± 1.69 | 74.30 ± 5.50 | 67.84 ± 6.00 | 77.91 ± 3.39 |  |
| Batch Label Shuffle | 81.26 ± 1.72 | 78.35 ± 1.17 | 81.43 ± 0.54 | 78.79 ± 0.55 | 81.53 ± 1.70 |  |
| Batch Label Flip | 77.64 ± 3.43 | 77.84 ± 1.50 | 78.22 ± 3.04 | 75.96 ± 2.83 | 79.26 ± 3.78 |  |
| Added Noise | 78.05 ± 1.96 | 73.12 ± 1.96 | 78.10 ± 1.69 | 75.26 ± 1.89 | 79.98 ± 3.83 |  |
| Replace With Noise | 78.99 ± 2.20 | 74.29 ± 1.19 | 79.09 ± 1.72 | 75.82 ± 2.14 | 81.14 ± 2.25 |  |

Following Li et al. [], Wang et al. [], Han et al. [], Li et al. [], we test our proposed method and baselines on CIFAR-10, CIFAR-100 [], and F-MNIST [] forming many comparisons with the literature. Along with Tiny-Imagenet and Imagenet [], these five datasets form well-studied computer vision tasks, easing reproducibility.
Additionally, we use a human labelled version of CIFAR-10, titled CIFAR-10N [], for which we use the “worst labels" allowing us flexibility in our experiments.
We then study an electrocardiograph (ECG) dataset, PTB-XL []; a time-series classification task with the goal to classify normal and abnormal cardiac rhythms and for which noise can be simulated following Wong et al. [] and random labelling to understand LAP applied to time-series data with multiple noise types.
A sentiment analysis natural language task allows us to further compare LAP against the literature, for which we employ the IMDB dataset [] containing movie reviews and their sentiment.
Finally, to illustrate our method’s use in regression tasks, we present results on the California Housing dataset [].
For further information, see Appendix A.6.

To simulate data sources for CIFAR-10, CIFAR-100, F-MNIST, Imagenet, IMDB, and California Housing, data is uniformly split into $10$ distinct groups, and for Tiny-Imagenet we use $100$ groups to study larger numbers of sources.
For CIFAR-10 and CIFAR-100, $4$ and $2$ of these sources are chosen to be noisy respectively; for F-MNIST, Imagenet, and Tiny-Imagenet $6$, $5$ and $40$ are chosen; and for IMDB and California Housing $4$ are chosen. These are in line with the noise rates used in the literature (often $20\%$, $40\%$, $50\%$).
For CIFAR-10, in Appendix A.11 we also significantly increase the number of sources.
To generate noise for the vision datasets, we extended the methods in Li et al. []:
(1) Original Data: No noise is applied to the data;
(2) Chunk Shuffle: Split features into distinct chunks and shuffle. This is only done on the first and/or second axis of a given input;
(3) Random Label: Randomly assign a new label from the same code;
(4) Batch Label Shuffle: For a given batch of features, randomly shuffle the labels;
(5) Batch Label Flip: For a given batch of data, assign all features in this batch a label randomly chosen from the same batch;
(6) Added Noise: Add Gaussian noise to the features, with mean $=0$ and standard deviation $=1$;
(7) Replace with Noise: Replace features with Gaussian noise, with mean $=0$ and standard deviation $=1$.

For IMDB and California Housing we use random labelling, and for IMDB we further shuffle the order of text tokens (referred to as “Random Permute").

PTB-XL was labelled by $12$ nurses, naturally forming data sources. However, since this data is high quality, synthetic noise is required. We add Gaussian noise to sources’ ECG recordings (simulating electromagnetic interference as in Wong et al. []) and label flipping to simulate human error in labelling. This also allows us to test the setting with multiple noise types.
Here, data from sources are upsampled so that each source contains the same number of observations. For experiments with PTB-XL, we linearly increase the number of noisy sources from $1$ to $8$ (out of $12$ in total), and for each number of noisy sources we set the noise level for each source linearly from $0.25$ to $1.0$. For example, when training with $4$ noisy sources, sources haves noise levels of $0.25$, $0.50$, $0.75$, and $1.0$.

Although CIFAR-10N contains real-world noise, we must still split the data into sources. For each experiment, we assign sources as to evaluate varied levels of noise and numbers of noisy sources. As is done for PTB-XL, we linearly increase the number of noisy sources from $1$ to $7$ (out of $10$ in total), and for each set of noisy sources we linearly increase the noise level from $0.25$ to $1.0$.

For this, five base model architectures are evaluated (of multiple sizes): A Multilayer Perceptron, Convolutional Neural Network, a 1D and 2D ResNet [], and an LSTM [] (Appendix A.7).

In all experiments, data points contain an observation, source, and target, which are assigned to mini-batches in the ordinary way. Features and labels are passed to the model for training, whilst sources are used by LAP (Appendix A.7). The test sets contain clean labels only.

### Results

**Table 2: RRL and RRL + LAP results. Mean ± standard deviation of the maximum test accuracy (%) of $10$ repeats of RRL and LAP on CIFAR-10 data with different types of noise. Here, $4$ out of $10$ sources are 100% noisy.**
|  | Model Types |  |
| --- | --- | --- |
| Noise Type | RRL | RRL + LAP (Ours) |
| Original Data | 87.67 ± 0.37 | 87.54 ± 0.22 |
| Chunk Shuffle | 82.93 ± 0.29 | 84.27 ± 0.31 |
| Random Label | 76.04 ± 1.43 | 80.31 ± 0.58 |
| Batch Label Shuffle | 77.66 ± 0.71 | 80.84 ± 0.51 |
| Batch Label Flip | 78.81 ± 0.66 | 82.02 ± 0.45 |
| Added Noise | 78.51 ± 0.74 | 81.70 ± 0.48 |
| Replace With Noise | 80.05 ± 0.65 | 79.00 ± 0.75 |

Baselines and LAP. Table 1 shows the results of the baselines and LAP on CIFAR-10, CIFAR-100, and F-MNIST.

These experiments illustrate that in high noise settings, in most cases, using LAP allows for improved test performance over the baselines. In particular, our method allows for improved performance over two different approaches to learn from noisy labels (IDPA and Co-teaching), and over an approach from federated learning (ARFL), as well as training a model in the standard way. This is the case across the three different datasets tested in this experiment with varied noise types, displaying LAP’s wide applicability.
Required by ARFL, each batch contains one source and so within Appendix A.8 we replicate the CIFAR-10 experiments with multiple sources in each batch. There we see that all methods improve on the results shown in Table 1 by approximately the same amount, leading to the same conclusions.

LAP in conjunction with RRL. When evaluating the RRL baseline, we found that using the same model architecture as in Table 1 caused an unexpected loss in accuracy. We therefore used the larger architecture (Appendix A.7) employed in Li et al. [] and data augmentation to allow for a fairer comparison. We tested RRL with and without LAP to evaluate its ability to be used in conjunction with other methods. Table 2 presents these results on CIFAR-10, and further underlines the use of LAP to improve model performance on data generated by multiple sources.
Here, LAP supplements the performance obtained by RRL, which uses a contrastive learning approach to tackle noisy features and labels, that is improved upon by further applying our method to make use of the source values.
We observe that LAP increases all metric scores except for “Replace With Noise", where the difference is relatively small, and “Original Data", where both methods perform equally. In Appendix A.9, we further experiment with different numbers of noisy sources and noise rates in the same setting.

Figure: (a) AUC precision-recall on PTB-XL.
Refer to caption: x3.png

**Table 3: Standard and LAP results on a natural language task. Mean ± standard deviation of maximum test accuracy (%) of $5$ repeats of standard training and LAP on the IMDB dataset with different types of noise. Here, $4$ out of $10$ sources are 100% noisy. Note that “Random Label" is the noise type with a largest difference between methods.**
|  | Model Types |  |  |  |
| --- | --- | --- | --- | --- |
| Noise Type | Standard | IDPA | Co-teaching | LAP (Ours) |
| Original Data | 82.81 ± 0.79 | 83.24 ± 0.56 | 85.12 ± 0.8 | 83.2 ± 0.83 |
| Random Permute | 83.46 ± 0.91 | 83.28 ± 0.79 | 85.6 ± 0.15 | 83.26 ± 1.09 |
| Random Label | 65.01 ± 0.65 | 64.61 ± 0.71 | 67.18 ± 0.69 | 71.95 ± 2.94 |

Time-series data sources with varied and mixed noise. Figure 3(a) compares the results of not using and using LAP for a time-series classification task on normal and abnormal cardiac rhythms with both label and input noise. To evaluate the model on data sources with differing noise levels, for each number of noisy sources we set the noise levels of sources at linear increments between $25\%$ and $100\%$. Additionally, we linearly increase the number of these noisy sources and measure the area under the precision-recall curve (AUC PR) on the test set. These results shows that LAP allows for improved model training on data with sources of varied noise and with multiple noise types.
Figure 3(a) also illustrates that in this setting, LAP is robust to increases in the noise within the dataset, as the AUC PR does not significantly degrade, especially when compared to not using LAP. Interestingly, when only two sources contain noise, the total noise rate in the dataset is only $10\%$ (lower than commonly tested in the literature), which has little negative effect on the standard training method, leading to both methods achieving similar results.

LAP on real-world noisy labels. To further demonstrate the effectiveness of LAP in conjunction with other noisy data methods and on real-world noise, we now present the results on a dataset with human labelling of varied noise rates. Figure 3(b) illustrates the results on CIFAR-10N, a noisy human labelled version of CIFAR-10, where we observe a similar pattern to that depicted in Figure 3(a).
In both cases, LAP improved performance on noisy data at all noise levels tested, and the standard deviation over the accuracy is reduced.
However, we also note that in this case the performance of LAP degraded faster than in Figure 3(a) as the number of noisy sources increased.
This could be for various reasons, such as differing noise types, model baselines, and data type.
In Appendix A.10 we also show the results of this experiment when using the same model architecture as in Table 1, and with standard training as a baseline, instead of RRL, where we arrive at the same conclusions.

LAP on a noisy natural language task. We also tested LAP on a natural language task, in which the goal is to predict the sentiment from the movie review. The results are presented in Table 3, for which we tested two types of noise. Note the largest difference between the results is seen for “Random Label" noise, in which LAP clearly out-performs the baselines. This is as expected, since for “Random Permute", tokens in a review could still easily be classified with the correct sentiment as the words indicating a positive or negative review (such as “good" or “bad") will still be contained within the text, but in a different location. Additionally, we expect that when the data is not noisy, using LAP should not limit performance, which we see here. It is interesting however, that Co-teaching performs better in the “Original Data" and “Random Permute" settings. We hypothesise that the IMDB dataset contains some noisy labels (through human error), which were split uniformly across data sources; a limitation of our method that we discuss in Section 5.

Additional results. Many further experiments, such as with varied numbers of sources and source sizes (A.8, A.9 and A.11), models sizes (A.10), Imagenet (A.12 and A.13), a regression task (A.14), and the effect on late training performance (A.13.1) can be found in Appendix which provide further intuitions about LAP and strong evidence for its use in a wide variety of settings.

## 5 Discussion

This research reveals some interesting future research directions. In our experiments, we studied models of varied capacity (for example: Table 1 and Appendix A.10, and Table 2 and Appendix A.13), however, it is interesting to further study the effects of ill specified models on noisy data techniques, since most methods assume that models attain smaller losses on the non-noisy data points (for example: in our work and Co-teaching []), or that logits are reliable (for example: in RRL [] and IDPA []).
Additionally, our work focuses on the setting in which knowing the source of a data point provides extra information in learning from noisy data. However, when the noise level is uniform across all sources, knowing the source value does not provide additional information about a data point’s likelihood of being noisy, and so in this particular case LAP would perform as well as standard training. Here, it would be beneficial to apply a noisy data technique in addition to our method, such as with RRL + LAP, studied in the experiments (Table 2, Figure 3(b), and Appendix A.9).

When using new methods, the computational complexity should also be considered. The additional compute required to apply LAP to a single source is $O(S+B)$ and the extra memory cost is $O(S\times H)$ (where $S$ is the number of unique sources in the dataset, $B$ is the batch size, and $H$ is the length of the loss history), as we calculate the source means and standard deviations online. For multiple sources in a batch, the additional compute becomes $O(S\times S_{b}+B)$ (where $S_{b}$ is the number of unique sources in a batch). The extra memory cost in this case is $O(S\times H+S_{b}\times S)$. Although vectorised in the current implementation, $O(S\times S_{b})$ could be performed with $S_{b}$ parallel jobs of $O(S)$, since each source calculation is independent, significantly improving its speed for larger numbers of sources. This is however, already significantly faster than the baselines tested, in which Co-teaching trains two models, IDPA trains a model twice, and RRL applies a $k$-nearest neighbours approach at each epoch.

Importantly, as is the case with all methods designed for training models on noisy data, thought must be given to the underlying cause of noise. For example, in some scenarios noise within a dataset could be attributed to observations on minority groups during data collection, rather than as a result of errors in measurements, labelling, or data transfer. This is why we began with the assumption that all data (if non-noisy) is expected to be generated from the same underlying probability distribution. If data from minority groups are not carefully considered, any technique for learning from noisy data, or standard training could lead to an unexpected predictive bias [].

Within this work we presented LAP, a method designed for training neural networks on data generated by many data sources with unknown noise levels. In Section 4, we observed that using LAP during training improves model performance when trained on data generated by a mixture of noisy and non-noisy sources, and does not hinder performance when all data sources are free of noise. The results also illustrated that applying the proposed method is beneficial at varied noise levels, when training on multiple sources with differing levels of noise, and with different types of noise. We additionally see through results in Table 1, 2, 3 and Figure 3(a), and 3(b) that our method is applicable across multiple domains with differing tasks. Moreover, within the Appendix we present many further experiments, showing that: (1) The improvements in results translate to large scale datasets (Imagenet), with multiple noise types (Appendix A.13); (2) LAP is robust to overfitting of noisy data, and therefore achieves significantly greater performance during late training (Appendix A.13.1); and (3) LAP continues to outperform the baseline on a regression task (Appendix A.14). Further, our implementation (Appendix A.1) allows this method to be easily applied to any neural network training where data is generated by multiple sources.

In conclusion, we have shown that the proposed method is versatile – providing improved model performance in a variety of noisy data settings and equal performance on non-noisy data, and therefore envision many scenarios in which LAP is relevant and useful.

## Acknowledgments

This study is funded by the UK Dementia Research Institute (UKDRI) Care Research and Technology Centre funded by the Medical Research Council (MRC), Alzheimer’s Research UK, Alzheimer’s Society (grant number: UKDRI–7002), and the UKRI Engineering and Physical Sciences Research Council (EPSRC) PROTECT Project (grant number: EP/W031892/1). Infrastructure support for this research was provided by the NIHR Imperial Biomedical Research Centre (BRC) and the UKRI Medical Research Council (MRC).
The funders were not involved in the study design, data collection, data analysis or writing the manuscript.

## Appendix A Appendix

### A.1 Code implementation

An implementation of the proposed method, as well as the code to reproduce the main results in this paper is made available (^2^22[https://github.com/alexcapstick/unreliable-sources](https://github.com/alexcapstick/unreliable-sources)). The experiments in this work were completed in Python 3.11, with all machine learning code written for Pytorch 2.1 []. Other requirements to run the experiments are available in the supplementary code. We make our code available under the MIT license.

All datasets tested are publicly available and easily accessible. Additionally, within the supplementary code we use the default Pytorch Dataset objects for CIFAR-10, CIFAR-100, and F-MNIST and provide Pytorch Dataset objects that will automatically download, unzip, and load the data for PTB-XL, CIFAR-10N, IMDB, and California Housing. We additionally provide code to load Tiny-Imagenet and Imagenet from a local directory, since it requires an agreement before accessing. This makes reproduction of the work presented simple to perform.

Baselines were made available by the authors on GitHub:

- •
ARFL []: MIT License: [https://github.com/lishenghui/arfl](https://github.com/lishenghui/arfl).
- •
IDP []: License not provided: [https://github.com/QizhouWang/instance-dependent-label-noise](https://github.com/QizhouWang/instance-dependent-label-noise).
- •
Co-teaching []: License not provided: [https://github.com/bhanML/Co-teaching](https://github.com/bhanML/Co-teaching).
- •
RRL []: BSD 3-Clause License: [https://github.com/salesforce/RRL](https://github.com/salesforce/RRL).

All experiments were conducted a single A100 (80GB VRAM), and 32GB of RAM. The full research project required more compute than the experiments reported in the paper to design and implement LAP, as well as choose training parameters for the standard training model that were then used for LAP and the baselines. Further information about the compute time required to run each of the main experiments is found in Appendix A.7, and the corresponding section of the Appendix for further experiments. In total, using this hardware, experiments took approximately 15 days to complete.

### A.2 Loss assumptions

Within this work, and for many other methods designed for tackling noisy data, we make use of the assumption that during training, neural networks learn non-noisy patterns before fitting to noisy data, and therefore achieve a greater log-likelihood on non-noisy data during early training. This is discussed within Zhang et al. [], Arpit et al. [], Han et al. [], Arazo et al. [], Yu et al. [], Shen and Sanghavi [], Li et al. [], Wang et al. [], which present both theoretical and empirical justifications. We also observe these training dynamics in Appendix A.13.1 (specifically, Figure 5), in which the standard training method overfits to noisy data points significantly during the later training stages when compared to our method for learning from noisy data.

### A.3 Further details on design decisions

#### Why use a weighted mean and standard deviation?

Firstly, we will discuss why the weighted mean and standard deviation is used for comparing sources with each other. This is done to allow for the identification of noisy sources by our method when different data sources might have significantly different noise levels. This is the case in Figure 2, where we have one source producing $100\%$ noise and other sources with $5\%$, and $2.5\%$ noise levels. Here, because the noise in the sources are so varied, the sources with lower noise levels would likely never have an average loss more than the unweighted mean of the loss trajectory plus the threshold created from the leniency multiplied by the unweighted standard deviation (Algorithm 1). By weighting the mean and standard deviation with the calculated temperature, we are able to ensure that all sources with noise level greater than $0\%$ will be discovered in a number of model update steps proportional to their noise level. This is shown in Figure 1, where the weighted mean and standard deviation of the loss moves further to the left, as the weight reduces the influence of the unreliable source (on the right).

#### Why the mean + standard deviation for thresholding?

When calculating whether a source should be considered more or less unreliable, we need to be able to calculate a reliability compared to the other sources. We therefore use a mean and standard deviation over previous loss values, so that we can calculate a relative reliability. As described in Section 3, it also provides an intuitive idea about the probability that a non-noisy source is incorrectly identified as noisy on a single step (if the means of loss values are assumed to follow a Gaussian distribution, which is not unreasonable according to the central limit theorem).

#### Why do we clip reliability at 0?

In Algorithm 1, we clip $C_{s}$ at 0 0 to ensure that when we have sources with noise levels of different magnitudes, once the sources with larger noise levels have been heavily weighted and so have insignificant effects on the weighted mean and standard deviation, we are able to start reducing the reliability of other noisy sources immediately, rather than waiting for $C_{s}$ to increase from some negative value to 0 0. Also, since we use the $\tanh^{2}$ function to calculate loss (or gradient) scaling, clipping $C_{s}$ at 0 0 prevents us from introducing an error in which loss from reliable sources get scaled with the same factor as unreliable sources.

#### Explanation for using 𝐭𝐚𝐧𝐡 𝟐 superscript 2 \boldsymbol{\tanh^{2}} bold_tanh start_POSTSUPERSCRIPT bold_2 end_POSTSUPERSCRIPT

Equation 6 describes the scaling of gradients (or equivalently, loss values) to reduce the contributions to model updates from less reliable data sources over time. Although any monotonically increasing function can be used for $f(\cdot):[0,+\infty)\rightarrow[1,+\infty)$, we find that $1/f(C_{s})=1-\tanh^{2}(0.005\cdot\delta\cdot C_{s})$ provides some nice properties: $y=\tanh^{2}x$ has gradient of 0 0 at $x=0$, and is asymptotic to $y=1$, which are important qualities for calculating the model update scaling. The stationary point at $x=0$ means that small perturbations in the unreliability of each source around $C_{s}=0$ have little effects on the scaling of model updates, which reduces the consequences of randomness in loss values from a given source and ensures that source contributions are only significantly scaled once it is clear that their loss values are consistently larger than those of the other sources. Secondly, since $y=\tanh^{2}x$ is asymptotic to $y=1$, the scale factor, $1-d_{s}$ (Equation 6) for sources that are calculated to be unreliable eventually reduces to 0 0, allowing the model to “ignore" these data points as if they were masked in late training.

#### Explanation for scaling with 0.005 0.005 \boldsymbol{0.005} bold_0.005

The value of $0.005$ used within the $\tanh^{2}$ function allows for the depression strength parameter $\delta$ to be on the scale of $1$, as shown in Figure 2.

### A.4 Alternative interpretation

Here, we present another interpretation of our proposed method which may provide inspiration for future research.

As discussed in Appendix A.2, the model evidence, $p(\mathcal{D}|\mathcal{M})$ ($\mathcal{D}$: the dataset and $\mathcal{M}$: the model) is the probability that a dataset is generated by a given model (by marginalisation of the model parameters). In our case, this could be used to calculate the probability that data from each source, $s$ is generated by the given model, namely: $p(\mathcal{D}_{s}|\mathcal{M})$ where $\mathcal{D}_{s}$ is the data generated by a source $s$.
A model designed for non-noisy data should have a high $p(\mathcal{D}_{s}|\mathcal{M})$ when $\mathcal{D}_{s}$ has a low noise level, and a low $p(\mathcal{D}_{s}|\mathcal{M})$ when $\mathcal{D}_{s}$ has a high noise level.
However, $\log(p(\mathcal{D}_{s}|\mathcal{M}))$ is hard to compute for neural networks, and would require an approximation.
It can be shown that $p(\mathcal{D}|\mathcal{M})$ can be approximated by the logsumexp of the log-likelihood over a training trajectory with noisy gradients, which approximates the posterior samples with SGLD or SGHMC [, ].
Within our work, when computing if a given source is noisy or non-noisy, the mean loss for this source is calculated over a training trajectory of length equal to the history length, $H$ (given by $\mu_{s}$ in Algorithm 1).
This is then compared to a weighted mean of the loss over a training trajectory of length $H$ of all sources excluding the source under scrutiny (given by $\mu_{s^{\prime}}$ in Algorithm 1).
This weighted mean is related to $p(\mathcal{D}_{R}|\mathcal{M})$ where $\mathcal{D}_{R}$ represents the data from all non-noisy sources, since the weights allow us to reduce the influence of noisy sources.
Therefore, our method is related to one in which the model evidence is calculated for each source at each step, and where the sources with a relative model evidence higher than some threshold (defined in our work through the leniency, $\lambda$) have larger influence on the model parameters when updating the weights.

### A.5 Details of the varied parameter experiments

To build an intuition for the parameters introduced in defining LAP, we run some synthetic examples to understand their effects on $1-d_{s}$ (in Equation 6). The results of this are presented in Figure 2.

Dataset. The synthetic data is created using Scikit-Learn’s make_moons (^3^33[https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html)) function, which produced $10,000$ synthetic observations with $2$ features. Each observation is assigned a label based on which “moon" the observation corresponded to. Then, to produce synthetic sources and noise levels for each source, we randomly assign each data point a source number from 0 0 to $4$, so that we have $5$ sources in total. Data points for each source were then made noisy by randomly flipping labels such that each source had a noise level of $0.0$, $0.025$, $0.05$, $0.25$, or $1.0$.

Model and training. A simple Multilayer Perceptron (MLP) with hidden sizes of ($100$, $100$) and ReLU activation functions is trained on this data using the Adam optimiser with a learning rate of $0.01$, a weight decay of $0.0001$, and with $(\beta_{1},\beta_{2})=(0.9,0.999)$ for $50$ epochs with a batch size of $128$. Data is shuffled at each epoch before being assigned to mini-batches.

LAP parameters. When conducting the experiments, the values of $\delta$, $H$, and $\lambda$ were varied as is described in the graphs shown in Figure 2 to experiment with different values of these newly introduced parameters. Unless otherwise specified, the values chosen are $H=25$, $\delta=1.0$, $\lambda=1.0$.

These experiments take approximately $5$ minutes to complete using the compute described in Appendix A.1.

### A.6 Further information on the datasets

The content of each of the datasets is as follows:

- •
CIFAR-10 and CIFAR-100 [] are datasets made up of $60000$ RGB images of size $32\times 32$ divided into 10 and 100 classes, with $6000$ and $600$ images per class respectively. The task in this dataset is to predict the correct class of a given image.
- •
F-MNIST [] is made up of $70000$ greyscale images of clothes of size $28\times 28$ divided into 10 classes with $7000$ images per class, which is flattened into observations with 784 features. The task of this dataset is to predict the correct class of a given image.
- •
PTB-XL [] consists of $21837$ ECG recordings of $10$ second length, sampled at $100$Hz, from $18885$ patients, labelled by $12$ nurses. The task of this dataset is to predict whether a patient has a normal or abnormal cardiac rhythm.
- •
CIFAR-10N [] is a dataset made up of all examples from CIFAR-10, but with human labelling categorised into different levels of quality. For our case, to allow for the most flexibility in experiment design, we utilised the worst of the human labels.
- •
IMDB [] is a natural language dataset with a sentiment analysis task. The goal is to correctly classify a movie review as either positive or negative based on its text. It contains $25000$ reviews in the training set, and $25000$ reviews in the testing set, split equally between positive and negative sentiment.
- •
Tiny-Imagenet [] contains $110000$ RGB images of size $64\times 64$ from $200$ classes, with the goal of correctly classifying an image into the given class. There are $100000$ training images and $10000$ images in the test set.
- •
Imagenet [] contains $1281167$ RGB images scaled to size $64\times 64$ from $1000$ classes, with the goal of correctly classifying an image into the given class. There are $1231167$ training images and $50000$ images in the test set.
- •
California Housing [] contains $20640$ samples of house values in California districts, with the goal to predict the median house value from the U.S census data for that region. We randomly split the data into training and testing with an $8:2$ ratio on each repeat.

Dataset licenses. CIFAR-10, CIFAR-100, and F-MNIST are managed under the MIT License, whilst PTB-XL is made available with the Creative Commons Attribution 4.0 International Public License (^4^44[https://creativecommons.org/licenses/by/4.0/](https://creativecommons.org/licenses/by/4.0/).), and CIFAR-10N is available with the Creative Commons Attribution-Non Commercial 4.0 International Public License (^5^55[https://creativecommons.org/licenses/by-nc/4.0/](https://creativecommons.org/licenses/by-nc/4.0/).). IMDB(^6^66[https://ai.stanford.edu/~amaas/data/sentiment/](https://ai.stanford.edu/~amaas/data/sentiment/)) and California Housing(^7^77[https://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.html](https://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.html)) are made publicly available, and Tiny-Imagenet and Imagenet are available after agreeing to the terms of access (^8^88[https://www.image-net.org/download](https://www.image-net.org/download)).

Dataset availibility. As mentioned in Appendix A.1, all datasets tested are publicly available and easily accessible. Additionally, within the supplementary code we use the default Pytorch Dataset objects for CIFAR-10, CIFAR-100, and F-MNIST and provide Pytorch Dataset objects that will automatically download, unzip, and load the data for PTB-XL, CIFAR-10N, IMDB, and California Housing. We additionally provide code to load Tiny-Imagenet and Imagenet from a local directory, since it requires an agreement before accessing. This makes reproduction of the work presented simple to perform.

### A.7 Experiments in detail

For each of the experiments presented in Section 4, we will now describe the dataset, models, and training in detail.

#### Model architectures

Within our experiments, we tested $4$ model architectures, described below. Due to limitations in compute and to allow for our work to be easily reproducible, we use different levels of model capacity which additionally illustrates that our method is applicable in varied settings. All models are also available in the supplementary code, implemented in Pytorch.

- •
Low capacity multilayer perceptron (MLP): The MLP used in Section 4 consists of 3 linear layers that map the input to dimension sizes of $16$, $16$, and the number of classes. In between these linear layers we apply dropout with a probability of $0.2$, and a ReLU activation function. For our experiments on California Housing, we used hidden sizes of $32$, $32$, $32$, and $1$ (for the output value) with ReLU activation functions.
- •
Low capacity CNN: This model consisted of $3$ convolutional blocks followed by $2$ fully connected layers. Each convolutional block contained a convolutional layer with kernel size of $3$ with no padding, and a stride and dilation of $1$; a ReLU activation function; and a max pooling operation with kernel size of $2$. The linear layers following these convolutional blocks maps the output to a feature size of $64$ and then the number of classes, with a ReLU activation function in between.
- •
High capacity CNN with contrastive learning: This CNN is inspired by the model used for the CIFAR-10 experiments in Li et al. [] and requires considerably more compute. It is based on the ResNet architecture [], except that it uses a pre-activation version of the original ResNet block. This block consists of a batch normalisation operation, a convolutional layer (of kernel size $3$, a padding of $1$, and varied stride, without a bias term), another batch normalisation operation, and another convolutional layer (with the same attributes). Every alternate block contains a skip connection (after a convolutional layer, with a kernel size of $1$ and a stride of $2$, had been applied to the input). The input passes through a convolutional layer before the blocks. This is followed by a linear layer that maps the output of the convolutions to the number of classes. This model also contains a data reconstruction component that allows for a unsupervised training component.
- •
ResNet 1D: This model is designed for time-series classification and is based on the 2D ResNet model [], except with 1D convolutions and pooling. The model is made up of $4$ blocks containing two convolutional layers split by a batch normalisation operation, ReLU activation function, and a dropout layer. These convolutional blocks reduce the resolution of their input by a quarter and increase the number of channels linearly by the number of input channels in the first layer of the model. Each block contains a skip connection that is added to the output of the block before passing through a batch normalisation operation, ReLU activation function and dropout layer. This is followed by a linear layer that transforms the output from the convolutional blocks to the number of output classes.
- •
ResNet 2D: This model is designed for image classification and is exactly the ResNet 18 or Resnet 50 architecture presented in He et al. []. For our implementation, we used the model source code available with Pytorch (^9^99[https://pytorch.org/vision/main/models/resnet.html](https://pytorch.org/vision/main/models/resnet.html)).
- •
LSTM: The natural language model contains an embedding layer, which maps tokens to vectors of size $256$, a predefined LSTM module from Pytorch (^10^1010[https://pytorch.org/docs/stable/generated/torch.nn.LSTM.html](https://pytorch.org/docs/stable/generated/torch.nn.LSTM.html)) with $2$ layers and a hidden size of $512$, a dropout layer with a probability of $0.25$, and a fully connected layer mapping the output from the LSTM module to $2$ classes.

#### Datasets and model training

Results in Table 1. To produce the results in Table 1, we used two different models applied to three different datasets, with 7 noise settings.

- •
CIFAR-10 and CIFAR-100: All training data is randomly split into $10$ sources, with $4$ and $2$ sources chosen to be noisy for CIFAR-10 and CIFAR-100 respectively. In this experiment, these noisy sources are chosen to be $100\%$ noisy so that we can get an understanding of how our method performs on data containing highly noisy sources. Noise is introduced based on the description given in Section 3. The Low capacity CNN described above is trained on this data and tasked with predicting the image class using cross entropy loss. The model is trained for $25$ epochs in both cases, with the Adam optimiser [] and a learning rate of $0.001$ on batches of size $128$. When training with LAP, we use $H=25$, $\delta=1.0$, and $\lambda=0.8$ chosen using the validation data (which is made noisy using the same procedure as the training data) after trained on data with batch label flip noise. When training on CIFAR-100 we found that using a warm-up of $100$ steps improved performance.
- •
F-MNIST:
All training data is randomly split into $10$ sources, with $6$ chosen to be $100\%$ noisy.
The low capacity MLP model is trained for $40$ epochs using the Adam optimiser, and a learning rate of $0.001$ on batches of size $200$. When training with LAP, we use $H=50$, $\delta=1.0$, and $\lambda=0.8$ chosen using the validation data (which is made noisy using the same procedure as the training data) after trained on data with batch label flip noise.

In our implementation, each data point contained an observation, the generating data source, and a target. In this experiment, to maintain consistency with ARFL, data points were assigned to mini-batches such that each batch contained data from a single source. The features and labels were passed to the model for training, and the sources were used to calculate the weighting to apply to the loss on each data point.

To allow fairness in the comparison with ARFL, global updates on this model were performed the same number of times as the number of epochs other models were trained for, with all clients being trained on data for a single epoch before each global update. All other parameters for the ARFL model are kept the same.
When testing IDPA, the parameters were chosen as in Wang et al. [] by using the default parameters in the implementation.
Finally, when testing “Co-teaching", the parameters are chosen as in Han et al. [] where possible, and scaled proportionally by the change in the number of epochs between their setting and our setting where they depended on the total number of epochs. The forgetting rate was set as the default given in the implementation code, $0.2$, since we do not assume access to the true noise rate.

These experiments take approximately $2$ days to complete when using the compute described in Appendix A.1.

For all of the following experiments, to reduce computational cost, we fix the parameters of LAP to $H=25$, $\delta=1.0$, and $\lambda=0.8$. In practise, optimising these parameters should allow for improved performance when using LAP over those presented in this work.

Results in Table 2. To produce the results presented here, all training data is randomly split into $10$ sources, with $4$ chosen to be $100\%$ noisy. The high capacity CNN with contrastive learning presented in Li et al. [] is trained for $25$ epochs, with all other parameters kept as in the original work. In addition to this model, a version (with the same parameters) is trained using LAP with $H=25$, $\delta=1.0$, and $\lambda=0.8$. These models were trained on batch sizes of $128$ using stochastic gradient descent with a learning rate of $0.02$, momentum of $0.9$, and weight decay $0.0005$. Data is randomly assigned to mini-batches, with each batch containing multiple sources.

These experiments take approximately $3$ days to complete when using the compute described in Appendix A.1.

Results in Figure 3(a). This experiment allowed us to test the performance of using LAP on different numbers of sources with varied noise levels. Firstly, data is split into $12$ sources based on the clinician performing the labelling of the ECG recording. Then, for a given number of sources (increasing along the $x$ axis), the noisy sources have noise levels that are set at linear intervals between $25\%$ and $100\%$. These sources are made noisy following suggestions in Wong et al. [] to simulate electromagnetic interference and using label flipping to simulate human error in labelling. On this data, we train the ResNet 1D model for $40$ epochs using the Adam optimiser with a learning rate of $0.001$ and a batch size of $64$. This model is trained with and without LAP with $H=25$, $\delta=1.0$, and $\lambda=0.8$. Data is randomly assigned to mini-batches, with each batch containing multiple sources.

These experiments take approximately $16$ hours to complete when using the compute described in Appendix A.1.

Results in Figure 3(b). Here, CIFAR-10 is used as the features and the labelling collected in Wei et al. [] are used as the noisy labels to produce CIFAR-10N.
The data is first randomly split into $10$ sources. Then, for a given number of sources (increasing along the $x$ axis), the noisy sources have noise levels that are set at linear intervals between $25\%$ and $100\%$, by replacing the true CIFAR-10 labels with the real noisy labels from Wei et al. []. The high capacity CNN with contrastive learning presented in Li et al. [] is trained for $25$ epochs, with all other parameters kept as in the original work. As before, a version of this model (with the same parameters) is trained using LAP with $H=25$, $\delta=1.0$, and $\lambda=0.8$. These models are trained on batch sizes of $128$ using stochastic gradient descent with a learning rate of $0.02$, momentum of $0.9$, and weight decay $0.0005$. Data is randomly assigned to mini-batches, with each batch containing multiple sources.

These experiments take approximately $30$ hours to complete when using the compute described in Appendix A.1.

Results in Table 3. In this set of experiments, we wanted to test the use of LAP in a natural language setting. Firstly, we load the training and testing sets and randomly split the training set into $10$ sources uniformly. We then choose $4$ of the sources to be $100\%$ unreliable, and introduce noise through random labelling and randomly permuting the order of the text. We truncate or extend each review such that it contains exactly $256$ tokens. We use an LSTM to predict the sentiment of the movie reviews by training the model for $40$ epochs with a batch size of $128$, leaning rate of $0.001$ and the Adam optimiser []. A version of this model (with the same parameters) is also trained using LAP with $H=25$, $\delta=1.0$, and $\lambda=0.8$. As before, data is randomly assigned to mini-batches, with each batch containing multiple sources. Since IDPA and Co-teaching are not bench-marked on this dataset, for the baseline specific parameters we used the same values as given for CIFAR-10.

These experiments take approximately $12$ hours to complete when using the compute described in Appendix A.1.

### A.8 Table 1 with multiple sources in batches

**Table 4: Table 1 CIFAR-10 results, with multiple sources in each batch. Mean ± standard deviation of maximum test accuracy (%) of $5$ repeats of the baselines and LAP on synthetic data with different noisy types on CIFAR-10. There are $4$ noisy sources out of $10$ total sources. Unreliable sources are each 100% noisy. Note there are non-significant differences in results on “Original Data" between Standard and LAP training since here the data is non-noisy.**
|  | Model Types |  |  |  |
| --- | --- | --- | --- | --- |
| Noise Type | Standard | IDPA | Co-teaching | LAP (Ours) |
| Original Data | 69.46 ± 1.12 | 70.86 ± 0.32 | 67.73 ± 0.83 | 69.6 ± 1.08 |
| Chunk Shuffle | 65.92 ± 1.32 | 66.34 ± 0.99 | 63.55 ± 0.41 | 66.92 ± 0.56 |
| Random Label | 60.85 ± 1.67 | 57.93 ± 1.59 | 61.37 ± 1.01 | 66.5 ± 0.43 |
| Batch Label Shuffle | 62.23 ± 0.62 | 60.08 ± 0.13 | 63.9 ± 0.44 | 66.09 ± 0.65 |
| Batch Label Flip | 59.94 ± 2.48 | 61.02 ± 1.9 | 63.05 ± 2.43 | 64.48 ± 1.11 |
| Added Noise | 59.86 ± 1.38 | 61.19 ± 0.33 | 59.59 ± 1.37 | 63.58 ± 1.03 |
| Replace With Noise | 65.07 ± 0.63 | 65.85 ± 0.64 | 64.1 ± 1.13 | 64.89 ± 1.28 |

Since ARFL is designed for a federated learning setting, it is only able to access data from a single source at a time. As mentioned in Section 4, to maintain a consistent experimental setting, we therefore trained all methods in Table 1 on batches that contained only a single source. For completeness, and to highlight that the same conclusions still remain when batches contain multiple sources, we reproduce the results for CIFAR-10 but with multiple sources in each batch. These results are presented in Table 4. This table highlights the same pattern, but does additionally show that the noisy label baselines perform better than the standard training when batches contain multiple sources, likely because each batch has less variability in the number of noisy data points compared to the experiments in Table 1. Note in all experiments presented in this work, apart from Table 1, each batch contains multiple sources.

These experiments take approximately $12$ hours to complete when using the compute described in Appendix A.1.

### A.9 RRL + LAP with varied noise.

Table 5 shows the percentage difference in accuracy when using LAP over not using LAP for different noise levels and numbers of noisy sources.

In these experiments, data in CIFAR-10 is randomly split into $10$ sources, with the row of Table 5 defining the number of noisy sources, of which all have a noise rate as given by the column of Table 5. As before, the high capacity CNN with contrastive learning presented in Li et al. [] is trained for $25$ epochs, with all other parameters kept as in the original work. Additionally, a version of this model (with the same parameters) is trained using LAP with $H=25$, $\delta=1.0$, and $\lambda=0.8$. These models are trained on batch sizes of $128$ using stochastic gradient descent with a learning rate of $0.02$, momentum of $0.9$, and weight decay $0.0005$. Data is randomly assigned to mini-batches, with each batch containing multiple sources.

When the whole dataset noise level is small (i.e: 2 sources with 25% noise), there are small performance increases when using LAP – likely because here, noisy sources have small impacts on the performance of models trained without LAP. Additionally, for lower noise levels, increasing the number of noisy sources reduced the performance improvement. This is likely because LAP is reducing noisy source training contributions early, when there is still information to learn. This can be remedied by increasing the leniency ($\lambda$), however since we were limited by compute, LAP parameters were fixed across experiments.

These experiments take approximately $5$ days to complete when using the compute described in Appendix A.1.

**Table 5: Different noise level and number of sources. Mean ± standard deviation (%) of the percentage difference in maximum test accuracy between RRL + LAP and RRL over $5$ repeats when training a model on CIFAR-10 for different noise levels and numbers of sources. Here a positive value represents an improvement in accuracy when using LAP. Here, $U$ corresponds to the number of unreliable sources out of 10 sources in total. Batch label flipping was used to introduce noise.**
|  | Noise Level |  |  |  |
| --- | --- | --- | --- | --- |
| $U$ | 25% | 50% | 75% | 100% |
| 2 | 0.88% ± 0.19 | 1.61% ± 0.60 | 2.95% ± 0.64 | 3.16% ± 0.51 |
| 4 | 0.09% ± 0.71 | 1.25% ± 0.58 | 2.01% ± 0.96 | 5.24% ± 1.24 |
| 6 | 0.02% ± 0.43 | 0.46% ± 0.50 | 3.74% ± 0.80 | 11.61% ± 1.66 |

### A.10 CIFAR-10N with a smaller neural network

Figure: Figure 4: Accuracy values on CIFAR-10N for an increasing number of noisy sources with a lower capacity model. The lines and error bands represent the mean and standard deviation of the maximum test accuracy for each of the 5 repeats with random allocation of noisy sources. The noise of the sources increases linearly from $25\%$ to $100\%$ for each number of noisy sources. In total, there are $10$ sources. Here we test the low capacity CNN (Appendix A.7).
Refer to caption: x5.png

In Figure 4, we show the results of the experiment presented in Figure 3(b) except when using the smaller network used to calculate the results in Table 1. The results in this experiment follow the same trend as in Figure 3(b), reassuring us of the applicability of LAP in a variety of settings, where lower capacity models are used.

These experiments take approximately $4$ hours to complete when using the compute described in Appendix A.1.

### A.11 CIFAR-10 with a with large numbers of sources

Table: Table 6: Comparison of LAP with the baselines with varied numbers of sources. Mean ± standard deviation of maximum test accuracy (%) of $5$ repeats of the baselines and LAP on synthetic data with different noisy types and numbers of sources. The number of noisy sources ranges from $10$ to $50000$, corresponding to “LAP-$n$", where $n$ denotes the number of sources in the training data. For all experiments, $40\%$ of the sources were chosen as unreliable, with 100% noise rate. Only the LAP methods require re-training and so the results on the baselines are the same as in Table 4. Since there are $50000$ training data points, LAP-$50000$ corresponds to LAP acting over sources that have size $1$: i.e the standard noisy data setting.

To understand the effectiveness of our method as the number of sources grows, we extended the results in Appendix A.8 and Table 1 by significantly increasing the number of unique sources. In this experiment we see that LAP performs well across the different source sizes, demonstrating its robustness as the number of sources increases. In fact, LAP-$50000$ corresponds to an experiment where the size of each source is equal to $1$ – the standard noisy data setting. It is interesting to see that in this case LAP often performs as well or better than the baselines, suggesting its usefulness in a setting it was not originally designed for. All other experimental settings are kept the same from Table 1, with details in Appendix A.7.

These experiments take approximately $9$ hours to complete when using the compute described in Appendix A.1. This is because the results for the baselines are already calculated as part of the experiments in Appendix A.8.

### A.12 Tiny-Imagenet results

**Table 7: Tiny Imagenet results. Mean ± standard deviation of maximum test top-5 accuracy (%) over $5$ repeats of standard training and LAP on Tiny Imagenet data with noisy labels. Here, $40$ out of $100$ sources are 100% noisy.**
|  | Model Types |  |
| --- | --- | --- |
| Noise Type | Standard | LAP (Ours) |
| Original Data | 61.32 ± 0.61 | 60.62 ± 0.71 |
| Random Label | 46.27 ± 1.04 | 54.48 ± 0.57 |

In an effort to demonstrate the potential of LAP further, we evaluate our method on Tiny-Imagenet [], a subset of Imagenet that contains $100000$ images from $200$ classes. In this experiment, we wanted to test the use of LAP on larger images with larger numbers of sources. Firstly, we load the training and testing sets and randomly split the training set into $100$ sources uniformly. We then choose $40$ of the sources to be $100\%$ unreliable, and introduce noise through random labelling. This dataset is then split in the ratio $9:1$ to produce a validation set.
For this experiment, we train a ResNet 50 architecture using the baseline training method provided for Imagenet in Pytorch (^11^1111[https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/](https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/)). This trains the model for $90$ epochs with a batch size of $256$ using stochastic gradient descent with an initial learning rate of $0.1$, momentum of $0.9$, and weight decay of $0.0001$, as well as a learning rate scheduler that multiplies the learning rate by $0.1$ every $30$ epochs. A version of this model (with the same parameters) is also trained using LAP with $H=25$, $\delta=1.0$, and $\lambda=0.8$. As before, data is randomly assigned to mini-batches, with each batch containing multiple sources.

The results of this are available in Table 7 and again demonstrates the expected performance improvement when using LAP for datasets with sources of unknown noise, and the maintenance of performance when data is non-noisy.

These experiments take approximately $14$ hours to complete when using the compute described in Appendix A.1.

### A.13 Imagenet results with multiple noise types

**Table 8: Imagenet results. Mean ± standard deviation of maximum test top-5 accuracy (%) over $5$ repeats of standard training and LAP on Imagenet data with noisy labels and noisy inputs. Here, $5$ out of $10$ sources are 100% noisy, with three of them containing label noise and 2 containing input noise.**
|  | Model Types |  |
| --- | --- | --- |
| Noise Type | Standard | LAP (Ours) |
| Input and Label Noise | 68.05 ± 0.26 | 70.61 ± 0.26 |

We additionally present our results on Imagenet, which allows us to test our method on a large scale dataset. Within this experiment, as in that presented in Figure 3(a), we allow for both input and label noise. In Figure 3(a) all noisy sources contain two types of noise, however in this experiment we allow for different sources to contain different types of noise. We further observe, in Table 8, that using LAP improves model performance here, since it achieves a greater maximum top-5 test accuracy as expected.

For this experiment, we train a ResNet 50 architecture using the baseline training method provided for Imagenet in Pytorch11.
This trains the model for $90$ epochs with a batch size of $256$ using stochastic gradient descent with an initial learning rate of $0.1$, momentum of $0.9$, and weight decay of $0.0001$, as well as a learning rate scheduler that multiplies the learning rate by $0.1$ every $30$ epochs.
We split the Imagenet data into $10$ sources, of which $5$ are chosen to be noisy ($2$ containing input noise and $3$ containing label noise). Images are loaded as 8-bit integer arrays and interpolated to $(64,64)$ before input noise is synthesised by randomly adding uniform integers from [-64, 64]. They are then transformed to 32-bit floats and normalised using the mean and standard deviation available on the same Pytorch training script. Label noise is added by randomly replacing labels in noisy sources. This dataset is then split in the ratio $9:1$ to produce a validation set for the analysis in Appendix A.13.1.
A version of the ResNet 50 model (with the same parameters) is also trained using LAP with $H=25$, $\delta=1.0$, and $\lambda=0.8$. As before, data is randomly assigned to mini-batches, with each batch containing multiple sources. These experiments are repeated $5$ times for each setting.

These experiments take approximately $32$ hours to complete when using the compute described in Appendix A.1.

#### A.13.1 Late training test accuracy

**Table 9: Imagenet late training results. Mean ± standard deviation of test top-5 accuracy (%) over the last $10$ epochs of standard training and LAP on Imagenet data with noisy labels and noisy inputs, repeated $5$ times. Here, $5$ out of $10$ sources are 100% noisy, with three of them containing label noise and 2 containing input noise.**
|  | Model Types |  |
| --- | --- | --- |
| Noise Type | Standard | LAP (Ours) |
| Input and Label Noise | 42.96 ± 0.64 | 66.26 ± 0.21 |

The noisy data literature often presents model performance results on the last $x$ epochs, since in reality (as we don’t have access to clean test labels) there is no way of knowing when to stop training and reduce overfitting to noisy data. In our work, in an effort to be most fair to the standard training baseline, we present the maximum performance over all of training to ensure that we are not presenting results in which the standard training baseline has significantly overfit to the noisy data. However, in Table 9 we also present the average test accuracy over the last $10$ epochs as is often reported in the literature. These results show the significant improvement that using LAP can have on model training when it is unknown if the standard training method is overfitting to noisy data. Similarly, Figure 5 presents the training, validation, and testing performance at each epoch during the training of a neural network using the standard method and LAP. We can see that the training curves appear usual (Figure 5(a), with LAP’s training curve representing the tempered loss), and that the validation accuracy is greater for standard training (since the validation set contains noisy labels), but that when tested on the clean labels (Figure 5(c)), it is clear that using LAP enables considerably more robustness to noisy data. Early stopping could be used here to achieve the maximally achieving models (since the epoch of maximum accuracy on the test set is the same as the validation set), which is why we find it more informative to report the maximum test accuracy as presented in all other experiments.

Figure: (a) Training cross entropy loss.
Refer to caption: x6.png

### A.14 California Housing: Regression results

**Table 10: Standard and LAP results on a regression task. Mean ± standard deviation of minimum mean squared error of standard training and LAP over $5$ repeats on the California Housing dataset with different types of noise. Here, $4$ out of $10$ sources are 100% noisy. Note that “Random Label" is the only noise type with a significant difference between methods. Here, smaller is better.**
|  | Model Types |  |
| --- | --- | --- |
| Noise Type | Standard | LAP (Ours) |
| Original Data | 0.44 ± 0.02 | 0.44 ± 0.02 |
| Random Label | 0.62 ± 0.02 | 0.45 ± 0.02 |

In Table 10 we present the results of using LAP and standard training on a regression dataset in which we have $10$ total sources and $4$ that are $100\%$ noisy, with labels replaced with uniform noise (sampled between the minimum and maximum label value in the training set).

To test our method against standard training, we evaluate both on a dataset of
$20640$ samples of house values in California districts, with the goal to predict the median house value from the U.S census data for that region – a regression task. We randomly split the data into training and testing with an $8:2$ ratio for each of the $5$ runs we performed over each noise type. We train a multilayer perceptron as described in Section A.7 for $200$ epochs with a batch size of $256$, leaning rate of $0.001$ using stochastic gradient descent with momentum of $0.9$ and weight decay of $0.0001$. A version of this model (with the same parameters) is also trained using LAP with $H=25$, $\delta=1.0$, and $\lambda=0.8$. As before, data is randomly assigned to mini-batches, with each batch containing multiple sources. This was repeated $5$ times for each setting.

Table 10 shows that LAP improves the test set performance significantly over the baseline for random labelling noise and maintains performance when no noise is present. This is as expected, and again illustrates its effectiveness, but this time on a regression task.

These experiments take approximately $2$ hours to complete when using the compute described in Appendix A.1.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 2
questions: Please address the weaknesses mentioned above.
soundness: 3
strengths: * The paper is overall organized well. 
* The authors conducted extensive experiments to verify the effectiveness of their method.
summary: This paper studies learning with noisy labels in a particular setup, where the data consists of multiple sources and only some sources are noisy. The authors proposed a method called Loss Adapted Plasticity (LAP), which leverages the observation that the model training loss in the early stage of training is likely a good indicator of the label noise level of a source. They validated the effectiveness of LAP on a wide variety of datasets.
weaknesses: * The method needs further clarification. I am looking at Section 3, the first two subsections (Tempered likelihood and source reliability estimation). For the first subsection, the introduction of $f(C_s)$ as "temperature" is a little bit confusing here. From my understanding, temperature is usually used to scale the logits, while $f(C_s)$ here is more of like used to scale the NLL loss. 

* There is a similar clarification issue for the second subsection: I wasn't able to follow the "Intuitively" part (Line 149-156). It seems to me that there's something interesting going on here when the authors are discussing the behaviors of the proposed method in cases of both when no sources are noisy and there are noisy sources. However, there is no rigorous derivation that one can follow to better understand the arguments here. It's better to formalize this part a little bit as this may be important to demonstrate the advantage of the method.

* Furthermore, the "Intuitions" subsection appears to be not necessary to me. The results here are built on synthetic toy datasets such as "make_moon", which is not that sound. To me this section is more of an ablation study of the method, studying the effect of its hyperparameters. If so, it's better to move it to the experiment section and use realistic datasets to make it more sound.

* There may be some baselines missing in the experiment section. Since the main leverage of the method is the observation that model losses in the early stage can indicate noise levels, why not design very simple baselines such as removing suspected noisy sources based on training losses? Also, it would be better to include an oracle case, for example, with noisy sources directly removed. 

* Finally, I am not sure whether the studied noisy labeling case is realistic, which makes the proposed method less significant. Although the authors conducted experiments on an extensive set of datasets, all of them are at least partly hand-crafted. For example, either the noise is intentionally injected by simple label flipping (PTB-XL, GoEmotions) or the data source splits are intentionally created (CIFAR-10N). Do the authors have results on realistic data cases that are both noisy and naturally have multiple sources?

---

confidence: 4
contribution: 1
initial_rating: 3
presentation: 2
questions: Please refer to weaknesses.
soundness: 2
strengths: 1. The paper addresses the issue of how to make learning algorithms more robust when some data sources in the dataset are unreliable, which is meaningful for the application of models in real-world scenarios.

2. The experiments validate the proposed method on datasets of varying sizes, proving that the method can handle unreliable data to a certain extent.
summary: This paper addresses the challenge of training neural networks when data is sourced from multiple providers with varying levels of reliability. The authors propose a method called Loss Adapted Plasticity (LAP), which dynamically adjusts the training process based on the estimated reliability degree of each data source. The core idea is to proportionally reduce the influence of noisy sources during training, thereby protecting the model from overfitting to noisy data. The method is evaluated extensively across different datasets and noise types, demonstrating improved performance over standard training techniques.
weaknesses: 1. The method proposed in this paper is too trivial. The method uses a reweighting mechanism to control the contribution of different data sources to model training, which is essentially a special case of instance reweighting. The reweighting method proposed in this paper does not offer much novelty compared to previous work, aside from being set-wise than instance-wise.

2. The core part of the proposed method is the SOURCE RELIABILITY ESTIMATION section, which directly uses the historical outputs of the model on different data sources as a basis and employs a threshold mechanism to continuously update the reliability of data sources. This approach is not elegant, for an instance, compared to existing mechanisms such as "learn to reweigh (publish in 2018)".

3. The experimental results of this paper do not show significant superiority of the proposed method over existing methods in the standard noisy label learning setting. Moreover, the experimental setup only analyzes situations where there is noise in the data, without considering more complex forms of unreliability. Additionally, the paper only considers random noise for noisy label setup and does not address more challenging scenarios like instance-dependent noise.

---

confidence: 3
contribution: 2
initial_rating: 3
presentation: 2
questions: - How do you disentangle the label noise from problem difficulty?
- Let's say we have sources arranged in a curriculum, such that once the source learns the easiest task it is much better posed to learn the more difficult one. Can the reliability estimate increase to enable learning the next source in such 'curriculum'?
soundness: 1
strengths: The method shows reasonable empirical performance on constructed multi-source training problems.
summary: The work attempts to address the label noise by suggesting a new algorithm for accounting for different source quality: Loss Adapted Plasticity. For this the model is pretrained on all label sources early in the training with sources deemed unreliable slowly dropping off as the time progresses.
weaknesses: - The writing quality can be improved. Examples of lines which I find hard to follow: 091-098; 
- Notation could be made more consistent, e.g. in (1) $p(D\mid \theta)$ is used, then after (2) $p_{\theta}(D)$ is used. Do we need the $f(.)$?
- The method is basically tempering the losses from different sources to compute the total loss. Transformation in equation (1) is only loosely motivated. Do we really need to make the assumption? Also the assumption that neural networks achieve a lower empirical risk on clean data than noisy data in early training could be made more explicit in text.
- The update rule in (2) and the source reweighing in (3) miss motivation. 
- The comparison to source unaware methods might not be the fairest. Federated learning and sensor fusion is invoked several times but no comparison is seen. Perhaps limiting the scope would be useful.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 1
questions: 1. Could the authors provide a formal proposition that defines the task, learning objective, and relevant notations to better clarify the problem being addressed?

2. Could the authors consider a more nuanced model of data sources that accounts for varying degrees of noise, as opposed to a binary noisy/noiseless distinction, to reflect experimental conditions more accurately?

3. What assumptions about noise distribution underlie Equation 2, and through what optimization objective was this equation derived? Could the authors provide a theoretical derivation or analysis to improve clarity?
soundness: 3
strengths: 1. The learning scenario proposed in this paper is of significant practical value. The modeling of data sources here shows some parallels with domain generalization, and is a useful complement to federated learning and learning from noisy data.
2. The paper provides a comprehensive empirical analysis for the proposed algorithm, validating its performance across a wide range of applications.
summary: This paper addresses a novel Out-of-Distribution (OOD) learning scenario where learning occurs across multiple noisy data sources, focusing on discerning the reliability of these sources and learning the underlying iid data distribution. To this end, the Loss Adapted Plasticity (LAP) algorithm is introduced, which adaptively adjusts learning weights based on the reliability of the information. The proposed method is broadly applicable across various environments and noise types, without performance degradation in scenarios without unreliability.
weaknesses: 1. The main contribution of this work lies in introducing a new OOD/robust learning task. However, the problem lacks a clear mathematical formulation. While the "Motivation for New Methods" section provides an analysis and explanation of the problem, a formal proposition explicitly describing the task, learning objective, and corresponding notations would strengthen the paper.

2. The theoretical modeling of the method is somewhat simplistic. For example, in "Tempered Likelihood," data sources are modeled simply as either noisy or noiseless; however, in practice, different data sources typically contain varying degrees of noise. The mathematical model might be better represented by an IID distribution overlaid with various noise distributions of differing intensities, where noise within each data source follows the same distribution. While later experiments show that the method can indeed handle scenarios with different noise levels, the discussion in Chapter 3 is insufficiently detailed.

3. Equation 2 lacks a theoretical derivation or analysis. Under what assumptions about noise distribution was this derived, and what optimization objective led to this conclusion? Presenting it without explanation leaves it somewhat opaque to the reader. Although subsequent sentences such as "Consequently…" provide partial assumptions (e.g., NLLs), the mathematical presentation remains unclear.

4. The 0.005 value in Equation 3 is unexplained: Is it a universal value or an empirical choice for a specific task? Is this value subject to modification under different noise scenarios? While the appendix briefly discusses its role, clear criteria or rationale for selecting this value remain absent.

5. While the experimental section is extensive, the presentation is overly complex and granular, obscuring key insights. For instance, to improve clarity, a concise table summarizing key information, such as dataset descriptions, noise types, and noise intensity settings, could facilitate easier comparisons.

6. The results convincingly demonstrate the superiority of LAP over other methods, but this performance improvement seems somewhat expected given the strong alignment of the algorithm’s design with multi-source scenarios.