Problèmes de sur-ajustement pour le modèle de points clés (détection des poignets, des coudes, des épaules, etc.)

Question

Je suis en train de construire un modèle pour détecter les points-clés des parties du corps. Pour ce faire, j'utilise le jeu de données COCO (http://cocodataset.org/#download). J'essaie de comprendre pourquoi je suis confronté à des problèmes de surenchère (les pertes d'entraînement convergent, mais j'atteins un plafond très tôt pour tester la perte). Dans le modèle, j'ai essayé d'ajouter des couches d'abandon (en ajoutant graduellement plus de couches avec des probabilités plus élevées, mais j'arrive rapidement à un point où la perte d'entraînement cesse de diminuer, ce qui est tout aussi mauvais.) Ma théorie est que le modèle que j'utilise n'est pas t assez complexe mais je voudrais savoir si c'est la raison probable ou si elle pourrait être quelque chose d'autre. les modèles que j'ai trouvé en ligne sont tous très profondes (plus de 30 couches).

données

J'utilise 10 000 images RGB, chacune avec une seule personne, chacune avec des tailles différentes mais une longueur et une largeur maximales de 640. Comme étape de prétraitement, je crée chaque image de la taille 640x640 en remplissant toute zone supplémentaire (bas et à droite de l'image) avec (0,0,0) ou noir.

Cibles

L'ensemble de données complet a beaucoup de points clés, mais je suis seulement intéressé par l'épaule droite, le coude droit et au poignet droit. Chaque partie du corps a 2 points-clés (coordonnées X et coordonnée Y) donc ma cible est une liste de longueur 6.

Modèle

activation_function = 'relu' 
batch_size = 16 # ## 
epoch_count = 40 # ## 
loss_function = 'mean_squared_error' 
opt = 'adam' 

model = Sequential() 
model.add(Conv2D(filters=16, kernel_size=(3, 3), input_shape=inp_shape)) 
# model.add(Conv2D(filters=16, kernel_size=(3, 3))) 
model.add(MaxPooling2D(pool_size=(2, 2))) 
model.add(Conv2D(filters=32, kernel_size=(3, 3))) 
# model.add(Conv2D(filters=32, kernel_size=(3, 3))) 
model.add(MaxPooling2D(pool_size=(2, 2))) 
model.add(Flatten()) 
model.add(Dense(300, activation=activation_function)) 
model.add(Dropout(rate=0.1)) 
model.add(Dense(300, activation=activation_function)) 
model.add(Dense(num_targets)) 
model.summary() 
model.compile(loss=loss_function, optimizer=opt) 
hist = model.fit(x_train, y_train, batch_size=batch_size, epochs=epoch_count, 
       verbose=verbose_level, 
       validation_data=(x_valid, y_valid)) 

Answer 1

Votre théorie

le modèle que j'utilise ISN c'est assez complexe

c'est une bonne théorie, le modèle est assez simple et étant donné que nous ne savons pas exactement combien overfitting souffrez-vous il semble possible que le surajustement est en raison de la complexité du modèle.

Dans le modèle, je l'ai essayé d'ajouter des couches de décrochage scolaire

Peut-être un moyen simple mais efficace de rendre le modèle un peu plus complexe, mais de plus, je augmenter le décrochage scolaire taux. Il semble que vous ayez une perte de 0.1, essayez 0.5 par exemple et comparez si le surajustement diminue.

Quoi qu'il en soit, je pense que le mieux que vous pouvez essayer est incrémenter la complexité du modèle, mais dans la partie de convolution , non seulement ajouter Dense couches après la Aplatir. Si cela vous semble difficile, je vous suggère de trouver des architectures générales préconstruites pour les réseaux de neurones convolutionnels pour la reconnaissance d'image ou encore des constructions plus spécifiques pour des problèmes similaires aux vôtres.

Dites nous comment ça marche!

Answer 2

Outre déjà dit dans les réponses:

• Vous pouvez avoir plusieurs couches Dropout avec des probabilités différentes, par exemple après les couches de regroupement. Les premières couches ont souvent une probabilité de conservation plus élevée, car elles utilisent moins de filtres.
• Image data augmentationImage data augmentation est une autre façon de généraliser et dans mon expérience, il améliore toujours le résultat, au moins légèrement (bien sûr, à condition que la transformation d'entrée n'est pas sévère). (Et ses successeurs, weight normalization et layer normalization) est une méthode de régularisation moderne qui réduit l'intensité de chute requise, parfois complètement, c'est-à-dire que vous pouvez vous débarrasser des couches de suppression. En outre, batchnorm améliore les statistiques d'activation, ce qui accélère souvent l'apprentissage du réseau. Je l'ai utilisé en plus de l'abandon et ça a plutôt bien marché.
• Une technique appelée unités linéaires exponentielles mises à l'échelle (SELU) a été published very recently, qui aurait des propriétés d'auto-normalisation implicites. C'est même already implemented en keras.
• Le bon vieux régularisateur L2 ou L1 est toujours utilisé. Si rien d'autre ne vous aide, envisagez de l'ajouter aussi. Mais je suis à peu près sûr que batchnorm, selu et quelques couches de drop-out suffiront.