Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Normalisierungen

Ansicht auf TensorFlow.org Quelle auf GitHub anzeigen Notizbuch herunterladen

Überblick

Dieses Notizbuch bietet eine kurze Einführung in die Normalisierungsebenen von TensorFlow. Derzeit unterstützte Ebenen sind:

  • Gruppennormalisierung (TensorFlow Addons)
  • Instanznormalisierung (TensorFlow Addons)
  • Schichtnormalisierung (TensorFlow Core)

Die Grundidee hinter diesen Schichten besteht darin, die Ausgabe einer Aktivierungsschicht zu normalisieren, um die Konvergenz während des Trainings zu verbessern. Im Gegensatz zur Chargennormalisierung funktionieren diese Normalisierungen nicht für Chargen, sondern normalisieren die Aktivierungen einer einzelnen Probe, sodass sie auch für wiederkehrende jährliche Netzwerke geeignet sind.

Normalerweise wird die Normalisierung durchgeführt, indem der Mittelwert und die Standardabweichung einer Untergruppe in Ihrem Eingangstensor berechnet werden. Es ist auch möglich, eine Skala und einen Versatzfaktor darauf anzuwenden.

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

$ y $: Ausgabe

$ x $: Eingabe

$ \ gamma $: Skalierungsfaktor

$ \ mu $: Mittelwert

$ \ sigma $: Standardabweichung

$ \ beta $: Versatzfaktor

Das folgende Bild zeigt den Unterschied zwischen diesen Techniken. Jedes Unterplot zeigt einen Eingangstensor mit N als Stapelachse, C als Kanalachse und (H, W) als Raumachse (z. B. Höhe und Breite eines Bildes). Die blauen Pixel werden durch denselben Mittelwert und dieselbe Varianz normalisiert, die durch Aggregation der Werte dieser Pixel berechnet werden.

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

Die Gewichte Gamma und Beta können in allen Normalisierungsschichten trainiert werden, um den möglichen Verlust der Repräsentationsfähigkeit auszugleichen. Sie können diese Faktoren aktivieren, indem Sie die center oder das scale auf True . Natürlich können Sie initializers , constraints und regularizer für beta und gamma , um diese Werte während des Trainingsprozesses abzustimmen.

Konfiguration

Installieren Sie Tensorflow 2.0 und Tensorflow-Addons

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

Datensatz vorbereiten

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

Tutorial zur Gruppennormalisierung

Einführung

Die Gruppennormalisierung (GN) unterteilt die Kanäle Ihrer Eingaben in kleinere Untergruppen und normalisiert diese Werte basierend auf ihrem Mittelwert und ihrer Varianz. Da GN an einem einzelnen Beispiel arbeitet, ist diese Technik unabhängig von der Stapelgröße.

GN wurde experimentell bei Bildklassifizierungsaufgaben für die Chargennormalisierung geschlossen bewertet. Es kann vorteilhaft sein, GN anstelle der Chargennormalisierung zu verwenden, wenn Ihre Gesamtchargengröße niedrig ist, was zu einer schlechten Leistung der Chargennormalisierung führen würde

Beispiel

Aufteilen von 10 Kanälen nach einer Conv2D-Ebene in 5 Untergruppen in einer Standardeinstellung "Kanäle zuletzt":

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 [==============================] - 4s 3ms/step - loss: 0.7835 - accuracy: 0.7722

<tensorflow.python.keras.callbacks.History at 0x7f94db65ca58>

Tutorial zur Instanznormalisierung

Einführung

Die Instanznormalisierung ist ein Sonderfall der Gruppennormalisierung, bei dem die Gruppengröße der Kanalgröße (oder der Achsengröße) entspricht.

Experimentelle Ergebnisse zeigen, dass die Instanznormalisierung bei der Stilübertragung beim Ersetzen der Stapelnormalisierung gut funktioniert. In letzter Zeit wurde die Instanznormalisierung auch als Ersatz für die Chargennormalisierung in GANs verwendet.

Beispiel

Anwenden von InstanceNormalization nach einer Conv2D-Ebene und Verwenden eines uniformierten initialisierten Skalierungs- und Versatzfaktors.

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 [==============================] - 2s 3ms/step - loss: 0.9159 - accuracy: 0.7194

<tensorflow.python.keras.callbacks.History at 0x7f9549c37278>

Tutorial zur Ebenennormalisierung

Einführung

Die Schichtnormalisierung ist ein Sonderfall der Gruppennormalisierung, bei dem die Gruppengröße 1 beträgt. Der Mittelwert und die Standardabweichung werden aus allen Aktivierungen einer einzelnen Probe berechnet.

Experimentelle Ergebnisse zeigen, dass die Schichtnormalisierung für wiederkehrende neuronale Netze gut geeignet ist, da sie unabhängig von der Stapelgröße funktioniert.

Beispiel

Anwenden der Layernormalisierung nach einer Conv2D-Ebene und Verwenden eines Skalierungs- und Versatzfaktors.

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.6272 - accuracy: 0.8049

<tensorflow.python.keras.callbacks.History at 0x7f9549b0a748>

Literatur

Schichtnorm

Instanznorm

Gruppennorm

Vollständige Übersicht über Normalisierungen