Estás leyendo la publicación: ¿Cómo generar imágenes a partir de texto usando DALL.E Mini?
El método de generación de texto a imagen Zero-shot funciona combinando las categorías observadas y no observadas de descripciones de texto a través de algunos tipos de información auxiliar, que codifica las propiedades distintivas observables de los objetos. En este artículo, usaremos DALL-E mini para la implementación de la generación de texto a imagen Zero-shot y generaremos las imágenes para una cadena de texto determinada. Los siguientes son los temas que se tratarán en este artículo.
Tabla de contenido
- ¿Qué es el aprendizaje Zero-shot?
- ¿Cómo funciona la generación de texto a imagen Zero-shot?
- Generación de imágenes con DALL-E Mini
Comencemos con la comprensión del aprendizaje Zero-shot (ZSL).
¿Qué es el aprendizaje Zero-shot?
El objetivo de Zero-Shot Learning (ZSL) es aprender capas semánticas intermedias y sus propiedades, de modo que, durante la inferencia, se pueda predecir una nueva clase de datos. Como ejemplo, un modelo desarrollado para distinguir entre las imágenes de gatos y perros también puede identificar imágenes de pájaros. En estos casos, las clases cubiertas se conocen como clases “vistas”, mientras que las instancias de entrenamiento no etiquetadas se denominan clases “no vistas”.
El conocimiento de la clase vista se puede transferir a las clases no vistas utilizando un espacio vectorial de alta dimensión llamado espacio semántico. Al aprovechar el espacio semántico, así como una representación de características visuales del contenido de la imagen, ZSL puede resolverse proyectando el vector de características visuales y el prototipo en un espacio de incrustación combinado. La proyección de un vector de características de imagen se compara con la clase invisible mediante la búsqueda de vecinos más cercanos (NNS).
Zero-Shot Learning es un subcampo de Transfer Learning, ya que el zero-shot learning transfiere el conocimiento obtenido de las instancias de entrenamiento a la clasificación de instancias de prueba.
Hay tres componentes principales de ZSL de los que depende todo el proceso de aprendizaje.
- Las clases de datos utilizadas para entrenar el modelo de aprendizaje profundo que se llama Clases vistas
- Las clases de datos utilizadas con fines de validación en las que el modelo profundo existente debe generalizarse son Clases invisibles.
- Como no hay conocimiento previo sobre las clases invisibles, algunos información auxiliar es necesario para resolver el problema de aprendizaje Zero-Shot. La información auxiliar contiene información como descripciones, información semántica o incrustaciones de palabras relacionadas con clases no vistas.
Comprendamos cómo usar ZSL para sintetizar imágenes a partir de descripciones de texto.
¿Está buscando un repositorio completo de bibliotecas de Python utilizadas en ciencia de datos, echa un vistazo aquí.
¿Cómo funciona la generación de texto a imagen Zero-shot?
El objetivo es maximizar la Límite inferior de evidencia (ELB) sobre la probabilidad conjunta de la distribución del modelo sobre las imágenes, la descripción de la imagen y los tokens para la imagen RGB codificada.
- El límite inferior de evidencia es la técnica estadística para aproximar la función de log-verosimilitud. Es una parte de la inferencia bayesiana variacional. Entonces, la evidencia aquí es la función de probabilidad logarítmica y el límite inferior es el método que ayuda a aproximar la función.
Si los píxeles se usaran directamente como tokens de imagen, las imágenes de alta resolución requerirían una cantidad excesiva de memoria. El objetivo de probabilidad tiende a priorizar el modelado de dependencias de corto alcance entre píxeles, por lo que gran parte de la capacidad de modelado se dedicaría a registrar detalles de alta frecuencia, en lugar de desarrollar la estructura de baja frecuencia que hace que los objetos sean visualmente reconocibles. Todo el proceso podría dividirse en dos etapas, lo que facilitará el procedimiento de capacitación para el alumno.
Autocodificador variacional discreto de entrenamiento
Cada imagen RGB se comprime mediante un codificador automático variacional discreto (dVAE) en tokens de imagen más pequeños, cada elemento de los cuales puede asumir miles de valores posibles. Esto reduce el tamaño del contexto del transformador sin una gran degradación en la calidad visual y acelera el proceso de entrenamiento. Este proceso es similar a cómo podemos etiquetar diferentes cosas desde un lugar distante, incluso si no está en una visión clara porque hemos entrenado nuestra mente para reconocer con solo ver el contorno y los gradientes de las cosas.
Ahora necesitamos establecer la inicial antes de la distribución categórica uniforme sobre los vectores de libro de códigos de valores posibles, y estos vectores deben parametrizarse en la misma posición espacial que la salida de imagen más pequeña del codificador. El límite inferior de evidencia (ELB) ahora se vuelve difícil de optimizar, ya que el anterior inicial se convierte en una distribución discreta.
Entonces, necesitamos convertir la distribución categórica en una distribución continua al refactorizar la muestra en una función determinista de los parámetros y algún ruido independiente con la distribución fija. Este proceso también se llama relajación. Para realizar este tipo de operación, el truco de Gumbile es perfecto. Una vez que el factor de temperatura de la codificación de un vector caliente de Gumbile tiende a infinito, la distribución comienza a volverse uniforme. Ahora, el promedio de iteración ponderado exponencialmente se utiliza para maximizar el ELB relajado. La probabilidad de la distribución sobre las imágenes RGB generadas por el decodificador dVAE se evalúa utilizando la distribución log-Laplace.
Las pérdidas de entropía cruzada deben normalizarse para los tokens de texto e imagen por el número total de cada tipo en un lote de datos. Dado que estamos interesados principalmente en el modelado de imágenes, multiplicamos la pérdida de entropía cruzada del texto por 1/8 y la pérdida de entropía cruzada de la imagen por 7/8.
Antes de aprender
Esta etapa se enfoca en concatenar los tokens de texto codificado con los tokens de imagen convertidos más pequeños y entrena al alumno con un transformador autorregresivo.
Para codificar texto-imagen se utiliza Byte-Pair Encoding (BPE) que codifica las descripciones en minúsculas y la imagen utilizando tokens con vocabulario. Para garantizar que a las palabras que aparecen con frecuencia en el vocabulario se les asigne un solo token, las palabras más raras se dividen en múltiples tokens. Como se explicó anteriormente, el logit del codificador dVAE se utiliza para generar tokens de imagen. Luego, los tokens de texto e imagen se concatenan y se modelan autorregresivamente como un flujo de datos.
Aquí, un transformador disperso de 12 mil millones de parámetros aprende la distribución previa sobre los tokens de texto e imagen al maximizar el ELB. El modelo utiliza tres tipos de máscaras de atención dispersa para asignar cada token de imagen a una de sus 64 capas de atención propia.
- La máscara de atención convolucional solo se usa en la última capa de autoatención.
- La máscara de atención de la fila
- La máscara de atención de la columna
Las partes de las máscaras de atención para la atención de texto a texto usan la máscara causal estándar, y las partes de la atención de imagen a imagen usan una máscara de atención de fila, columna o convolucional.
El flujo de trabajo anterior es para el transformador en el que se utilizan dos procesos: propagación hacia adelante y propagación hacia atrás. La línea continua indica la propagación hacia adelante y la línea discontinua es la secuencia de operaciones para la propagación hacia atrás. Cuando el algoritmo de retropropagación opera desde la capa de salida hacia la capa de entrada (hacia atrás), los gradientes se reducen y se acercan a cero, lo que eventualmente deja los pesos de las capas inferiores casi sin cambios. Como resultado, el descenso del gradiente nunca converge al óptimo.
Esto plantea el problema de la desaparición de los gradientes. De manera similar, en la propagación hacia adelante, los gradientes siguen aumentando. Esto, a su vez, provoca actualizaciones de peso muy grandes y hace que el descenso del gradiente diverja y surja el problema de los gradientes explosivos.
Mecanismo de bloque residual (Fuente de la imagen)Para hacer frente a estos problemas, se utiliza el bloque residual o ResBlock, que es diferente del proceso de red tradicional. A medida que los datos se transfieren de una capa a otra colocando 2 o 3 capas. En la representación anterior, se puede ver que la identidad ‘x’ escapa de una capa y salta a otra.
Las activaciones y gradientes a lo largo de la ruta de identidad se almacenan con una precisión de 32 bits. La operación de “filtro” establece todos los valores infinitos y faltantes en el gradiente de activación a cero. Sin esto, un evento no finito en el Resblock actual haría que las escalas de gradiente de todos los Resblocks anteriores cayesen innecesariamente, lo que resultaría en un subdesbordamiento.
Generación de imágenes con DALL-E Mini
Usaremos Hugging face DALL-E mini, un modelo preentrenado que funciona en ZSL para generar imágenes a partir de descripciones de texto.
Instalación de bibliotecas necesarias
!pip install -q git+https://github.com/huggingface/transformers.git !pip install -q git+https://github.com/patil-suraj/vqgan-jax.git !pip install -q git +https://github.com/borisdayma/dalle-mini.git
Cargando DALL-E mini modelo y tokenizador
from dalle_mini import DalleBart, DalleBartProcessor from vqgan_jax.modeling_flax_vqgan import VQModel from transformers import CLIPProcessor, FlaxCLIPModel DALLE_MODEL = “dalle-mini/dalle-mini/wzoooa1c:latest” DALLE_COMMIT_ID = Ninguno VQGAN_REPO = “dalle-mini/vqgan_imagenet_f16_16384 ” VQGAN_COMMIT_ID = “e93a26e7707683d349bf5d5c41c5b0ef69b677a9” CLIP_REPO = “openai/clip-vit-large-patch14” CLIP_COMMIT_ID = Ninguno modelo = DalleBart.from_pretrained(DALLE_MODEL, revision=DALLE_COMMIT_ID) vqgan = VQModel.from_pretrained(VQGAN_REPO, revision=VQGAN_COMMIT_ID) clip = FlaxCLIPModel.from_pretrained(CLIP_REPO, revision= CLIP_COMMIT_ID) clip_processor = CLIPProcessor.from_pretrained(CLIP_REPO, revision=CLIP_COMMIT_ID)
El modelo Vqgan generará tokens para la descripción y las imágenes y el modelo Clip calculará las puntuaciones de la imagen generada. Aquí se usa la API Wandb, necesitará una clave para usar esta API que podría generarse fácilmente
Definición de la descripción de la imagen
Tomando dos descripciones de imágenes diferentes, una con complejidad y otra con menos complejidad para comprender el rendimiento del modelo.
descript = “Perro con ropa” tokenized_prompt = procesador ([descript]) tokenized_prompt = replicar (tokenized_prompt) descript_1 = “Tierra desde el espacio” tokenized_prompt_1 = procesador ([descript_1]) tokenized_prompt_1 = replicar (tokenized_prompt_1)
Generando imagen
from flax.training.common_utils import shard_prng_key import numpy as np from PIL import Image from tqdm.notebook import trange n_predictions = 10 gen_top_k = Ninguno gen_top_p = Ninguno temperatura = 0.85 cond_scale = 3.0 imágenes = []
for i in trange(max(n_predictions // jax.device_count(), 1)): key, subkey = jax.random.split(key) encoded_images = p_generate(tokenized_prompt, shard_prng_key(subkey), model.params, gen_top_k, gen_top_p , temperatura, cond_scale, ) encoded_images = encoded_images.sequences[…, 1:]
decoded_images = p_decode(encoded_images, vqgan.params) decoded_images = decoded_images.clip(0.0, 1.0).reshape((-1, 256, 256, 3)) para img en decoded_images: images.append(Image.fromarray(np.asarray (img * 255, dtype=np.uint8)))
Mostrar la imagen con la partitura
print(f”Solicitud: {descripción}\n”) para idx en logits.argsort()[::-1]: mostrar (imágenes[idx]) print(f”Puntuación: {logits[idx]:.2f}\n”)
Aquí hay dos muestras de imágenes generadas a partir de diez predicciones y podemos decir que se parece bastante a la descripción del texto.
Veamos la otra descripción con menos complejidad.
Entonces, a medida que la complejidad disminuye, se generan mejores imágenes.
Ultimas palabras
La implementación de Zero-Shot Learning en la generación de texto a imagen ha demostrado ser una gran solución para los desafíos que se enfrentan durante la síntesis de imágenes. Los modelos se entrenan con menos datos y la previsibilidad de las imágenes es sobresaliente. Este artículo proporciona el conocimiento de ZSL y cómo se utiliza para sintetizar imágenes a partir de descripciones de texto, así como una implementación de la teoría en Python. Puede experimentar con esto con los códigos vinculados a continuación.
