Je joue un peu avec des convnets. Plus précisément, j'utilise l'ensemble de données kaggle cats-vs-dogs qui consiste en 25000 images étiquetées comme chat ou chien (12500 chacune).
J'ai réussi à atteindre une précision de classification d'environ 85% sur mon test, mais je me suis fixé comme objectif d'atteindre une précision de 90%.
Mon problème principal est le sur-ajustement. D'une manière ou d'une autre, cela finit toujours par se produire (normalement après l'époque 8-10). L'architecture de mon réseau est vaguement inspirée du VGG-16, plus précisément mes images sont redimensionnées en , puis je lance:
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)
Toutes les couches sauf la dernière ont des relus comme fonctions d'activation.
Notez que j'ai essayé différentes combinaisons de convolutions (j'ai commencé avec des convolutions plus simples).
De plus, j'ai augmenté l'ensemble de données en reflétant les images, de sorte qu'au total, j'ai 50000 images.
De plus, je normalise les images en utilisant la normalisation min max, où X est l'image
Le code est écrit en tensorflow et les tailles de lot sont 128.
Les mini-lots de données d'entraînement finissent par sur-ajuster et ont une précision de 100% tandis que les données de validation semblent cesser d'apprendre à environ 84-85%.
J'ai également essayé d'augmenter / diminuer le taux d'abandon.
L'optimiseur utilisé est AdamOptimizer avec un taux d'apprentissage de 0,0001
En ce moment, je joue avec ce problème depuis 3 semaines et 85% semblent avoir placé une barrière devant moi.
Pour mémoire, je sais que je pourrais utiliser l'apprentissage par transfert pour obtenir des résultats beaucoup plus élevés, mais je suis intéressé à construire ce réseau comme une expérience d'auto-apprentissage.
Mise à jour:
J'exécute le même réseau avec une taille de lot différente, dans ce cas, j'utilise une taille de lot beaucoup plus petite (16 au lieu de 128) jusqu'à présent, j'atteins une précision de 87,5% (au lieu de 85%). Cela dit, le réseau finit par sur-équiper de toute façon. Je ne comprends toujours pas comment un décrochage de 50% des unités n'aide pas ... évidemment, je fais quelque chose de mal ici. Des idées?
Mise à jour 2:
Il semble que le problème soit lié à la taille du lot, car avec une taille plus petite (16 au lieu de 128), j'atteins maintenant une précision de 92,8% sur mon jeu de test, avec la taille de lot plus petite, le réseau est toujours sur-adapté (les mini-lots finissent avec une précision de 100%) cependant, la perte (erreur) continue de diminuer et elle est en général plus stable. Les inconvénients sont un temps de fonctionnement BEAUCOUP plus lent, mais cela vaut vraiment la peine d'attendre.