Para terminar la prueba de creación de música, vamos a ver cómo se crear el Discriminador que va a ser parte de nuestra GAN, complementando al Generador que vimos en la parte anterior de este artículo. Con esta GAN completa, vamos a ver el vídeo con el resultado de la música creada.

El modelo Discriminador funciona como una CNN que recibe una melodía generada por el modelo Generador y trata de predecir si el contenido es real o no, es decir, un simple clasificador binario.

Figura 18: Arquitectura modelo discriminador

Su implementación se muestra en el siguiente snippet de código:

def  _build_critic_layer(layer_input, filters, f_size=4):
     """
    This layer decreases the spatial resolution by 2:
    input:  [batch_size, in_channels, H, W]
    output: [batch_size, out_channels, H/2, W/2]
    """
     d = tf.keras.layers.Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)
     # Critic does not use batch-norm
     d = tf.keras.layers.LeakyReLU(alpha=0.2)(d)
     return d
  
 def build_critic(pianoroll_shape=(32, 128, 4), filters=64):
     """WGAN critic."""
     condition_input_shape = (32,128,1)
     groundtruth_pianoroll = tf.keras.layers.Input(shape=pianoroll_shape)
     condition_input = tf.keras.layers.Input(shape=condition_input_shape)
     combined_imgs=tf.keras.layers.Concatenate(axis=-1)([groundtruth_pianoroll, condition_input])
  
     d1 = _build_critic_layer(combined_imgs, filters)
     d2 = _build_critic_layer(d1, filters * 2)
     d3 = _build_critic_layer(d2, filters * 4)
     d4 = _build_critic_layer(d3, filters * 8)
  
     x = tf.keras.layers.Flatten()(d4)
     logit = tf.keras.layers.Dense(1)(x)
  
     critic = tf.keras.models.Model([groundtruth_pianoroll,condition_input], logit,
                                           name='Critic')
    
     return critic

Este modelo, en el entrenamiento, se instanciará dos veces, por una parte, se obtendrá su veredicto (si es similar a Bach) con respecto a una melodía real, y por otra parte se obtendrá su veredicto con respecto a la melodía creada por el modelo Generador (creada en base a esta melodía real sobre la que se hizo el primer veredicto). 

El modelo se trata de un clasificador binario, donde se realizan cuatro convoluciones sucesivas con el objetivo de ir extrayendo las características importantes y realizar la predicción. De esta manera, el proceso de aprendizaje consiste en ir iterando sobre el dataset de melodías de Bach mientras que el modelo Discriminador y el Generador se van entrenando. 

El Discriminador se entrena en primer lugar, de manera que, dada una melodía del dataset, se escoge una sola pista de esta y se llama al Generador para que genere una melodía de cuatro pistas en base a esta pista seleccionada, conocida como la entrada fake del modelo Discriminador, y se realizará una predicción sobre si el estilo de esta nueva melodía creada es similar a una de Bach, también se realiza una predicción sobre si la melodía original del dataset, conocida como la entrada real de esta red, es similar en estilo a una de este famoso compositor.

Esta información sobre ambas predicciones se utiliza para optimizar al modelo Discriminador (en esta implementación, este proceso de entrenamiento del modelo Discriminador se realiza cinco veces por cada entrenamiento del modelo Generador). El cálculo de la información sobre ambas predicciones se ve implementado en el siguiente código.

def critic_train_step(x, condition_track_idx=0):
 
     # Extract condition track to make real batches pianoroll
     c = tf.expand_dims(x[..., condition_track_idx], -1)
  
     # Generate batch of latent vectors
     z = tf.random.truncated_normal([BATCH_SIZE, 2, 8, 512])
  
     # Generated fake pianoroll
     fake_x = generator((c, z), training=False)
  
     # Update critic parameters
     with tf.GradientTape() as tape:
         real_output = critic((x,c), training=True)
         fake_output = critic((fake_x,c), training=True)
         critic_loss =  wasserstein_loss(real_output, fake_output)
 

En segundo lugar, se entrena al modelo Generador, que creará una melodía en base a la misma pista seleccionada de la melodía del dataset de esta iteración (esta pista seleccionada, la misma que se utiliza tanto en el modelo Discriminador como en el Generador, se puede ver en el código nombrada como condition input o simplemente c). Con esta melodía generada, se llamará al modelo Discriminador para que realice una predicción sobre si es similar al estilo de Bach, y esta información proporcionada por el Discriminador se utilizará para optimizar el modelo Generador.

El proceso del cálculo de la información necesaria para optimizar al Generador se muestra en el siguiente código.

def generator_train_step(x, condition_track_idx=0):
 
     # Extract condition track to make real batches pianoroll
     c = tf.expand_dims(x[..., condition_track_idx], -1)
  
     # Generate batch of latent vectors
     z = tf.random.truncated_normal([BATCH_SIZE, 2, 8, 512])
  
     with tf.GradientTape() as tape:
         fake_x = generator((c, z), training=True)
         fake_output = critic((fake_x,c), training=False)
  
         # Calculate Generator's loss based on this generated output
         gen_loss = generator_loss(fake_output)
 
 A continuación, se muestra un snippet de código con el proceso de entrenamiento de ambos modelos.
 
 # Data iterator to iterate over our dataset
 it = iter(dataset)
 for iteration in range(iterations):
 
     # Train critic
     for _ in range(n_dis_updates_per_gen_update):
         c_loss = critic_train_step(next(it))
  
     # Train generator
     g_loss = generator_train_step(next(it))

Cada 50 iteraciones, se llamará al modelo Generador para que genere melodías, recibiendo como entrada otras melodías no presentes en el entrenamiento. De esta manera, veremos el rendimiento del modelo Generador y su capacidad de crear nuevas melodías similares a las de este famoso compositor. 

En este caso, hemos realizado un entrenamiento de 2000 iteraciones, y hemos creado un vídeo donde podemos ver cómo va evolucionando el estilo de la melodía creada por el modelo Generador. Se trata de una primera aproximación, es decir, el proceso de entrenamiento todavía se puede optimizar más, por ejemplo, dejando más iteraciones para entrenar.

Conclusiones finales

La Inteligencia Artificial está suponiendo una gran revolución en muchos dominios, como en el ámbito del arte. La cuestión ahora es ver y entender todo este potencial como un asistente que ayude a los artistas a encontrar inspiración para sus obras, apoyándose en nuevas creaciones desarrolladas con IA que estimulen su imaginación, permitiendo destinar estas nuevas fuentes de inspiración a mejorar su contenido.

Además, gracias a las nuevas corrientes dedicadas a ofrecer al mundo de manera muy explicativa y accesible herramientas para que cada vez más personas de cualquier formación puedan desarrollar modelos de IA, se está promoviendo la generación de comunidades de interesados en este campo que están creando cada vez más contenidos interesantes que, a su vez, ayudan a la creación de un ciclo por el que cada vez más gente empieza a utilizar la IA como ayuda en sus respectivos ámbitos, y dado el interés promovido se realizan cada vez más investigaciones dedicadas a mejorar y crear nuevos algoritmos de IA.


Personalmente, para aprender más sobre la generación de contenido (imágenes, música, texto…) y, en general, conocer en más detalle el potencial del Deep Learning (el subcampo de la IA que nos permite realizar este tipo de contenido), recomiendo el libro Deep Learning with Python, escrito por François Chollet, creador de Keras, una librería creada en su inicio para hacer del mundo del Deep Learning más accesible a personas de cualquier nivel, pero que ha acabado convirtiéndose en la más utilizada por los practicantes de este campo. Y para terminar, si quieres aprender sobre Inteligencia Artificial y cómo aplicarla a otro campo como es la ciberseguridad, en 0xWord puedes encontrar este libro de Machine Learning aplicado a Ciberseguridad.