REVUE DE l'apprentissage de la machine à papier est ingénieur Google Chris Rawles écrit par un blog technique, la formation sur la façon discute d'utiliser la profondeur du lot et tf.keras tensorflow Normalization accélèrent le réseau de neurones. Nous savons que la profondeur du réseau de neurones est généralement très complexe, même dans la bénédiction du GPU actuelle en matière de performance élevé, afin de former rapidement la profondeur du réseau de neurones est toujours pas facile. Lot pourrait être une normalisation bonne méthode d'accélération, cet article décrit comment il peut aider à résoudre la disparition des gradients et problème d'explosion gradient, et discute activation Relu et d'autres fonctions d'activation pour rôle de gradient disparaissant offset. Enfin, utilisez tensorflow et tf.keras réalisé par lots sur MNIST Normalization, aide à approfondir la compréhension du lecteur.
Comment utiliser Batch avec tensorflow et Normalization tf.keras pour former plus rapidement des réseaux de neurones profonds
la formation approfondie du réseau de neurones peut être très chronophage. Mais peut être considérablement réduite en éliminant le temps de formation de gradient, cela se produit parce que le réseau de gradient (en particulier au début de la couche de gradient) proche de zéro et arrête la mise à jour. initialisation Xavier combiné du poids et de l'activation RELU aider à compenser le problème de gradient disparaissent. Ces technologies contribuent également à résoudre le problème de contraste de gradient d'explosion, dans ce cas, le gradient devient très important, il empêche la mise à jour du modèle.
lot de normalisation (lot Normaliser) est peut-être le plus puissant outil Tiduo disparaître et les problèmes explosifs à traiter. la standardisation des lots fonctionne comme suit: Pour une couche donnée dans chaque cellule, z-score est d'abord calculé, puis formé en deux variables ß et l'application d'une transformation linéaire. La normalisation est généralement complété par lots (voir ci-dessous) avant que la fonction d'activation non linéaire, mais l'application peut également être lots standards avantageux après la fonction d'activation. Vérifiez ce séminaire pour apprendre plus de détails sur la façon dont la technologie fonctionne.
Dans le processus de retour à la propagation, les gradients ont tendance à devenir plus petits dans la couche inférieure afin de ralentir la mise à jour de poids et donc de réduire les temps de formation. normalisation par lots permet d'éliminer le gradient disparaissant soi-disant.
normalisation des lots peut être réalisé de trois façons tensorflow en. utilisation:
1. tf.keras.layers.BatchNormalization
2. tf.layers.batch_normalization
3. tf.nn.batch_normalization
tf.keras font partie de ce module de base de la version 1.4 API tensorflow. Et fournir une API de haut niveau pour la construction de modèle tensorflow, donc je vais vous dire comment faire en Keras. fonction tf.layers.batch_normalization ont des fonctions similaires, mais Keras avéré être une fonction de modèle préparé d'une manière plus simple tensorflow.
in_training_mode = tf.placeholder (tf.bool) cachés = tf.keras.layers.Dense (n_units, activation = Aucun) (X) # pas de fonction d'activation, encore batch_normed = tf.keras.layers.BatchNormalization () (masqué, = formation in_training_mode) output = tf.keras.activations \ .relu (batch_normed) # Relu est généralement effectuée après la normalisation des lots # Code Optimizer ici ... extra_ops = tf.get_collection (tf.GraphKeys.UPDATE_OPS) avec tf.control_dependencies (extra_ops): train_op = optimizer.minimize (perte)Notez que la fonction de formation normalisée à volume variable. Cela est nécessaire parce que les différents lots standardisés fonctionnement et étape de la demande pendant la formation. Au cours de la formation, le score z est calculé en utilisant la moyenne et la variance du lot, et l'inférence, on estime en utilisant la moyenne et la variance calculée à partir de l'ensemble d'apprentissage.
En tensorflow, les quantités normalisées peuvent être utilisées comme une couche supplémentaire de tf.keras.layers mis en uvre.
Tf.GraphKeys.UPDATE_OPS comprenant un second bloc de code est important. Pour chaque cellule dans le réseau, en utilisant tf.keras.layers.BatchNormalization, tensorflow continuera à réestimer le droit de jeu de données de formation sur la moyenne et la variance. Ces valeurs sont stockées pour le temps de prédiction des applications en vrac normalisé. La formation mis en moyenne et la variance de chaque unité peut être considérée par extra_ops impression, extra_ops couches, chacune d'une liste du réseau:
imprimer (extra_ops)Bien que la normalisation peut également être utilisé dans le lot tf.nn module, mais il nécessite des enregistrements supplémentaires nécessaires pour les paramètres moyenne et la variance de la fonction. Par conséquent, l'utilisateur doit calculer manuellement la moyenne et la variance du niveau de charge et le niveau de jeu de formation. Par conséquent, il est inférieur ou niveau d'abstraction tf.layers de tf.keras.layers, tf.nn mise en uvre doit être évitée.
normalisation des lots sur MNIST
Maintenant, j'utilise tensorflow en vrac MNIST importante demande normalisée à un ensemble de données. Regardez le code ici. MNIST est facile à analyser un ensemble de données, ne pas besoin de beaucoup de couches peuvent obtenir une erreur de classification inférieure. Cependant, nous pouvons encore construire la profondeur du réseau et observer comment la convergence standardisée par lots.
Nous utilisons tf.estimator API pour construire estimateur personnalisé. D'abord, nous construisons le modèle:
def dnn_custom_estimator (caractéristiques, des étiquettes, des attributs, params): in_training = mode == tf.estimator.ModeKeys.TRAIN use_batch_norm = params net = tf.feature_column.input_layer (caractéristiques, params ) pour i, n_units à énumérer (params ): net = build_fully_connected (net, n_units = n_units, formation = in_training, batch_normalization = use_batch_norm, activation = params , name = 'hidden_layer' + str (i)) logits = output_layer (net, 10, batch_normalization = use_batch_norm, formation = in_training) predicted_classes = tf.argmax (logits, 1) = perte tf.losses.softmax_cross_entropy (onehot_labels = étiquettes, logits = logits) précision = tf.metrics.accuracy (étiquettes = tf.argmax (étiquettes, 1), prédictions = predicted_classes, name = 'acc_op') tf.summary.scalar ( 'précision', précision ) # pour visualiser en TensorBoard si le mode de tf.estimator.ModeKeys.EVAL: retour tf.estimator.EstimatorSpec (mode, perte = perte, eval_metric_ops = { 'précision': précision}) # Création op de formation. Mode assert == tf.estimator.ModeKeys.TRAIN extra_ops = tf.get_collection (tf.GraphKeys.UPDATE_OPS) optimiseur = tf.train.AdamOptimizer (learning_rate = params ) avec tf.control_dependencies (extra_ops): train_op = optimizer.minimize (perte, global_step = tf.train.get_global_step ()) retour tf.estimator.EstimatorSpec (mode, la perte = perte, train_op = train_op)Après nous définissons la fonction de modèle, bâtissons un estimateur personnalisé et le train et évaluer notre modèle:
def train_and_evaluate (output_dir): caractéristiques = classificateur = tf.estimator.Estimator (model_fn = dnn_custom_estimator, model_dir = output_dir, params = { 'caractéristiques': caractéristiques, 'Batch_norm': USE_BATCH_NORMALIZATION, 'Activation': ACTIVATION, 'Hidden_units': HIDDEN_UNITS, 'Learning_rate': LEARNING_RATE}) train_spec = tf.estimator.TrainSpec (input_fn = train_input_fn, max_steps = NUM_STEPS) eval_spec = tf.estimator.EvalSpec (input_fn = eval_input_fn) tf.estimator.train_and_evaluate (classificateur, train_spec, eval_spec) train_and_evaluate ( 'mnist_model')test Let comment l'impact du modèle de normalisation des lots à différentes profondeurs. Après notre paquet de code paquet python, nous pouvons utiliser ML-Cloud Engine exécution en parallèle de multiples expériences:
# Def ml moteur fonction submitMLEngineJob () { emploi gcloud ml-moteur $ NOMTACHE formation submit \ --package-path = $ (PWD) / mnist_classifier / formateur \ --module nom trainer.task \ --region $ REGION \ --staging seau = gs: // $ SEAU \ --scale-tier = BASE \ --runtime-version = 1,4 \ - \ --outdir $ OUTDIR \ --hidden_units $ net \ --num_steps 1000 \ $ BatchNorm } # lancer des travaux en parallèle export PYTHONPATH = $ {PYTHONPATH}: $ {} PWD / mnist_classifier pour batchNorm dans « » « --use_batch_normalization » faire net = '' pour la couche en 5004003002001005025; faire net = $ net couche $ netname = $ {// net, / _ $ {} batchNorm / - use_batch_normalization / _bn} JOBNAME = mnist $ _ $ netname (date -u +% y% m% d_% H% M% S) OUTDIR = gs: // $ {} SEAU / mnist_models / mnist_model $ netname / trained_model echo $ OUTDIR $ RÉGION $ NOMTACHE gsutil -m rm -rf $ OUTDIR submitMLEngineJob net = $ net, fini finiLe montre la figure ci-dessous de 90% du nombre d'itérations de formation nécessaires précision (taille du lot 1500 itératifs) atteint de. De toute évidence, la normalisation en vrac accélérer considérablement la formation de la profondeur du réseau. S'il n'y a pas de normalisation par lots, avec l'augmentation de chaque couche suivante, il augmentera le nombre d'étapes de formation, mais après l'avoir utilisé, le nombre d'étapes de formation est restée pratiquement inchangée. Dans la pratique, il est beaucoup plus difficile ensemble des données, une condition sine qua non pour le succès lorsque plusieurs couches de structure de réseau.
S'il n'y a pas de lot standardisé, jusqu'à 90% le nombre exact d'itérations de formation requis augmente avec le nombre de couches augmente, cela peut être dû au gradient a provoqué la disparition.
En outre, comme représenté, le réseau ayant une couche cachée 7 est entièrement connecté, il n'y a pas de charge normalisés temps de convergence lente
l'utilisation expérimentale de l'activation classique décrit ci-dessus RELU. Bien que pas comme ci-dessus résister aux effets provoqués par la disparition du gradient montré, Relu que l'activation sigmoïde ou la fonction d'activation tanh beaucoup mieux. fonction d'activation sigmoïde du gradient disparaît très faible. Lorsque la plus grande valeur (positive ou négative extrêmement), la dérivée de la fonction sigmoïde « de saturation » de la fonction S-forme qui est proche de zéro. De plus en plus saturés noeuds, ce qui réduit le nombre de mises à jour, la formation d'arrêt du réseau.
En utilisant la fonction d'activation sigmoïde sans l'utilisation de la normalisation des lots, la même formation de réseau à sept couches freinera considérablement. Lors de l'utilisation normalisation des lots, le nombre d'itérations lors de l'utilisation convergence des réseaux Relu est atteint similaire.
D'autre part, d'autres fonctions d'activation (tels que l'indice Relu ou une fuite fonction Relu) peuvent aider à résister à la pente disparait problème, car ils sont tous deux nombres positifs et négatifs avec un dérivé non nul.
Enfin, il est important de noter que la formation en vrac normalisé donnera les coûts de temps supplémentaire. Bien que la normalisation des lots réduit généralement le nombre d'étapes pour parvenir à la convergence de la formation, mais il vous en coûtera plus de temps, car il introduit des opérations supplémentaires, et a également donné chaque unité présente deux nouveaux paramètres de formation.
Pour le classement MNIST (en utilisant 1080 GPU GTX), la normalisation des lots peut convergent vers moins d'itérations, mais à chaque fois d'itération est plus lente. Le lot final version normalisée de la vitesse de convergence est encore plus rapide, mais l'intégration du temps de formation, d'améliorer l'effet est pas évident.
On peut produire des lots de liaison et de mélange XLA normalisation (fusionnée lot de Normalisation) (Les paramètres d'intégration de tf.layers.batch_normalization) par plusieurs opérations séparées dans un seul noyau normalisé pour accélérer le fonctionnement par lots.
Dans tous les cas, la normalisation en vrac peut être un outil très précieux pour accélérer la profondeur de la formation du réseau de neurones. Comme la formation du réseau de neurones en profondeur pour déterminer la meilleure façon de résoudre le problème de savoir si un moyen d'aider est de faire des expériences!
ressources officielles KERAS attachés
références:
https://towardsdatascience.com/how-to-use-batch-normalization-with-tensorflow-and-tf-keras-to-train-deep-neural-networks-faster-60ba4d054b73
sortie d'origine au nombre de micro-chaîne publique - expertise (Quan_Zhuanzhi)
