Diffusers documentation

Kandinsky 2.1

Diffusers

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Kandinsky 2.1

Kandinsky 2.1 fue creado por Arseniy Shakhmatov, Anton Razzhigaev, Aleksandr Nikolich, Vladimir Arkhipkin, Igor Pavlov, Andrey Kuznetsov y Denis Dimitrov.

La descripción de su página de GitHub es:

Kandinsky 2.1 hereda las mejores prácticas de Dall-E 2 y Latent diffusion, mientras introduce algunas ideas nuevas. Como codificador de texto e imagen, utiliza el modelo CLIP y un prior de difusión de imágenes (mapeo) entre los espacios latentes de las modalidades de CLIP. Este enfoque aumenta el rendimiento visual del modelo y abre nuevos horizontes en la fusión de imágenes y la manipulación de imágenes guiada por texto.

El código original se puede encontrar en ai-forever/Kandinsky-2.

Consulta la organización Kandinsky Community en el Hub para obtener los puntos de control oficiales de modelos para tareas como texto a imagen, imagen a imagen y relleno.

Asegúrate de consultar la guía de Schedulers para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección reutilizar componentes entre pipelines para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

Asegúrate de tener instaladas las siguientes bibliotecas.

# uncomment to install the necessary libraries in Colab
#!pip install -q diffusers transformers accelerate

¡El uso de Kandinsky 2.1 y 2.2 es muy similar! La única diferencia es que Kandinsky 2.2 no acepta prompt como entrada al decodificar los latentes. En su lugar, Kandinsky 2.2 solo acepta image_embeds durante la decodificación.

Kandinsky 3 tiene una arquitectura más concisa y no requiere un modelo previo. Esto significa que su uso es idéntico al de otros modelos de difusión como Stable Diffusion XL.

Texto a imagen

Para usar los modelos Kandinsky en cualquier tarea, siempre se comienza configurando el pipeline prior para codificar el prompt y generar los embeddings de la imagen. El pipeline prior también genera negative_image_embeds que corresponden al prompt negativo "". Para obtener mejores resultados, se puede pasar un negative_prompt real al pipeline prior, pero esto aumentará el tamaño de lote efectivo del pipeline prior por un factor de 2.

Kandinsky 2.1

Kandinsky 2.2

Kandinsky 3

🤗 Diffusers también proporciona una API de extremo a extremo con KandinskyCombinedPipeline y KandinskyV22CombinedPipeline, lo que significa que no es necesario cargar por separado el pipeline de prior y el pipeline de texto a imagen. El pipeline combinado carga automáticamente tanto el modelo de prior como el decodificador. Si lo deseas, aún puedes establecer valores diferentes para el pipeline de prior con los parámetros prior_guidance_scale y prior_num_inference_steps.

Use AutoPipelineForText2Image para llamar automáticamente a los pipelines combinados por debajo:

Kandinsky 2.1

Kandinsky 2.2

Imagen a imagen

Para la conversión de imagen a imagen, pase la imagen inicial y el prompt de texto para condicionar la imagen al pipeline. Comience cargando el pipeline anterior:

Kandinsky 2.1

Kandinsky 2.2

Kandinsky 3

Descarga una imagen para usarla como condición:

from diffusers.utils import load_image

# download image
url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
original_image = load_image(url)
original_image = original_image.resize((768, 512))

Genere los image_embeds y los negative_image_embeds con el pipeline anterior:

prompt = "A fantasy landscape, Cinematic lighting"
negative_prompt = "low quality, bad quality"

image_embeds, negative_image_embeds = prior_pipeline(prompt, negative_prompt).to_tuple()

Ahora, pasa la imagen original, así como todos los prompts y embeddings, a la pipeline para generar una imagen:

Kandinsky 2.1

Kandinsky 2.2

Kandinsky 3

🤗 Diffusers también proporciona una API de extremo a extremo con KandinskyImg2ImgCombinedPipeline y KandinskyV22Img2ImgCombinedPipeline, lo que significa que no es necesario cargar por separado el prior y el pipeline de imagen a imagen. El pipeline combinado carga automáticamente tanto el modelo prior como el decodificador. Si lo deseas, aún puedes establecer valores diferentes para el pipeline prior con los parámetros prior_guidance_scale y prior_num_inference_steps.

Use AutoPipelineForImage2Image para llamar automáticamente a los pipelines combinados por debajo:

Kandinsky 2.1

Kandinsky 2.2

Inpainting

⚠️ Los modelos Kandinsky ahora usan ⬜️ píxeles blancos para representar el área enmascarada en lugar de píxeles negros. Si estás usando KandinskyInpaintPipeline en producción, debes cambiar la máscara para que use píxeles blancos:
# For PIL input
import PIL.ImageOps
mask = PIL.ImageOps.invert(mask)

# For PyTorch and NumPy input
mask = 1 - mask

Para el inpainting, necesitarás la imagen original, una máscara del área a reemplazar en la imagen original y un prompt de texto de lo que se debe inpaintear. Carga el pipeline anterior:

Kandinsky 2.1

Kandinsky 2.2

Cargue una imagen inicial y cree una máscara:

init_image = load_image("https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png")
mask = np.zeros((768, 768), dtype=np.float32)
# mask area above cat's head
mask[:250, 250:-250] = 1

Genere los embeddings con el pipeline anterior:

prompt = "a hat"
prior_output = prior_pipeline(prompt)

Ahora, pasa la imagen inicial, la máscara, el prompt y los embeddings a la pipeline para generar una imagen:

Kandinsky 2.1

Kandinsky 2.2

También puedes usar los pipelines KandinskyInpaintCombinedPipeline y KandinskyV22InpaintCombinedPipeline de extremo a extremo para invocar los pipelines de prior y decodificador juntos por debajo. Usa AutoPipelineForInpainting para esto:

Kandinsky 2.1

Kandinsky 2.2

Interpolación

La interpolación le permite explorar el espacio latente entre los embeddings de imagen y texto, lo cual es una forma interesante de ver algunas de las salidas intermedias del modelo previo. Cargue el pipeline previo y dos imágenes que desee interpolar:

Kandinsky 2.1

Kandinsky 2.2

un gato

El cuadro La noche estrellada de Van Gogh

Especifique el texto o las imágenes a interpolar y establezca los pesos para cada texto o imagen. Experimente con los pesos para ver cómo afectan a la interpolación.

images_texts = ["a cat", img_1, img_2]
weights = [0.3, 0.3, 0.4]

Llama a la función interpolate para generar los embeddings y, a continuación, pásalos a la pipeline para generar la imagen:

Kandinsky 2.1

Kandinsky 2.2

ControlNet

⚠️ ControlNet solo se admite para Kandinsky 2.2.

ControlNet permite condicionar modelos de difusión preentrenados de gran tamaño con entradas adicionales, como un mapa de profundidad o la detección de bordes. Por ejemplo, puedes condicionar Kandinsky 2.2 con un mapa de profundidad para que el modelo comprenda y preserve la estructura de la imagen de profundidad.

Carguemos una imagen y extraigamos su mapa de profundidad:

from diffusers.utils import load_image

img = load_image(
    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinskyv22/cat.png"
).resize((768, 768))
img

Luego, puede usar el Pipeline de depth-estimation de 🤗 Transformers para procesar la imagen y obtener el mapa de profundidad:

import torch
import numpy as np

from transformers import pipeline

def make_hint(image, depth_estimator):
    image = depth_estimator(image)["depth"]
    image = np.array(image)
    image = image[:, :, None]
    image = np.concatenate([image, image, image], axis=2)
    detected_map = torch.from_numpy(image).float() / 255.0
    hint = detected_map.permute(2, 0, 1)
    return hint

depth_estimator = pipeline("depth-estimation")
hint = make_hint(img, depth_estimator).unsqueeze(0).half().to("cuda")  # or "mps", "xpu", "cpu"

Texto a imagen

Cargue el pipeline anterior y el KandinskyV22ControlnetPipeline:

from diffusers import KandinskyV22PriorPipeline, KandinskyV22ControlnetPipeline

prior_pipeline = KandinskyV22PriorPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-prior", dtype=torch.float16, use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

pipeline = KandinskyV22ControlnetPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-controlnet-depth", dtype=torch.float16
).to("cuda")

Genere los embeddings de imagen a partir de un prompt y un prompt negativo:

prompt = "A robot, 4k photo"
negative_prior_prompt = "lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature"

generator = torch.Generator(device="cuda").manual_seed(43)  # or "mps", "xpu", "cpu"

image_emb, zero_image_emb = prior_pipeline(
    prompt=prompt, negative_prompt=negative_prior_prompt, generator=generator
).to_tuple()

Finalmente, pase los embeddings de la imagen y la imagen de profundidad a KandinskyV22ControlnetPipeline para generar una imagen:

image = pipeline(image_embeds=image_emb, negative_image_embeds=zero_image_emb, hint=hint, num_inference_steps=50, generator=generator, height=768, width=768).images[0]
image

Imagen a imagen

Para image-to-image con ControlNet, necesitarás usar:

KandinskyV22PriorEmb2EmbPipeline para generar los embeddings de imagen a partir de un prompt de texto y una imagen
KandinskyV22ControlnetImg2ImgPipeline para generar una imagen a partir de la imagen inicial y los embeddings de la imagen

Procesa y extrae un mapa de profundidad de una imagen inicial de un gato con el Pipeline depth-estimation de 🤗 Transformers:

import torch
import numpy as np

from diffusers import KandinskyV22PriorEmb2EmbPipeline, KandinskyV22ControlnetImg2ImgPipeline
from diffusers.utils import load_image
from transformers import pipeline

img = load_image(
    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinskyv22/cat.png"
).resize((768, 768))

def make_hint(image, depth_estimator):
    image = depth_estimator(image)["depth"]
    image = np.array(image)
    image = image[:, :, None]
    image = np.concatenate([image, image, image], axis=2)
    detected_map = torch.from_numpy(image).float() / 255.0
    hint = detected_map.permute(2, 0, 1)
    return hint

depth_estimator = pipeline("depth-estimation")
hint = make_hint(img, depth_estimator).unsqueeze(0).half().to("cuda")  # or "mps", "xpu", "cpu"

Cargue el pipeline anterior y el KandinskyV22ControlnetImg2ImgPipeline:

prior_pipeline = KandinskyV22PriorEmb2EmbPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-prior", dtype=torch.float16, use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

pipeline = KandinskyV22ControlnetImg2ImgPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-controlnet-depth", dtype=torch.float16
).to("cuda")

Pase un prompt de texto y la imagen inicial a la pipeline prior para generar los embeddings de la imagen:

prompt = "A robot, 4k photo"
negative_prior_prompt = "lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature"

generator = torch.Generator(device="cuda").manual_seed(43)  # or "mps", "xpu", "cpu"

img_emb = prior_pipeline(prompt=prompt, image=img, strength=0.85, generator=generator)
negative_emb = prior_pipeline(prompt=negative_prior_prompt, image=img, strength=1, generator=generator)

Ahora puede ejecutar KandinskyV22ControlnetImg2ImgPipeline para generar una imagen a partir de la imagen inicial y los embeddings de imagen:

image = pipeline(image=img, strength=0.5, image_embeds=img_emb.image_embeds, negative_image_embeds=negative_emb.image_embeds, hint=hint, num_inference_steps=50, generator=generator, height=768, width=768).images[0]
make_image_grid([img.resize((512, 512)), image.resize((512, 512))], rows=1, cols=2)

Optimizaciones

Kandinsky es único porque requiere un pipeline previo para generar las correspondencias y un segundo pipeline para decodificar los latentes en una imagen. Los esfuerzos de optimización deben centrarse en el segundo pipeline, ya que es donde se realiza la mayor parte del cómputo. A continuación se presentan algunos consejos para mejorar Kandinsky durante la inferencia.

Habilita xFormers si estás usando PyTorch < 2.0:

  from diffusers import DiffusionPipeline
  import torch

  pipe = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16)
+ pipe.enable_xformers_memory_efficient_attention()

Habilite torch.compile si está usando PyTorch >= 2.0 para usar automáticamente scaled dot-product attention (SDPA):

  pipe.unet.to(memory_format=torch.channels_last)
+ pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)

Esto es lo mismo que establecer explícitamente el procesador de atención para usar AttnAddedKVProcessor2_0:

from diffusers.models.attention_processor import AttnAddedKVProcessor2_0

pipe.unet.set_attn_processor(AttnAddedKVProcessor2_0())

Descargue el modelo a la CPU con enable_model_cpu_offload() para evitar errores de memoria insuficiente:

  from diffusers import DiffusionPipeline
  import torch

  pipe = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16)
+ pipe.enable_model_cpu_offload()

Por defecto, el pipeline de texto a imagen utiliza DDIMScheduler, pero puedes reemplazarlo por otro programador, como DDPMScheduler, para ver cómo afecta al equilibrio entre la velocidad de inferencia y la calidad de la imagen:

from diffusers import DDPMScheduler
from diffusers import DiffusionPipeline

scheduler = DDPMScheduler.from_pretrained("kandinsky-community/kandinsky-2-1", subfolder="ddpm_scheduler")
pipe = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", scheduler=scheduler, dtype=torch.float16, use_safetensors=True).to("cuda")  # or "mps", "xpu", "cpu"

Diffusers

Kandinsky 2.1

Texto a imagen

Imagen a imagen

Inpainting

Interpolación

ControlNet

Texto a imagen

Imagen a imagen

Optimizaciones

KandinskyPriorPipeline

clase diffusers.KandinskyPriorPipeline

__call__

interpolate

KandinskyPipeline

clase diffusers.KandinskyPipeline

__call__

KandinskyCombinedPipeline

clase diffusers.KandinskyCombinedPipeline

__call__

enable_sequential_cpu_offload

KandinskyImg2ImgPipeline

clase diffusers.KandinskyImg2ImgPipeline

__call__

KandinskyImg2ImgCombinedPipeline

clase diffusers.KandinskyImg2ImgCombinedPipeline

__call__

enable_sequential_cpu_offload

KandinskyInpaintPipeline

clase diffusers.KandinskyInpaintPipeline

__call__

KandinskyInpaintCombinedPipeline

clase diffusers.KandinskyInpaintCombinedPipeline

__call__

enable_sequential_cpu_offload

call

call

call

call

call

call

call