Redes adversarias generativas (GAN) | Una introducción

Ian Goodfellow presentó por primera vez las redes adversas generativas (GAN) en 2014. Las GAN son una poderosa clase de redes neuronales que se utilizan para el aprendizaje no supervisado. Los GAN pueden crear cualquier cosa que les des, ya que aprende-genera-mejora. Para comprender primero las GAN, debe tener poca comprensión de las redes neuronales convolucionales . Las CNN están entrenadas para clasificar imágenes con respecto a sus etiquetas si una imagen se alimenta a una CNN, analiza la imagen píxel por píxel y pasa a través de los Nodes presentes en las capas ocultas de la CNN y, como salida, dice de qué se trata la imagen o lo que ve en la imagen. Por ejemplo:Si se entrena a una CNN para clasificar perros y gatos y se alimenta una imagen a esta CNN, puede decir si hay un perro o un gato en esa imagen. Por lo tanto, también se puede llamar como un algoritmo de clasificación. ¿En qué se diferencian las GAN? Las GAN se pueden dividir en dos partes, que son el generador y el discriminador . discriminador –Esta parte de las GAN puede considerarse similar a lo que hace la CNN. El discriminador es una red neuronal convolucional que consta de muchas capas ocultas y una capa de salida, la principal diferencia aquí es que la capa de salida de las GAN puede tener solo dos salidas, a diferencia de las CNN, que pueden tener salidas con respecto a la cantidad de etiquetas en las que se entrena. La salida del discriminador puede ser 1 o 0 debido a una función de activación elegida específicamente para esta tarea, si la salida es 1, los datos proporcionados son reales y si la salida es 0, se refiere a ellos como datos falsos. Discriminator está entrenado en los datos reales, por lo que aprende a reconocer cómo se ven los datos reales y qué características deben tener los datos para clasificarlos como reales. Generador –Por el nombre en sí, podemos entender que es un algoritmo generativo. Generator es una red neuronal convolucional inversa, hace exactamente lo contrario de lo que hace una CNN, porque en CNN se proporciona una imagen real como entrada y se espera una etiqueta clasificada como salida, pero en Generator, un ruido aleatorio (un vector que tiene algunos valores para ser precisos) se proporciona como entrada a esta CNN inversa y se espera una imagen real como salida. En términos simples, genera datos a partir de una pieza de datos utilizando su propia imaginación. Como se muestra en la imagen de arriba, se proporciona un vector de valor aleatorio como entrada a Inverse-CNN y, después de pasar por las capas ocultas y las funciones de activación, se recibe una imagen como salida. Funcionamiento del Generador y el Discriminador juntos:Como ya discutimos, Discriminator está entrenado en datos reales para clasificar si los datos dados son verdaderos o no, por lo que el trabajo de Discriminator es decir qué es real y qué es falso. Ahora el Generador comienza a generar datos a partir de una entrada aleatoria y luego esos datos generados se pasan a Discriminator como entrada. Ahora Discriminator analiza los datos y verifica qué tan cerca está de ser clasificado como real, si los datos generados no contienen suficientes características para ser clasificado como real por el Discriminador, luego estos datos y los pesos asociados con ellos se envían de vuelta al Generador mediante retropropagación, para que pueda reajustar los pesos asociados con los datos y crear nuevos datos que sean mejores que los anteriores. Estos datos recién generados se pasan nuevamente al Discriminador y continúa.En términos simples, Discriminator es un tipo capacitado que puede decir qué es real y qué es falso y Generator está tratando de engañar a Discriminator y hacerle creer que los datos generados son reales, con cada intento fallido, Generator aprende y se mejora para producir datos más reales. me gusta. También se puede establecer como una competencia entre Generador y Discriminador. 

Ejemplo de código para generador y discriminador:

1. Construyendo el generador

una. Qué entrada pasar la entrada a la primera capa del generador en la etapa inicial: random_normal_dimensions, que es un hiperparámetro que define cuántos números aleatorios en un vector querrás alimentar al generador como punto de partida para generar imágenes.

b. El siguiente punto a tener en cuenta es que aquí hemos utilizado la función de activación «selu» en lugar de «relu» porque «relu» tiene el efecto de eliminar el ruido al clasificar los datos al evitar que los valores negativos cancelen los positivos, pero en las GAN no lo hacemos. quiere eliminar datos.

# You'll pass the random_normal_dimensions to the first dense layer of the generator
random_normal_dimensions = 32
 
### START CODE HERE ###
generator = keras.models.Sequential([
    keras.layers.Dense(7 * 7 * 128, input_shape=[random_normal_dimensions]),
    keras.layers.Reshape([7, 7, 128]),
    keras.layers.BatchNormalization(),
    keras.layers.Conv2DTranspose(64, kernel_size=5, strides=2, padding="SAME",
                                 activation="selu"),
    keras.layers.BatchNormalization(),
    keras.layers.Conv2DTranspose(1, kernel_size=5, strides=2, padding="SAME",
                                 activation="tanh")
     
     
])
### END CODE HERE ###

2. Construyendo el discriminador:

### START CODE HERE ###
discriminator = keras.models.Sequential([
    keras.layers.Conv2D(64, kernel_size=5, strides=2, padding="SAME",
                        activation=keras.layers.LeakyReLU(0.2),
                        input_shape=[28, 28, 1]),
    keras.layers.Dropout(0.4),
    keras.layers.Conv2D(128, kernel_size=5, strides=2, padding="SAME",
                        activation=keras.layers.LeakyReLU(0.2)),
    keras.layers.Dropout(0.4),
    keras.layers.Flatten(),
    keras.layers.Dense(1, activation="sigmoid") 
     
     
])
### END CODE HERE ###

3. Compilando el discriminador:

Aquí estamos compilando el discriminador con un optimizador binary_crossentropy loss y rmsprop.
Configure el discriminador para que no entrene en sus pesos (establezca su campo «entrenable»).

### START CODE HERE ###
discriminator.compile(loss="binary_crossentropy", optimizer="rmsprop")
discriminator.trainable = False
### END CODE HERE ###

4. Construya y compile el modelo GAN:
construya el modelo secuencial para el GAN, pasando una lista que contiene el generador y el discriminador.
Compile el modelo con una pérdida de entropía cruzada binaria y un optimizador rmsprop.

### START CODE HERE ###
gan = keras.models.Sequential([generator, discriminator])
gan.compile(loss="binary_crossentropy", optimizer="rmsprop")
### END CODE HERE ###

5. Entrenar el GAN:
Fase 1

real_batch_size: Obtenga el tamaño del lote del lote de entrada (es la dimensión cero del tensor)
noise: Genere el ruido usando tf.random.normal. La forma es tamaño de lote x random_normal_dimension
imágenes falsas: use el generador que acaba de crear. Pase el ruido y produzca imágenes falsas.
mixed_images: concatena las imágenes falsas con las imágenes reales.
Establece el eje en 0.
discriminator_labels: Establece en 0. para imágenes reales y 1. para imágenes falsas.
Establezca el discriminador como entrenable.
Utilice el método train_on_batch() del discriminador para entrenar en las imágenes mixtas y las etiquetas del discriminador.

Fase 2

ruido: generar valores normales aleatorios con dimensiones batch_size x random_normal_dimensions
Use real_batch_size.
Generator_labels: Establézcalo en 1. para marcar las imágenes falsas como reales
. El generador generará imágenes falsas que se etiquetarán como imágenes reales e intentará engañar al discriminador.
Configure el discriminador para que NO sea entrenable.
Entrene a la GAN sobre el ruido y las etiquetas del generador.

Lectura adicional : https://www.geeksforgeeks.org/generative-adversarial-network-gan/