 Ver en TensorFlow.org |  Ejecutar en Google Colab |  Ver fuente en GitHub |  Descargar cuaderno |
Visión general
Este cuaderno ofrece una breve introducción a las capas de normalización de TensorFlow. Las capas admitidas actualmente son:
- Normalización de grupos (complementos de TensorFlow)
- Normalización de instancias (complementos de TensorFlow)
- Normalización de capas (TensorFlow Core)
La idea básica detrás de estas capas es normalizar la salida de una capa de activación para mejorar la convergencia durante el entrenamiento. A diferencia de la normalización por lotes, estas normalizaciones no funcionan en lotes, sino que normalizan las activaciones de una sola muestra, lo que las hace adecuadas también para redes neuales recurrentes.
Normalmente, la normalización se realiza calculando la media y la desviación estándar de un subgrupo en su tensor de entrada. También es posible aplicar una escala y un factor de compensación a esto.
$ y_ {i} = \ frac {\ gamma (x_ {i} - \ mu)} {\ sigma} + \ beta $
$ y $: Salida
$ x $: Entrada
$ \ gamma $: factor de escala
$ \ mu $: mean
$ \ sigma $: desviación estándar
$ \ beta $: factor de compensación
La siguiente imagen demuestra la diferencia entre estas técnicas. Cada subparcela muestra un tensor de entrada, con N como eje de lote, C como eje de canal y (H, W) como ejes espaciales (Alto y Ancho de una imagen, por ejemplo). Los píxeles en azul están normalizados por la misma media y varianza, calculados agregando los valores de estos píxeles.
Fuente: ( https://arxiv.org/pdf/1803.08494.pdf )
Los pesos gamma y beta se pueden entrenar en todas las capas de normalización para compensar la posible pérdida de capacidad de representación. Puede activar estos factores configurando el center o el indicador de scale en True . Por supuesto, puede usar initializers , constraints y regularizer para beta y gamma para ajustar estos valores durante el proceso de entrenamiento.
Preparar
Instalar Tensorflow 2.0 y los complementos de Tensorflow
pip install -q -U tensorflow-addons
import tensorflow as tf
import tensorflow_addons as tfa
Preparando conjunto de datos
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 de normalización de grupos
Introducción
La normalización de grupo (GN) divide los canales de sus entradas en subgrupos más pequeños y normaliza estos valores en función de su media y varianza. Dado que GN funciona con un solo ejemplo, esta técnica es independiente del tamaño de lote.
GN puntuado experimentalmente cerrado a la normalización por lotes en tareas de clasificación de imágenes. Puede ser beneficioso utilizar GN en lugar de la normalización por lotes en caso de que su tamaño de lote general sea bajo, lo que daría lugar a un mal rendimiento de la normalización por lotes.
Ejemplo
Dividir 10 canales después de una capa Conv2D en 5 subgrupos en una configuración estándar de "últimos canales":
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 de normalización de instancias
Introducción
La normalización de instancia es un caso especial de normalización de grupo en el que el tamaño del grupo es del mismo tamaño que el tamaño del canal (o el tamaño del eje).
Los resultados experimentales muestran que la normalización de instancias funciona bien en la transferencia de estilos cuando se reemplaza la normalización por lotes. Recientemente, la normalización de instancias también se ha utilizado como reemplazo de la normalización por lotes en GAN.
Ejemplo
Aplicar InstanceNormalization después de una capa Conv2D y utilizar una escala inicializada uniformada y un factor de compensación.
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 de normalización de capas
Introducción
La normalización de capa es un caso especial de normalización de grupo donde el tamaño del grupo es 1. La media y la desviación estándar se calculan a partir de todas las activaciones de una sola muestra.
Los resultados experimentales muestran que la normalización de capas es adecuada para redes neuronales recurrentes, ya que funciona independientemente del tamaño de los lotes.
Ejemplo
Aplicar la normalización de capas después de una capa Conv2D y usar un factor de escala y desplazamiento.
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>