Transformación de Estilo Neural con TensorFlow: Guía Definitiva

La transformación de estilo neural es una técnica de inteligencia artificial que permite transferir el estilo artístico de una imagen a otra. Esta técnica ha ganado popularidad en los últimos años debido a su capacidad para generar imágenes creativas y sorprendentes. Con TensorFlow, puedes implementar fácilmente esta transformación y dar un toque artístico a tus proyectos visuales. Esta guía te mostrará cómo hacerlo paso a paso.

Qué es la Transformación de Estilo Neural

La transformación de estilo neural es una técnica que utiliza redes neuronales convolucionales (CNN) para combinar el contenido de una imagen con el estilo de otra. El resultado es una nueva imagen que conserva el contenido de la primera pero con el estilo visual de la segunda. Esta técnica se basa en la capacidad de las CNN para extraer características de las imágenes, tanto a nivel de contenido como de estilo.

¿Por qué es importante la Transformación de Estilo Neural?

• Creatividad: Permite generar imágenes y videos con estilos artísticos únicos.
• Personalización: Adapta el estilo visual de contenido a preferencias individuales.
• Automatización: Automatiza el proceso de creación artística.
• Aplicaciones Versátiles: Se utiliza en fotografía, video, diseño gráfico y más.

Cómo Funciona la Transformación de Estilo Neural con TensorFlow

La transformación de estilo neural con TensorFlow implica varios pasos clave:

1. Extracción de Características: Utiliza una CNN pre-entrenada, como VGG19, para extraer las características de contenido y estilo de las imágenes de entrada

   .

2. Definición de Pérdidas: Define funciones de pérdida que miden la diferencia entre el contenido de la imagen generada y la imagen de contenido, así como la diferencia entre el estilo de la imagen generada y la imagen de estilo.
3. Optimización: Utiliza un algoritmo de optimización, como Adam, para minimizar las pérdidas y generar una imagen que combine el contenido y el estilo deseados.

Componentes Clave

• Imagen de Contenido: La imagen cuyo contenido se desea preservar.
• Imagen de Estilo: La imagen cuyo estilo se desea transferir.
• Imagen Generada: La imagen resultante que combina el contenido y el estilo.
• Red Neuronal Convolucional (CNN): Utilizada para la extracción de características.
• Funciones de Pérdida: Miden la diferencia entre las características de contenido y estilo.
• Algoritmo de Optimización: Ajusta la imagen generada para minimizar las pérdidas.

Preparación del Entorno

Antes de comenzar, asegúrate de tener instalado TensorFlow y las bibliotecas necesarias

.

pip install tensorflow tensorflow-hub pillow matplotlib

Importación de Bibliotecas

import tensorflow as tf
import tensorflow_hub as hub
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
import os

Carga de Imágenes

def load_img(path_to_img):
    img = tf.io.read_file(path_to_img)
    img = tf.image.decode_image(img, channels=3)
    img = tf.image.convert_image_dtype(img, tf.float32)

    shape = tf.cast(tf.shape(img)[:-1], tf.float32)
    long_dim = max(shape)
    scale = 512 / long_dim

    new_shape = tf.cast(shape * scale, tf.int32)

    img = tf.image.resize(img, new_shape)
    img = img[tf.newaxis, :]
    return img

style_image = load_img('style_image.jpg')
content_image = load_img('content_image.jpg')

Visualización de Imágenes

def imshow(image, title=None):
  if len(image.shape) > 3:
    image = tf.squeeze(image, axis=0)

  plt.imshow(image)
  if title:
    plt.title(title)
plt.subplot(1, 2, 1)
imshow(content_image, 'Content Image')

plt.subplot(1, 2, 2)
imshow(style_image, 'Style Image')
plt.show()

Carga del Modelo Pre-Entrenado VGG19

Utilizaremos VGG19, una red neuronal convolucional pre-entrenada en el conjunto de datos ImageNet

. TensorFlow Hub facilita la carga de este modelo.

hub_model = hub.load('https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2')
stilized_image = hub_model(tf.convert_to_tensor(content_image), tf.convert_to_tensor(style_image))[0]

tf.keras.preprocessing.image.save_img('styled_image.png', stylized_image)

Definición de Capas de Estilo y Contenido

Para extraer las características de estilo y contenido, definimos las capas específicas de VGG19 que utilizaremos.

content_layers = ['block5_conv2']

style_layers = ['block1_conv1',
                'block2_conv1',
                'block3_conv1',
                'block4_conv1',
                'block5_conv1'
               ]

num_style_layers = len(style_layers)

Creación del Modelo VGG

def vgg_layers(layer_names):
  vgg = tf.keras.applications.VGG19(include_top=False, weights='imagenet')
  vgg.trainable = False

  outputs = [vgg.get_layer(name).output for name in layer_names]

  model = tf.keras.Model([vgg.input], outputs)
  return model

style_extractor = vgg_layers(style_layers)
style_outputs = style_extractor(style_image*255)

Cálculo de Estilo

El estilo se calcula utilizando la matriz de Gram de las salidas de las capas de estilo.

def gram_matrix(input_tensor):
  result = tf.linalg.einsum('bijc,bijd->bcd', input_tensor, input_tensor)
  input_shape = tf.shape(input_tensor)
  num_locations = tf.cast(input_shape[1]*input_shape[2], tf.float32)
  return result/(num_locations)

class StyleContentModel(tf.keras.models.Model):
  def __init__(self, style_layers, content_layers):
    super(StyleContentModel, self).__init__()
    self.vgg =  vgg_layers(style_layers + content_layers)
    self.style_layers = style_layers
    self.content_layers = content_layers
    self.num_style_layers = len(style_layers)
    self.vgg.trainable = False

  def call(self, inputs):
    inputs = inputs*255.0
    preprocessed_input = tf.keras.applications.vgg19.preprocess_input(inputs)
    outputs = self.vgg(preprocessed_input)
    style_outputs, content_outputs = (outputs[:self.num_style_layers], 
                                      outputs[self.num_style_layers:])

    style_outputs = [gram_matrix(style_output)
                     for style_output in style_outputs]

    content_dict = {content_name:value 
                    for content_name, value 
                    in zip(self.content_layers, content_outputs)}

    style_dict = {style_name:value
                  for style_name, value
                  in zip(self.style_layers, style_outputs)}

    return {'content':content_dict, 'style':style_dict}

extractor = StyleContentModel(style_layers, content_layers)

results = extractor(tf.constant(content_image))

style_results = results['style']

print('Styles:', [tf.shape(style_results[name]).numpy() for name in style_layers])
print('Content:', tf.shape(results['content']['block5_conv2']).numpy())

Definición de Funciones de Pérdida

Las funciones de pérdida son esenciales para medir la calidad de la imagen generada. Aquí definimos las funciones de pérdida de contenido y estilo.

style_weight=1e-2
content_weight=1e4

def style_content_loss(outputs):
    style_outputs = outputs['style']
    content_outputs = outputs['content']
    style_loss = tf.add_n([tf.reduce_mean((style_outputs[name]-style_targets[name])**2) 
                           for name in style_outputs.keys()])
    style_loss *= style_weight / num_style_layers

    content_loss = tf.add_n([tf.reduce_mean((content_outputs[name]-content_targets[name])**2)  
                             for name in content_outputs.keys()])
    content_loss *= content_weight / num_content_layers
    loss = style_loss + content_loss
    return loss

Optimización y Entrenamiento

Utilizamos el optimizador Adam para minimizar la función de pérdida y generar la imagen final. Ajustamos los pesos de estilo y contenido para obtener el resultado deseado

.

image = tf.Variable(content_image)
optimizer = tf.optimizers.Adam(learning_rate=0.02, beta_1=0.99, epsilon=1e-1)

@tf.function()
def train_step(image):
  with tf.GradientTape() as tape:
    outputs = extractor(image)
    loss = style_content_loss(outputs)

grad = tape.gradient(loss, image)
    optimizer.apply_gradients([(grad, image)])
    image.assign(clip_0_1(image))

style_targets = extractor(style_image)['style']
content_targets = extractor(content_image)['content']

def clip_0_1(image):
  return tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=1.0)

import time
start = time.time()

epochs = 10
steps_per_epoch = 100

step = 0
for n in range(epochs):
  for m in range(steps_per_epoch):
    step += 1
    train_step(image)
    print(".", end='')
  display.clear_output(wait=True)
  display.display(tensor_to_image(image))
  print("Train step: {}".format(step))

end = time.time()
print("Total time: {:.1f}".format(end-start))

def tensor_to_image(tensor):
  tensor = tensor*255
  tensor = np.array(tensor, dtype=np.uint8)
  if np.ndim(tensor)>3:
    assert tensor.shape[0] == 1
    tensor = tensor[0]
  return  PIL.Image.fromarray(tensor)

Paso 1: Instalación de Bibliotecas

Asegúrate de tener instaladas las bibliotecas necesarias:

pip install tensorflow tensorflow-hub pillow matplotlib

Paso 2: Carga de Imágenes

Carga las imágenes de contenido y estilo:

style_image = load_img('style_image.jpg')
content_image = load_img('content_image.jpg')

Paso 3: Ejecución del Modelo

Ejecuta el modelo de transformación de estilo neural:

stylized_image = hub_model(tf.convert_to_tensor(content_image), tf.convert_to_tensor(style_image))[0]

tf.keras.preprocessing.image.save_img('styled_image.png', stylized_image)

Estrategias de Optimización de Costos

La optimización de costos es crucial para proyectos de transformación de estilo neural, especialmente al trabajar con grandes volúmenes de datos o implementaciones en la nube.

• Utilización de GPUs: Utiliza unidades de procesamiento gráfico (GPUs) para acelerar los cálculos intensivos de las CNNs .
• Modelos Cuantizados: Emplea modelos cuantizados para reducir el tamaño del modelo y mejorar la eficiencia.
• Servicios en la Nube: Aprovecha servicios en la nube como Google Colab o AWS para acceder a recursos computacionales escalables.
• Ajuste de Hiperparámetros: Optimiza los hiperparámetros de entrenamiento para lograr una convergencia más rápida.

Google Colab para una Transformación de Estilo Neural Eficiente

Google Colab es una excelente opción para ejecutar la transformación de estilo neural debido a su acceso gratuito a GPUs y TPUs. Aquí te mostramos cómo configurarlo:

1. Acceso a Google Colab: Inicia sesión en Google Colab.
2. Creación de un Nuevo Notebook: Crea un nuevo notebook de Python 3.
3. Habilitación de GPU: Ve a "Entorno de ejecución" -> "Cambiar tipo de entorno de ejecución" y selecciona "GPU".
4. Carga de Código: Copia y pega el código de transformación de estilo neural en el notebook.
5. Ejecución del Código: Ejecuta las celdas de código para transformar tus imágenes.

Extracción de Características de Contenido

Utiliza capas profundas de una CNN pre-entrenada para capturar la estructura y los objetos presentes en la imagen de contenido.

Extracción de Características de Estilo

Utiliza la matriz de Gram de las capas superficiales de una CNN para representar las características de textura y color de la imagen de estilo.

Optimización de la Imagen Generada

Ajusta la imagen generada iterativamente para minimizar las diferencias con las características de contenido y estilo deseadas.

Fotografía Artística

Transforma fotos ordinarias en obras de arte aplicando estilos de pintores famosos como Van Gogh, Monet o Picasso.

Creación de Videojuegos

Genera texturas y entornos visuales únicos para videojuegos, adaptando el estilo a la narrativa y el ambiente del juego.

Diseño Gráfico

Crea contenido visual atractivo para marketing y publicidad, aplicando estilos personalizados a imágenes y videos.

Filtros Artísticos en Redes Sociales

Implementa filtros que permiten a los usuarios transformar sus fotos y videos con estilos artísticos en tiempo real

.