 Ver en TensorFlow.org |  Ejecutar en Google Colab |  Ver fuente en GitHub |  Descargar cuaderno |
Visión general
Este portátil ofrece una breve introducción en las capas de normalización de TensorFlow. Las capas actualmente admitidas son:
- Grupo de Normalización (TensorFlow Addons)
- Instancia Normalización (TensorFlow Addons)
- Capa de Normalización (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. En contraste con la normalización de lotes estas normalizaciones no lo hacen el trabajo en lotes, en lugar de que se normalicen las activaciones de una sola muestra, haciéndolas adecuadas para redes neual recurrentes, así.
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 el eje del lote, C como el eje del canal y (H, W) como los 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 estableciendo el center o la scale la bandera a True . Por supuesto se puede utilizar initializers , constraints y regularizer de beta y gamma para ajustar estos valores durante el proceso de formación.
Configuración
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 el 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 los lotes.
GN puntuó 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 usar 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>