Version 13, last updated by abergeron at April 28, 2010 13:27 UTC

Decrease font size Decrease font size

Increase font size Increase font size

Print this page Print this page

Auto-encodeur convolutionels débruitants

Auteurs

Salah Rifai (code)

Arnaud Bergeron (paramètres et code)

 

IMPORTANT: Erreur pour les modèles à 3 couches (et plus)

Je viens d'identifier la source d'erreur pour les modèles à 3 couches ou plus.  La réduction de taille effectuée par les filtres (5x5) et le MaxPooling (2x2) combinés font qu'après trois couches il reste des images de taille 0x0, donc aucune information des exemples d'entrée.  Ce qui veut dire que tous les résultats obtenus avec 3 couches ou plus dans les expériences suivantes sont invalides.  Les expériences futures se feront avec des filtres 3x3 (sauf pour la première couche qui restera 5x5) pour éviter ce problème.

 

Tâche 1

Cette expérience fait réference au ticket: #36.

Motivation pour cette expérience.

Vérifier l'effets de certains hypers-paramètres sur la performance de test.

Modèle avec lequel on a effectué l'expérience:

Pile d'auto-encodeurs à convolution (auto-encodeurs tanh pré-entraîné par MSE) suivi d'un MLP (tanh).  Les paramètres explorés sont:

  • bsize=100
  • pretrain_lr={0.1,0.01}
  • train_lr={0.1,0.01}
  • nfilts1=4
  • nfilts2={0,4}
  • nfilts3={0,4}
  • nfilts4=0
  • pretrain_rounds={2500,5000,10000}
  • noise={0.0,0.2}
  • mlp_sz=500

Ce qu'on teste:

l'impact:

  • du taux d'apprentissage,
  • du temps de pré-entrainement,
  • du facteur de bruit et
  • du nombre de couches d'auto-encodeur.

Données utilisées: l'ensemble NIST-digits non-transformé (selon la distribution donnée par ift6266.datasets).

Résultats

Le meilleur résultat est une erreur de validation de 0.65% avec comme erreur de test 3.22%.  Il est obtenu avec les paramètres pretrain_lr=0.01, train_lr=0.1, pretrain_rounds=10000, noise=0, nfilts2=0, nfilts3=0.

L'entraînement s'est arrêté en se rendant au maximum du nombre d'étapes permises et donc pourrait bénéficier d'un plus grand nombre d'étapes.

Tous les modèles à trois couches (de 4 filtres) obtiennent excatement la même erreur de 88.9% validation, 88.7% test, donc j'ai probablement un problème dans mes paramètres.

Les autres modèles se placent entre 1.99% et 0.65% validation et 6.14% et 2.99% test.

Emplacement des résultats

  • dans la base de donnée ift6266h10_db
  • sur gershwin
  • dans les tables bergearn_csda1*
  • le SQL view (crée par la commande "jobman sqlview ...") est bergearn_cdsa1_view (j'ai fait une typo en créant la vue)

Details pour réproduire les résultats

Code utilisé:

Grappe de calcul utilisé: condor au lisa

Commandes utilisées pour lancer les jobs:

  • jobman sqlschedules postgres://ift6266h10@gershwin/ift6266h10_db/bergearn_csda1 ift6266.deep.convolutional_dae.run_exp.go <params décrits en haut>
  • dbidispatch --condor --mem=980 --repeat_jobs=72 jobman sql postgres://ift6266h10@gershwin/ift6266h10_db/bergearn_csda1 .

Temps de calcul: 72 jobs toutes terminées en environ 2h30 chacune.

 

 

 

Tâche 2

Cette expérience fait réference au ticket: #36.

Motivation pour cette expérience.

Vérifier l'effets de certains hypers-paramètres sur la performance de test.

Modèle avec lequel on a effectué l'expérience:

Pile d'auto-encodeurs à convolution suivi d'un MLP.  Les paramètres explorés sont:

  • bsize=100
  • pretrain_lr=0.01
  • train_lr={0.1,0.01,0.001}
  • nfilts1={10, 20, 30}
  • nfilts2={40,80,120}
  • nfilts3={0,80,160,240}
  • nfilts4=0
  • pretrain_rounds={10000,20000}
  • noise=0.2
  • mlp_sz=500

Ce qu'on teste:

l'impact:

  • du taux d'apprentissage,
  • du temps de pré-entrainement,
  • du nombre de couches d'auto-encodeur.

Données utilisées: l'ensemble NIST non-transformé au complet (selon la distribution donnée par ift6266.datasets).

 

Résultats

Le meilleur résultat est une erreur de validation de 11.08% avec comme erreur de test 21.18%.  Il est obtenu avec les paramètres pretrain_lr=0.01, train_lr=0.01, pretrain_rounds=20000, noise=0.2, nfilts1=20, nfilts2=120, nfilts3=0.

Tous les modèles à trois couches obtiennent excatement la même erreur de 94.88% validation, 91.94% test.  Il est possible que le learing rate du préentraînement soit en cause ou qu'il n'y a pas assez d'époques pour entrainer.  Ou alors, comme j'ai obtenu des résultats similaires avant, il est possible que trois niveaux de maxpooling détruisent trop d'information pour que le réseau qui vient après soit capable de distinguer les caractères.

Les autres modèles se placent entre 16.21% et 11.10% validation et 28.11% et 20.46% test.

Emplacement des résultats

  • dans la base de donnée ift6266h10_db
  • sur gershwin
  • dans les tables bergearn_csda2*
  • le SQL view (crée par la commande "jobman sqlview ...") est bergearn_csda2_view

    Details pour réproduire les résultats

    Code utilisé:

    Grappe de calcul utilisé: condor au lisa

    Commandes utilisées pour lancer les jobs:

    • jobman sqlschedules postgres://ift6266h10@gershwin/ift6266h10_db/bergearn_csda2 ift6266.deep.convolutional_dae.run_exp.go <params décrits en haut>
    • dbidispatch --condor --mem=980 --repeat_jobs=162 --next_job_start_delay=10 jobman sql postgres://ift6266h10@gershwin/ift6266h10_db/bergearn_csda2 .

    Temps de calcul: entre 1h et 7 jours (dépendant des paramètres de la job).  Comme point de référence, la job avec les meilleurs paramètres (donnée en haut) a pris un peu plus de 3 jours.  La médiane est autour de deux heures et la moyenne autour d'une demie journée.

     

     

     

     

    Tâche 3

    Cette expérience fait réference au ticket: #36.

    Motivation pour cette expérience.

    Vérifier l'effets de certains hypers-paramètres sur la performance de test.

    Modèle avec lequel on a effectué l'expérience:

    Pile d'auto-encodeurs à convolution suivi d'un MLP.  Les auto-encodeurs ont été modifiés pour utiliser des sigmoides avec coût de cross-entropie plutôt que des tangentes hyperboliques avec coût quadratique.

    Les paramètres explorés sont:

    • bsize=100
    • pretrain_lr={0.1,0.01,0.001}
    • train_lr=0.01
    • nfilts1=[10, 20]
    • nfilts2=[40,80]
    • nfilts3=[0,160,320]
    • nfilts4=0
    • pretrain_rounds={10000,20000,40000}
    • noise={0.0,0.2}
    • mlp_sz=500

    Ce qu'on teste:

    l'impact:

    • du taux de pré-entraînement,
    • du temps de pré-entrainement,
    • du facteur de bruit,
    • du nombre de couches d'auto-encodeur.

    Données utilisées: l'ensemble NIST non-transformé au complet (selon la distribution donnée par ift6266.datasets).

     

    Résultats

    Le meilleur résultat est une erreur de validation de 11.08% avec comme erreur de test 20.92%.  Il est obtenu avec les paramètres pretrain_lr=0.1, train_lr=0.01, pretrain_rounds=10000, noise=0.2, nfilts1=20, nfilts2=80, nfilts3=0, noise=0.2.

    Tous les modèles à trois couches obtiennent excatement la même erreur de 94.88% validation, 91.94% test. Voir l'explication en haut de la page.

    Les autres modèles se placent entre 12.19% et 11.10% validation et 23.83% et 20.64% test.

    Cinq essais à deux couches n'ont pas pu se terminer pour des raisons indéterminées.

    Emplacement des résultats

    • dans la base de donnée ift6266h10_db
    • sur gershwin
    • dans les tables bergearn_csda3*
    • le SQL view (crée par la commande "jobman sqlview ...") est bergearn_csda3_view

    Details pour réproduire les résultats

    Code utilisé:

    Grappe de calcul utilisé: condor au lisa

    Commandes utilisées pour lancer les jobs:

    • jobman sqlschedules postgres://ift6266h10@gershwin/ift6266h10_db/bergearn_csda3 ift6266.deep.convolutional_dae.run_exp.go <params décrits en haut>
    • dbidispatch --condor --mem=980 --repeat_jobs=72 --next_job_start_delay=5 jobman sql postgres://ift6266h10@gershwin/ift6266h10_db/bergearn_csda3 .

    Temps de calcul: autour de 1 semaine chaque avec un maximum de 23 jours pour la plus longue.

     

     

     

    Tâche 4

    Cette expérience fait réference au ticket: #36.

    Motivation pour cette expérience.

    Vérifier l'effets du nombre de filtres et du nombre de couches sur la performance de test.

    Modèle avec lequel on a effectué l'expérience:

    Pile d'auto-encodeurs à convolution suivi d'un MLP.  Les auto-encodeurs ont été modifiés pour utiliser des sigmoides avec coût de cross-entropie plutôt que des tangentes hyperboliques avec coût quadratique.

    Les paramètres explorés sont:

    • bsize=100
    • pretrain_lr=0.1
    • train_lr=0.01
    • nfilts1=[10, 20]
    • nfilts2=[40,80]
    • nfilts3=[0,160,320]
    • nfilts4=0
    • pretrain_rounds=20000
    • noise=0.2
    • mlp_sz=500

    Ce qu'on teste:

    l'impact:

    • du taux de pré-entraînement,
    • du temps de pré-entrainement,
    • du facteur de bruit,
    • du nombre de couches d'auto-encodeur.

    Données utilisées: l'ensemble P07 (selon la distribution donnée par ift6266.datasets)

     

    Résultats

    Le meilleur résultat est une erreur de validation de 45.26% avec comme erreur de test 47.71%.  Il est obtenu avec les paramètres nfilts1=10, nfilts2=40, nfilts3=0.

    Un des réseaux à trois couche [10, 40, 160], malgré la correction effectuée pour corriger le problème de réduction excessive de l'image, a tout de même donné une erreur de 94.83% en validation et 96.26% en test.  Après avoir obtenu ces résultats j'ai décidé de ne pas essayer l'autre combinaison de paramètres.

    Emplacement des résultats

    • dans la base de donnée ift6266h10_db
    • sur gershwin
    • dans les tables bergearn_csda4*

    Details pour réproduire les résultats

    Code utilisé:

    Grappe de calcul utilisé: gpu2 sur ceylon (lisa)

    Commandes utilisées pour lancer les jobs:

    • jobman sqlschedules postgres://ift6266h10@gershwin/ift6266h10_db/bergearn_csda4 ift6266.deep.convolutional_dae.run_exp.go <params décrits en haut>
    • THEANO_FLAGS="device=gpu2,floatX=float32" jobman sql postgres://ift6266h10@gershwin/ift6266h10_db/bergearn_csda4 . (4x en séquence dans un screen)

    Temps de calcul: environ 10 heures par job sur GPU.