Normalisations

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Voir sur TensorFlow.org Exécuter dans Google Colab Voir la source sur GitHub Télécharger le cahier

Aperçu

Ce portable donne une brève introduction dans les couches de normalisation de tensorflow. Les calques actuellement pris en charge sont :

  • Groupe Normalization (tensorflow Addons)
  • Instance Normalisation (tensorflow Extensions)
  • Couche Normalization (tensorflow de base)

L'idée de base derrière ces couches est de normaliser la sortie d'une couche d'activation pour améliorer la convergence pendant l'entraînement. Contrairement à la normalisation des lots de ces normalisations ne fonctionnent pas sur des lots, au lieu qu'ils normalisent les activations d'un seul échantillon, ce qui les rend appropriés pour les réseaux neual récurrents ainsi.

Généralement, la normalisation est effectuée en calculant la moyenne et l'écart type d'un sous-groupe dans votre tenseur d'entrée. Il est également possible d'appliquer une échelle et un facteur de décalage à cela.

\(y_{i} = \frac{\gamma ( x_{i} - \mu )}{\sigma }+ \beta\)

\( y\) : Débit

\(x\) : Entrée

\(\gamma\) : Facteur d'échelle

\(\mu\): moyenne

\(\sigma\): écart - type

\(\beta\): facteur de décalage

L'image suivante montre la différence entre ces techniques. Chaque sous-intrigue montre un tenseur d'entrée, avec N comme axe de lot, C comme axe de canal et (H, W) comme axes spatiaux (Hauteur et Largeur d'une image par exemple). Les pixels en bleu sont normalisés par la même moyenne et la même variance, calculées en agrégeant les valeurs de ces pixels.

Source: ( https://arxiv.org/pdf/1803.08494.pdf )

Les poids gamma et bêta peuvent être entraînés dans toutes les couches de normalisation pour compenser la perte possible de capacité de représentation. Vous pouvez activer ces facteurs en définissant le center ou l' scale drapeau True . Bien sûr , vous pouvez utiliser initializers , constraints et regularizer pour la beta et gamma pour régler ces valeurs au cours du processus de formation.

Installer

Installer Tensorflow 2.0 et Tensorflow-Addons

pip install -U tensorflow-addons
import tensorflow as tf
import tensorflow_addons as tfa

Préparation de l'ensemble de données

mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

Tutoriel de normalisation de groupe

introduction

La normalisation de groupe (GN) divise les canaux de vos entrées en sous-groupes plus petits et normalise ces valeurs en fonction de leur moyenne et de leur variance. Étant donné que GN travaille sur un seul exemple, cette technique est indépendante de la taille des lots.

GN a obtenu un score expérimental proche de la normalisation par lots dans les tâches de classification d'images. Il peut être avantageux d'utiliser GN au lieu de la normalisation par lots au cas où votre batch_size global serait faible, ce qui entraînerait de mauvaises performances de normalisation des lots.

Exemple

Diviser 10 canaux après une couche Conv2D en 5 sous-groupes dans un paramètre standard « canaux en dernier » :

model = tf.keras.models.Sequential([
  # Reshape into "channels last" setup.
  tf.keras.layers.Reshape((28,28,1), input_shape=(28,28)),
  tf.keras.layers.Conv2D(filters=10, kernel_size=(3,3),data_format="channels_last"),
  # Groupnorm Layer
  tfa.layers.GroupNormalization(groups=5, axis=3),
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
model.fit(x_test, y_test)
313/313 [==============================] - 3s 3ms/step - loss: 0.4707 - accuracy: 0.8613
<keras.callbacks.History at 0x7f63a5c5f490>

Tutoriel de normalisation d'instance

introduction

La normalisation d'instance est un cas particulier de normalisation de groupe où la taille du groupe est la même que la taille du canal (ou la taille de l'axe).

Les résultats expérimentaux montrent que la normalisation d'instance fonctionne bien sur le transfert de style lors du remplacement de la normalisation par lots. Récemment, la normalisation des instances a également été utilisée en remplacement de la normalisation par lots dans les GAN.

Exemple

Application de la normalisation d'instance après une couche Conv2D et utilisation d'une échelle et d'un facteur de décalage initialisés uniformes.

model = tf.keras.models.Sequential([
  # Reshape into "channels last" setup.
  tf.keras.layers.Reshape((28,28,1), input_shape=(28,28)),
  tf.keras.layers.Conv2D(filters=10, kernel_size=(3,3),data_format="channels_last"),
  # LayerNorm Layer
  tfa.layers.InstanceNormalization(axis=3, 
                                   center=True, 
                                   scale=True,
                                   beta_initializer="random_uniform",
                                   gamma_initializer="random_uniform"),
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
model.fit(x_test, y_test)
313/313 [==============================] - 1s 3ms/step - loss: 0.5367 - accuracy: 0.8405
<keras.callbacks.History at 0x7f63a58d9f50>

Tutoriel de normalisation des calques

introduction

La normalisation de couche est un cas particulier de normalisation de groupe où la taille du groupe est de 1. La moyenne et l'écart type sont calculés à partir de toutes les activations d'un seul échantillon.

Les résultats expérimentaux montrent que la normalisation de couche est bien adaptée aux réseaux de neurones récurrents, car elle fonctionne indépendamment de la taille des lots.

Exemple

Application de la normalisation de couche après une couche Conv2D et utilisation d'un facteur d'échelle et de décalage.

model = tf.keras.models.Sequential([
  # Reshape into "channels last" setup.
  tf.keras.layers.Reshape((28,28,1), input_shape=(28,28)),
  tf.keras.layers.Conv2D(filters=10, kernel_size=(3,3),data_format="channels_last"),
  # LayerNorm Layer
  tf.keras.layers.LayerNormalization(axis=3 , center=True , scale=True),
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
model.fit(x_test, y_test)
313/313 [==============================] - 1s 3ms/step - loss: 0.4056 - accuracy: 0.8754
<keras.callbacks.History at 0x7f63a5722d10>

Littérature

Norme de couche

Norme d'instance

Norme de groupe