Classification avec des étiquettes bruyantes?

13

J'essaie de former un réseau de neurones pour la classification, mais les étiquettes que j'ai sont plutôt bruyantes (environ 30% des étiquettes sont fausses).

La perte d'entropie croisée fonctionne en effet, mais je me demandais s'il existe des alternatives plus efficaces dans ce cas? ou la perte d'entropie croisée est-elle optimale?

Je ne suis pas sûr, mais je pense à "couper" quelque peu la perte d'entropie croisée, de sorte que la perte pour un point de données ne soit pas supérieure à une limite supérieure, cela fonctionnera-t-il?

Merci!

Mise
à jour Selon la réponse de Lucas, j'ai obtenu ce qui suit pour les dérivées pour la sortie de prédiction et l'entrée de la fonction softmax . Donc, je suppose qu'il s'agit essentiellement d'ajouter un terme de lissage aux dérivés. Dérivés pour la perte d'entropie croisée d'origine: $y$ $z$ $\frac{3}{7N}$

p_{i} = 0.3 / N + 0.7 y_{i}

$p_i=0.3/N+0.7y_i$

l = - \sum t_{i} \log (p_{i})

$l=-\sum t_i\log(p_i)$

\frac{\partial l}{\partial y_{i}} = - t_{i} \frac{\partial \log (p_{i})}{\partial p_{i}} \frac{\partial p_{i}}{\partial y_{i}} = - 0.7 \frac{t_{i}}{p_{i}} = - \frac{t_{i}}{\frac{3}{7 N} + y_{i}}

$\frac{\partial l}{\partial y_i}=-t_i\frac{\partial\log(p_i)}{\partial p_i}\frac{\partial p_i}{\partial y_i}=-0.7\frac{t_i}{p_i}=-\frac{t_i}{\frac{3}{7N}+y_i}$

\frac{\partial l}{\partial z_{i}} = 0.7 \sum_{j} \frac{t_{j}}{p_{j}} \frac{\partial y_{j}}{\partial z_{i}} = y_{i} \sum_{j} t_{j} \frac{y_{j}}{\frac{3}{7 N} + y_{j}} - t_{i} \frac{y_{i}}{\frac{3}{7 N} + y_{i}}

$\frac{\partial l}{\partial z_i}=0.7\sum_j\frac{t_j}{p_j}\frac{\partial y_j}{\partial z_i}=y_i\sum_jt_j\frac{y_j}{\frac{3}{7N}+y_j}-t_i\frac{y_i}{\frac{3}{7N}+y_i}$

\frac{\partial l}{\partial y_{i}} = - \frac{t_{i}}{y_{i}}

$\frac{\partial l}{\partial y_i}=-\frac{t_i}{y_i}$

\frac{\partial l}{\partial z_{i}} = y_{i} - t_{i}

$\frac{\partial l}{\partial z_i}=y_i-t_i$ Veuillez me faire savoir si je me trompe. Merci!

Mise à jour
Je viens de lire un article de Google qui applique la même formule que dans la réponse de Lucas mais avec des interprétations différentes.

Dans la section 7 Régularisation du modèle via le lissage des étiquettes

Cela (la perte d'entropie croisée), cependant, peut causer deux problèmes. Tout d'abord, cela peut entraîner un sur-ajustement: si le modèle apprend à attribuer une probabilité totale à l'étiquette de vérité du terrain pour chaque exemple de formation, il n'est pas garanti de généraliser. Deuxièmement, il encourage les différences entre le plus grand logit et tous les autres à devenir grandes, ce qui, combiné au gradient borné , réduit la capacité du modèle à s'adapter. Intuitivement, cela se produit parce que le modèle devient trop confiant sur ses prédictions. $∂l/∂z_k$

Mais au lieu d'ajouter le terme de lissage aux prédictions, ils l'ont ajouté à la vérité fondamentale , ce qui s'est avéré utile.

Dans nos expériences ImageNet avec K = 1000 classes, nous avons utilisé u (k) = 1/1000 et = 0,1. Pour ILSVRC 2012, nous avons constaté une amélioration constante d'environ 0,2% absolu à la fois pour l'erreur top-1 et l'erreur top-5. $\epsilon$

— dontloo
source

3

Il existe de nombreux ouvrages sur ce sujet - github.com/subeeshvasu/Awesome-Learning-with-Label-Noise

— guest_anonym

10

La bonne chose à faire ici est de changer le modèle, pas la perte. Votre objectif est toujours de classer correctement autant de points de données que possible (ce qui détermine la perte), mais vos hypothèses sur les données ont changé (qui sont encodées dans un modèle statistique , le réseau neuronal dans ce cas).

Soit un vecteur de probabilités de classe produites par le réseau neuronal et la perte d'entropie croisée pour l'étiquette . Pour prendre explicitement en compte l'hypothèse que 30% des étiquettes sont du bruit (supposé uniformément aléatoire), nous pourrions changer notre modèle pour produire $\mathbf{p}_t$ $\ell(y_t, \mathbf{p}_t)$ $y_t$

{\tilde{p}}_{t} = 0.3 / N + 0.7 p_{t}

$\mathbf{\tilde p}_t = 0.3/N + 0.7 \mathbf{p}_t$

à la place et optimiser

\sum_{t} ℓ (y_{t}, 0.3 / N + 0.7 p_{t}),

$\sum_t \ell(y_t, 0.3/N + 0.7 \mathbf{p}_t),$

où est le nombre de classes. Cela se comportera en fait quelque peu selon votre intuition, limitant la perte à être finie. $N$

— Lucas
source

Comment est est égal à . Si nous prenons deux cas de classe, alors sera . De même pour . Pourquoi terme? Merci

{\tilde{p}}_{t}

$\tilde{p}_t$

0.3 / N + 0.7 p_{t}

$0.3/N +0.7p_t$

{\tilde{p}}_{t}

$\tilde{p}_t$

P r o b (\tilde{y} = + 1 | t) = 0.7 P r o b (y = + 1 | t) + 0.3 P r o b (y = - 1 | t)

$Prob(\tilde{y} = +1|t) = 0.7Prob(y=+1|t) + 0.3Prob(y = -1|t)$

P r o b (\tilde{y} = - 1 | t) = 0.7 P r o b (y = - 1 | t) + 0.3 P r o b (y = + 1 | t)

$Prob(\tilde{y} = -1|t) = 0.7Prob(y=-1|t) + 0.3Prob(y = +1|t)$

1 / N

$1/N$

— intuition

0

Je reconnais qu'il s'agit d'un forum de statistiques et que l'attente est axée sur les dérivations mathématiques, mais si cela peut être utile et que vous utilisez Python, il existe un package de classification avec des étiquettes bruyantes appelé cleanlab: https://github.com/ cgnorthcutt / cleanlab / .

Le cleanlabpackage Python, pip install cleanlabdont je suis l'auteur, trouve des erreurs d'étiquette dans les jeux de données et prend en charge la classification / l'apprentissage avec des étiquettes bruyantes. Il fonctionne avec scikit-learn, PyTorch, Tensorflow, FastText, etc.

Pour apprendre avec des étiquettes bruyantes.

# Code taken from https://github.com/cgnorthcutt/cleanlab
from cleanlab.classification import LearningWithNoisyLabels
from sklearn.linear_model import LogisticRegression

# Learning with noisy labels in 3 lines of code.

# Wrap around any classifier. Works with sklearn/pyTorch/Tensorflow/FastText/etc.
lnl = LearningWithNoisyLabels(clf=LogisticRegression())
lnl.fit(X = X_train_data, s = train_noisy_labels)
# Estimate the predictions you would have gotten by training with *no* label errors.
predicted_test_labels = lnl.predict(X_test)

Pour rechercher des erreurs d'étiquette dans votre jeu de données.

from cleanlab.latent_estimation import estimate_cv_predicted_probabilities

# Find the indices of label errors in 2 lines of code.

probabilities = estimate_cv_predicted_probabilities(
    X_train_data, 
    train_noisy_labels, 
    clf=LogisticRegression(),
)
label_error_indices = get_noise_indices(
    s = train_noisy_labels, 
    psx = probabilities, 
)

Quelques exemples avec FastText (NLP) et PyTorch (MNIST AlexNet).

Documentation: https://l7.curtisnorthcutt.com/cleanlab-python-package

— cgnorthcutt
source