Assurer la reproductibilité avec tf.keras dans Tensorflow 2.3

introduction

Dans TensorFlow, il existe un moyen de maintenir la reproductibilité en fixant la graine comme indiqué dans l'article suivant, mais dans l'environnement GPU de TensorFlow 2.3, la fixation de la graine seule ne donnait pas le même résultat à chaque fois. (Dans Tensorflow 2.1 ou 2.0, je pense que le même résultat a été obtenu simplement en fixant la graine ...)

J'ai essayé d'exécuter la vérification d'intersection plusieurs fois et j'ai obtenu le même résultat (j'ai pu confirmer la reproductibilité), je vais donc le résumer sous forme de mémorandum. Le code source utilisé pour la vérification est publié sur Github, veuillez donc signaler toute erreur ou correction.

Conclusion

Tout d'abord, j'écrirai la conclusion, mais comme décrit dans l'article suivant, il semble que vous deviez modifier le paramètre de tf.config.threading et les variables d'environnement TF_DETERMINISTIC_OPS et TF_CUDNN_DETERMINISTIC.

Ainsi, dans TensorFlow 2.3, il semble que la reproductibilité puisse être maintenue en créant une fonction qui initialise des nombres aléatoires comme indiqué ci-dessous et en l'appelant au début du programme.


def setSeed(seed):
    os.environ['PYTHONHASHSEED'] = '0'
    
    tf.random.set_seed(seed)
    np.random.seed(seed)
    random.seed(seed)
    
    os.environ['TF_DETERMINISTIC_OPS'] = '1'
    os.environ['TF_CUDNN_DETERMINISTIC'] = '1'

    tf.config.threading.set_inter_op_parallelism_threads(1)
    tf.config.threading.set_intra_op_parallelism_threads(1)

Selon la Documentation officielle, les performances seront dégradées au détriment du traitement parallèle. Je pensais que ce serait bien de n'écrire que la conclusion, mais je me demandais si c'était vrai, alors j'ai effectué une vérification croisée et confirmé en fait si la reproductibilité était maintenue.

Code source utilisé pour la vérification

Je ne résumerai que les principaux points du code placé dans Github.

--__ main.py__: Effectuez une validation croisée (n = 10) sur l'image de formation de MNIST pour obtenir la perte et la précision de l'apprentissage 10 fois.

--Lorsque j'ai expérimenté un réseau court avec seulement une couche entièrement connectée (128 dimensions) comme couche cachée, il n'y avait pas de grande différence dans le temps de traitement, j'ai donc ajouté une couche de convolution.

--__ eval.py__: affiche la distribution moyenne et le temps de traitement à partir du fichier texte enregistré. ―― Puisque la vérification d'intersection est effectuée 10 fois, si la variance de chaque fois de la vérification d'intersection 10 est égale à 0, il est jugé que le même résultat exact = reproductibilité peut être confirmée. --main.py générera des fichiers texte, donc chargez-les.

--___ run_all.sh (pour Ubuntu) ou run_all.ps1 (pour Win) ___: Ceci est un script qui répète main.py 10 fois et exécute finalement eval.py. --Enregistrer les résultats avec reproductibilité dans with_tf_option.txt et les résultats sans reproductibilité dans without_tf_option.txt.

--__ docker-compose.yml, env / Dockerfile__: Ceci est un fichier pour Docker. (Pour Linux)

résultat de l'inspection

Cette fois, je l'ai exécuté avec TensorFlow 2.3 + Python 3.7.7 sur Windows 10. La moyenne des variances de chaque vérification de croisement (Variance) et le temps total jusqu'à ce que le prochain résultat soit enregistré (Time_diff_total) sont les suivants.

                                Variance, Time_diff_total
   results\with_tf_option.txt:     0.0,       0:17:11     #1037 secondes
results\without_tf_option.txt:  6.694e-07,    0:13:45        #825 secondes

Avec cette option, la distribution est 0, vous pouvez donc penser que le résultat de l'exécution de 10 vérifications d'intersection 10 fois était exactement le même. Cependant, si vous essayez d'assurer la reproductibilité, il faut environ 104 secondes pour atteindre le résultat suivant, et si vous rejetez la reproductibilité, il faut environ 82 secondes pour terminer le processus suivant. Puisqu'il n'y a pas de processus chronophage autre que la formation, il semble que les performances diminueront si la reproductibilité est assurée selon le document officiel.

À propos, la perte et la précision des premier et deuxième temps avec et sans l'option étaient les suivantes. (Il n'est pas nécessaire de le poster deux fois car la variance est de 0, mais je posterai le résultat brut au cas où)

#Avec options(Nombre de fois, perte, précision)
20201002-230020
0 0.041036274284124374 0.987500011920929
1 0.0490814633667469 0.9860000014305115
2 0.05664192885160446 0.9831666946411133
3 0.05320063605904579 0.9833333492279053
4 0.04623125120997429 0.9850000143051147
5 0.047372110188007355 0.984333336353302
6 0.05214701220393181 0.9850000143051147
7 0.03892550244927406 0.9858333468437195
8 0.047721363604068756 0.9851666688919067
9 0.05081837624311447 0.984499990940094
20201002-230216
0 0.041036274284124374 0.987500011920929
1 0.0490814633667469 0.9860000014305115
2 0.05664192885160446 0.9831666946411133
3 0.05320063605904579 0.9833333492279053
4 0.04623125120997429 0.9850000143051147
5 0.047372110188007355 0.984333336353302
6 0.05214701220393181 0.9850000143051147
7 0.03892550244927406 0.9858333468437195
8 0.047721363604068756 0.9851666688919067
9 0.05081837624311447 0.984499990940094

#Aucune option
20201002-231902
0 0.039828840643167496 0.9888333082199097
1 0.049601536244153976 0.9866666793823242
2 0.05240510031580925 0.9850000143051147
3 0.05293559655547142 0.9850000143051147
4 0.04633906111121178 0.9850000143051147
5 0.04794950410723686 0.9850000143051147
6 0.053883280605077744 0.9838333129882812
7 0.03880513831973076 0.987333357334137
8 0.04899284988641739 0.9850000143051147
9 0.0499492883682251 0.9851666688919067
20201002-232034
0 0.04064466059207916 0.987666666507721
1 0.04839828982949257 0.9851666688919067
2 0.055755823850631714 0.984499990940094
3 0.05341317877173424 0.9829999804496765
4 0.046509750187397 0.9856666922569275
5 0.04652954265475273 0.9853333234786987
6 0.05223047733306885 0.984666645526886
7 0.039393164217472076 0.9869999885559082
8 0.048276182264089584 0.9854999780654907
9 0.04923468455672264 0.9848333597183228

Impressions

En raison du travail sur la version supérieure de TensoFlow, j'ai eu des problèmes car je ne pouvais pas confirmer la reproductibilité, donc je suis heureux d'avoir pu le résoudre simplement en ajoutant des variables d'environnement et des paramètres d'options. J'ai expérimenté un simple réseau de neurones pour ce modèle, mais je pense qu'un réseau avec plus de couches sera utilisé dans l'environnement réel, donc je me demande dans quelle mesure le paramètre modifié cette fois affectera les performances. (Si vous en avez déjà un, faites-le moi savoir)

Histoire

2020/10/03 Ajout d'explications sur le code publié et écrit

Recommended Posts

Assurer la reproductibilité avec tf.keras dans Tensorflow 2.3
Mettre TensorFlow dans une instance P2 avec pip3
Zundokokiyoshi avec TensorFlow
Casser des blocs avec Tensorflow
Implémenter FReLU avec tf.keras
Lecture de données avec TensorFlow
Prévisions de courses de bateaux avec TensorFlow
Essayez la régression avec TensorFlow
[TensorFlow 2.x (tf.keras)] Correction de la graine aléatoire pour améliorer la reproductibilité
[TensorFlow 2 / Keras] Comment exécuter l'apprentissage avec CTC Loss dans Keras
Utilisez «% tensorflow_version 2.x» lorsque vous utilisez TPU avec Tensorflow 2.1.0 dans Colaboratory
Traduire Premiers pas avec TensorFlow
Essayez l'apprentissage en profondeur avec TensorFlow
Utiliser TensorFlow avec Intellij IDEA
Grattage au sélénium en Python
Exploitez LibreOffice avec Python
Clipping et normalisation dans TensorFlow
Grattage avec chromedriver en python
Fonction sinueuse approximative avec TensorFlow
Débogage avec pdb en Python
Gérer les sons en Python
Grattage avec du sélénium en Python
Prévision du cours de l'action avec tensorflow
Grattage avec Tor en Python
Tweet avec image en Python
Correction de la graine aléatoire avec TensorFlow
Combiné avec ordinal en Python
Essayez TensorFlow MNIST avec RNN
TensorFlow 2.X & TensorRT est la première étape pour accélérer l'inférence
Traitement de Impossible de créer un handle cudnn: CUDNN_STATUS_INTERNAL_ERROR dans Tensorflow v2.x
La gestion du tensorflow a soudainement cessé de fonctionner en utilisant le GPU dans l'apprentissage en profondeur