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.
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.
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.
La configuration du réseau est la suivante. La taille d'image MNIST 28 est entrée en largeur et en hauteur.
```python
def loadModel(width, height):
layer_input = Input(shape=(width, height))
layers_hidden = Reshape(target_shape=(width, height, 1))(layer_input)
layers_hidden = Conv2D(filters=8, kernel_size=(3, 3), strides=1, activation="relu")(layers_hidden)
layers_hidden = MaxPooling2D(pool_size=(2,2), strides=(2,2))(layers_hidden)
layers_hidden = Conv2D(filters=8, kernel_size=(3, 3), strides=1, activation="relu")(layers_hidden)
layers_hidden = MaxPooling2D(pool_size=(2,2), strides=(2,2))(layers_hidden)
layers_hidden = Flatten()(layers_hidden)
layers_hidden = Dense(128, activation="relu")(layers_hidden)
layers_hidden = Dropout(0.2)(layers_hidden)
layer_output = Dense(10, activation="softmax")(layers_hidden)
return Model(inputs=layer_input, outputs=layer_output)
```
--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.
Puisque le texte est enregistré comme premier temps de sauvegarde, le résultat de la première vérification des 10 intersections, le deuxième temps de sauvegarde, le deuxième ... (voir les résultats), le temps et le résultat après lecture de chaque ligne Est mis dans une liste séparée pour afficher la distribution et le temps de traitement.
def getResults(path_result, n_splits, num_train):
with open(path_result, "r") as f:
lines = f.readlines()
results = []
dates = []
for line in lines:
l = line.splitlines()[0].split()
if len(l) != 1:
results.append(l)
else:
dates.append(datetime.strptime(l[0], "%Y%m%d-%H%M%S"))
results = np.array(results).astype(np.float64)
results = np.reshape(results, newshape=(num_train, n_splits, 3))
var = np.mean(np.var(results[:,:,1:], axis=0))
diff_time_total = np.sum([dates[i + 1] - dates[i] for i in range(0, num_train-1)])
print(f"{path_result}: {var:.4}, {diff_time_total}")
return
getResults(path_result=os.path.join("results", "with_tf_option.txt"), n_splits=10, num_train=10)
(Pour la dispersion, la perte et la précision ont été moyennées (np.mean), mais il était préférable de les séparer.) --__ Note) Ce n'est pas l'heure exacte du temps d'apprentissage car c'est le temps total pour enregistrer le résultat en .txt et le résultat suivant en .txt __
--___ 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)
export UID avant l'exécutionCette 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
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)
2020/10/03 Ajout d'explications sur le code publié et écrit
Recommended Posts