Classificazione con etichette rumorose?

13

Sto cercando di formare una rete neurale per la classificazione, ma le etichette che ho sono piuttosto rumorose (circa il 30% delle etichette sono sbagliate).

La perdita di entropia funziona davvero, ma mi chiedevo ci sono alternative più efficaci in questo caso? o la perdita di entropia incrociata è ottimale?

Non sono sicuro, ma sto pensando di "tagliare" in qualche modo la perdita di entropia, in modo tale che la perdita per un punto dati non sia maggiore di un limite superiore, funzionerà?

Grazie!

Aggiornamento
Secondo la risposta di Lucas, ho ottenuto quanto segue per i derivati per l'output di previsione e l'input della funzione softmax . Quindi credo che essenzialmente stia aggiungendo un termine di livellamento ai derivati. Derivati per la perdita originale di entropia crociata: $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$ Per favore fatemi sapere se sbaglio. Grazie!

Aggiornamento
Mi è capitato di leggere un articolo di Google che applica la stessa formula della risposta di Lucas ma con interpretazioni diverse.

Nella sezione 7 Regolarizzazione del modello tramite levigatura dell'etichetta

Questo (la perdita di entropia crociata), tuttavia, può causare due problemi. In primo luogo, può risultare in un eccesso di adattamento: se il modello impara ad assegnare piena probabilità all'etichetta della verità di base per ciascun esempio di addestramento, non è garantito generalizzare. In secondo luogo, incoraggia le differenze tra il logit più grande e tutti gli altri a diventare grandi e questo, combinato con il gradiente limitato , riduce la capacità del modello di adattarsi. Intuitivamente, ciò accade perché il modello diventa troppo sicuro delle sue previsioni. $∂l/∂z_k$

Ma invece di aggiungere il termine smoothing alle previsioni, lo hanno aggiunto alla verità fondamentale , che si è rivelata utile.

Nei nostri esperimenti ImageNet con classi K = 1000, abbiamo usato u (k) = 1/1000 e = 0.1. Per ILSVRC 2012, abbiamo riscontrato un costante miglioramento di circa lo 0,2% assoluto sia per l'errore top-1 che per l'errore top-5. $\epsilon$

— dontloo
fonte

3

Ci sono numerosi lavori su questo argomento - github.com/subeeshvasu/Awesome-Learning-with-Label-Noise

— guest_anonym

10

La cosa giusta da fare qui è cambiare il modello, non la perdita. Il tuo obiettivo è ancora quello di classificare correttamente il maggior numero possibile di punti dati (che determina la perdita), ma i tuoi presupposti sui dati sono cambiati (che sono codificati in un modello statistico , la rete neurale in questo caso).

Sia un vettore di probabilità di classe prodotta dalla rete neurale e sia la perdita di entropia incrociata per l'etichetta . Per prendere esplicitamente in considerazione il presupposto che il 30% delle etichette siano rumorose (si presume che siano uniformemente casuali), potremmo cambiare il nostro modello per produrre $\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$

invece e ottimizza

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

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

dove è il numero di classi. Questo in realtà si comporterà in qualche modo secondo la tua intuizione, limitando la perdita per essere finita. $N$

— Lucas
fonte

In che modo è uguale a . Se prendiamo un caso di due classi, allora sarà . Allo stesso modo per . Perché termine? Grazie

{\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$

— sospetto

0

Riconosco che questo è un forum di statistiche e l'aspettativa è focalizzata sulle derivazioni matematiche, ma se può essere utile e stai usando Python, c'è un pacchetto per la classificazione con etichette rumorose chiamato cleanlab: https://github.com/ cgnorthcutt / cleanlab / .

Il cleanlabpacchetto Python pip install cleanlab, per il quale sono un autore, trova errori di etichetta nei set di dati e supporta la classificazione / apprendimento con etichette rumorose. Funziona con scikit-learn, PyTorch, Tensorflow, FastText, ecc.

Per l'apprendimento con etichette rumorose.

# 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)

Per trovare errori di etichetta nel set di dati.

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, 
)

Alcuni esempi con FastText (NLP) e PyTorch (MNIST AlexNet).

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

— cgnorthcutt
fonte