Overfitting della rete neurale convoluzionale. Abbandono non aiuta

Sto giocando un po 'con le convnet. In particolare, sto usando il set di dati Kaggle Gatti contro cani che consiste in 25000 immagini etichettate come gatto o cane (12500 ciascuna).

Sono riuscito a raggiungere un'accuratezza della classificazione dell'85% circa sul mio set di test, tuttavia ho fissato un obiettivo per ottenere un'accuratezza del 90%.

Il mio problema principale è l'adattamento eccessivo. In qualche modo finisce sempre per succedere (normalmente dopo l'8-10). L'architettura della mia rete è liberamente ispirata a VGG-16, in particolare le mie immagini vengono ridimensionate a $128x128x3$ , quindi eseguo:

Convolution 1 128x128x32 (kernel size is 3, strides is 1)
Convolution 2 128x128x32 (kernel size is 3, strides is 1)
Max pool    1 64x64x32   (kernel size is 2, strides is 2)
Convolution 3 64x64x64   (kernel size is 3, strides is 1)
Convolution 4 64x64x64   (kernel size is 3, strides is 1)
Max pool    2 32x32x64   (kernel size is 2, strides is 2)
Convolution 5 16x16x128  (kernel size is 3, strides is 1)
Convolution 6 16x16x128  (kernel size is 3, strides is 1)
Max pool    3 8x8x128    (kernel size is 2, strides is 2)
Convolution 7 8x8x256    (kernel size is 3, strides is 1)
Max pool    4 4x4x256    (kernel size is 2, strides is 2)
Convolution 8 4x4x512    (kernel size is 3, strides is 1)
Fully connected layer 1024 (dropout 0.5)
Fully connected layer 1024 (dropout 0.5)

Tutti i livelli eccetto l'ultimo hanno relus come funzioni di attivazione.

Nota che ho provato diverse combinazioni di convoluzioni (ho iniziato con convoluzioni più semplici).

Inoltre, ho aumentato il set di dati rispecchiando le immagini, in modo da avere in totale 50000 immagini.

Inoltre, sto normalizzando le immagini usando la normalizzazione minima massima, dove X è l'immagine

$X = X - 0 / 255 - 0$

Il codice è scritto in tensorflow e le dimensioni del lotto sono 128.

I mini-batch di dati di allenamento finiscono per sovrautilizzare e avere una precisione del 100% mentre i dati di validazione sembrano smettere di apprendere all'84-85% circa.

Ho anche provato ad aumentare / diminuire il tasso di abbandono.

L'ottimizzatore utilizzato è AdamOptimizer con un tasso di apprendimento di 0,0001

Al momento ho giocato a questo problema nelle ultime 3 settimane e l'85% sembra aver fissato una barriera davanti a me.

Per la cronaca, so che potrei usare l'apprendimento di trasferimento per ottenere risultati molto più alti, ma sono interessante costruire questa rete come esperienza di autoapprendimento.

Aggiornare:

Sto gestendo la rete SAME con una dimensione batch diversa, in questo caso sto utilizzando una dimensione batch molto più piccola (16 invece di 128) e sto raggiungendo una precisione dell'87,5% (invece dell'85%). Detto questo, la rete finisce comunque con un overfitting. Ancora non capisco come un abbandono del 50% delle unità non sia d'aiuto ... ovviamente sto facendo qualcosa di sbagliato qui. Qualche idea?

Aggiornamento 2:

Sembra che il problema abbia a che fare con la dimensione del lotto, come con una dimensione più piccola (16 invece di 128) Sto raggiungendo ora un'accuratezza del 92,8% sul mio set di test, con le dimensioni del lotto più piccole che la rete si adatta ancora (i mini lotti finiscono con un'accuratezza del 100%), tuttavia, la perdita (errore) continua a diminuire ed è generalmente più stabile. I contro sono molto più lenti, ma vale la pena aspettare.

Ok, quindi dopo molte sperimentazioni sono riuscito a ottenere alcuni risultati / approfondimenti.

In primo luogo, a parità di condizioni, i lotti più piccoli nel set di training aiutano molto al fine di aumentare le prestazioni generali della rete, in quanto lato negativo, il processo di training è molto più lento.

Secondo punto, i dati sono importanti, niente di nuovo qui, ma come ho imparato combattendo questo problema, più dati sembrano sempre aiutare un po '.

Terzo punto, il dropout è utile nelle reti di grandi dimensioni con molti dati e molte iterazioni, nella mia rete ho applicato il dropout solo sui livelli finali completamente collegati, i layer di convoluzione non sono stati applicati.

Quarto punto (e questo è qualcosa che sto imparando ancora e ancora): le reti neurali richiedono MOLTO allenamento, anche su buone GPU (ho addestrato questa rete su floydhub, che utilizza carte NVIDIA piuttosto costose), quindi la PAZIENZA è la chiave .

Conclusione finale: le dimensioni dei lotti sono più importanti di quanto si possa pensare, apparentemente è più facile raggiungere un minimo locale quando i lotti sono più grandi.

Il codice che ho scritto è disponibile come un notebook Python, penso che sia decentemente documentato

https://github.com/moriano/loco-learning/blob/master/cats-vs-dogs/cats-vs-dogs.ipynb

Ti suggerisco di analizzare i grafici di apprendimento della tua precisione di validazione come suggerito da Neil Slater. Quindi, se la precisione della convalida diminuisce, prova a ridurre le dimensioni della tua rete (sembra troppo profonda), aggiungi dropout ai livelli CONV e BatchNormalization dopo ogni livello. Può aiutare a sbarazzarsi del sovradimensionamento e aumentare la precisione del test.

Esistono diverse soluzioni possibili per il tuo problema.

1. Usa Dropout anche nei livelli precedenti (livelli convoluzionali).

2. La tua rete sembra in qualche modo abbastanza grande per un compito così "facile"; prova a ridurlo. Le grandi architetture sono anche addestrate su set di dati molto più grandi.

Se vuoi mantenere la tua "grande" architettura prova:

3. Aumento dell'immagine per aumentare virtualmente i dati di allenamento

4. Prova l'allenamento contraddittorio. A volte aiuta.

Una cosa che non è stata ancora menzionata e che puoi prendere in considerazione per il futuro: puoi ancora aumentare il tuo abbandono a livelli completamente connessi.

Una volta ho letto un documento che utilizzava un tasso di abbandono del 90%. Sebbene avesse molti nodi (2048 se ricordo bene), l'ho provato io stesso su livelli con meno nodi ed è stato molto utile in alcuni casi.

Ho appena cercato quale carta fosse. Non riesco a ricordare quale documento ho appena ricordato, ma ho trovato questi che hanno avuto un certo successo con tassi di abbandono del 90%.

Karpathy, A., Toderici, G., Shetty, S., Leung, T., Sukthankar, R., e Fei-Fei, L. (2014). Classificazione video su larga scala con reti neurali convoluzionali. Negli atti della conferenza IEEE su Computer Vision e Pattern Recognition (pagg. 1725-1732).

Simonyan, K. e Zisserman, A. (2014). Reti convoluzionali a due flussi per il riconoscimento dell'azione nei video. In Progressi nei sistemi di elaborazione delle informazioni neurali (pagg. 568-576).

Varol, G., Laptev, I., & Schmid, C. (2017). Convoluzioni temporali a lungo termine per il riconoscimento dell'azione. Transazioni IEEE sull'analisi dei modelli e sull'intelligenza artificiale.

Ho avuto anche questo problema. Dopo averlo usato per ore, per caso ho deciso di mescolare i dati prima di inserirli nel sistema e voilà, ha iniziato a funzionare. Mi ci è voluto un po 'per capire che è stato lo shuffle a fare il trucco! Spero che questo salvi qualcuno dalla frustrazione!