Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /main /es /api /pipelines /kandinsky5_image.md

mishig

3 days ago

preview code

download

raw

27.8 kB

Kandinsky 5.0 Image

Kandinsky 5.0 es una familia de modelos de difusión para la generación de video e imágenes.

Kandinsky 5.0 Image Lite es un modelo ligero de generación de imágenes (6B parámetros).

El modelo introduce varias innovaciones clave:

Pipeline de difusión latente con Flow Matching para mejorar la estabilidad del entrenamiento
Diffusion Transformer (DiT) como columna vertebral generativa principal, con atención cruzada a los incrustados de texto
Codificación de texto dual usando Qwen2.5-VL y CLIP para una comprensión exhaustiva del texto
Flux VAE para la codificación y decodificación de imágenes de forma eficiente

El código original se puede encontrar en kandinskylab/Kandinsky-5.

Consulta la organización Kandinsky Lab en el Hub para los puntos de control oficiales de modelos para la generación de texto a video, que incluyen variantes preentrenadas, SFT, no-CFG y destiladas.

Modelos disponibles

Kandinsky 5.0 Image Lite:

model_id	Descripción	Casos de uso
kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers	Modelo de 6B de imágenes con ajuste fino supervisado	Mejor calidad de generación
kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers	Modelo de 6B para edición de imágenes con ajuste fino supervisado	Mejor calidad de generación
kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers	Modelo preentrenado base de imagen 6B	Investigación y ajuste fino
kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers	Modelo preentrenado base de edición de imágenes 6B	Investigación y ajuste fino

Ejemplos de uso

Generación básica de texto a imagen

import torch
from diffusers import Kandinsky5T2IPipeline

# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers"
pipe = Kandinsky5T2IPipeline.from_pretrained(model_id)
_ = pipe.to(device='cuda',dtype=torch.bfloat16)  # or "mps", "xpu", "cpu"

# Generate image
prompt = "A fluffy, expressive cat wearing a bright red hat with a soft, slightly textured fabric. The hat should look cozy and well-fitted on the cat’s head. On the front of the hat, add clean, bold white text that reads “SWEET”, clearly visible and neatly centered. Ensure the overall lighting highlights the hat’s color and the cat’s fur details."

output = pipe(
    prompt=prompt,
    negative_prompt="",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).image[0]

Generación básica de imagen a imagen

import torch
from diffusers import Kandinsky5I2IPipeline
from diffusers.utils import load_image 
# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers"
pipe = Kandinsky5I2IPipeline.from_pretrained(model_id)

_ = pipe.to(device='cuda',dtype=torch.bfloat16)  # or "mps", "xpu", "cpu"
pipe.enable_model_cpu_offload()                                               # <--- Enable CPU offloading for single GPU inference

# Edit the input image
image = load_image(
    "https://huggingface.co/kandinsky-community/kandinsky-3/resolve/main/assets/title.jpg?download=true"
)

prompt = "Change the background from a winter night scene to a bright summer day. Place the character on a sandy beach with clear blue sky, soft sunlight, and gentle waves in the distance. Replace the winter clothing with a light short-sleeved T-shirt (in soft pastel colors) and casual shorts. Ensure the character’s fur reflects warm daylight instead of cold winter tones. Add small beach details such as seashells, footprints in the sand, and a few scattered beach toys nearby. Keep the oranges in the scene, but place them naturally on the sand."
negative_prompt = ""

output = pipe(
    image=image,
    prompt=prompt,
    negative_prompt=negative_prompt,
    guidance_scale=3.5,
).image[0]

Kandinsky5T2IPipeline[[diffusers.Kandinsky5T2IPipeline]]

diffusers.Kandinsky5T2IPipeline[[diffusers.Kandinsky5T2IPipeline]]

diffusers.Kandinsky5T2IPipeline(transformer: Kandinsky5Transformer3DModel, vae: AutoencoderKL, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: FlowMatchEulerDiscreteScheduler)

Fuente

Parámetros:

transformer (Kandinsky5Transformer3DModel) : Transformer condicional para desruidar los latentes de imagen codificados.

vae (AutoencoderKL) : Modelo de Autoencoder Variacional black-forest-labs/FLUX.1-dev (vae) para codificar y decodificar videos a y desde representaciones latentes.

text_encoder (Qwen2_5_VLForConditionalGeneration) : codificador de texto congelado Qwen2.5-VL.

tokenizer (AutoProcessor) : Tokenizador para Qwen2.5-VL.

text_encoder_2 (CLIPTextModel) : CLIP congelado, específicamente la variante clip-vit-large-patch14.

tokenizer_2 (CLIPTokenizer) : Tokenizador para CLIP.

scheduler (FlowMatchEulerDiscreteScheduler) : Un programador para usar en combinación con transformer para desruidar los latentes de imagen codificados.

Pipeline para la generación de imágenes a partir de texto usando Kandinsky 5.0.

Este modelo hereda de DiffusionPipeline. Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

call[[diffusers.Kandinsky5T2IPipeline.call]]

__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 1024, width: int = 1024, num_inference_steps: int = 50, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, prompt_embeds_clip: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_clip: typing.Optional[torch.Tensor] = None, prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, negative_prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int, NoneType], diffusers.callbacks.PipelineCallback | diffusers.callbacks.MultiPipelineCallbacks]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)

Fuente

Parámetros:

prompt (str o list[str], opcional) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, pase prompt_embeds en su lugar.

negative_prompt (str o list[str], opcional) : El prompt o los prompts a evitar durante la generación de imágenes. Si no se define, pase negative_prompt_embeds en su lugar. Se ignora cuando no se usa guía (guidance_scale < 1).

height (int, por defecto 1024) : La altura en píxeles de la imagen generada.

width (int, por defecto 1024) : El ancho en píxeles de la imagen generada.

num_inference_steps (int, por defecto 50) : El número de pasos de desruido.

guidance_scale (float, por defecto 5.0) : Escala de guía definida en la guía libre de clasificador.

num_images_per_prompt (int, opcional, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (torch.Generator o list[torch.Generator], opcional) : Un generador de torch para hacer la generación determinista.

latents (torch.Tensor, opcional) : Latentes ruidosos pregenerados.

prompt_embeds_qwen (torch.Tensor, opcional) : Embeddings de texto de Qwen pregenerados.

prompt_embeds_clip (torch.Tensor, opcional) : Embeddings de texto CLIP pregenerados.

negative_prompt_embeds_qwen (torch.Tensor, opcional) : Embeddings de texto negativo de Qwen pregenerados.

negative_prompt_embeds_clip (torch.Tensor, opcional) : Embeddings de texto negativos de CLIP pregenerados.

prompt_cu_seqlens (torch.Tensor, opcional) : Longitudes de secuencia acumuladas pregeneradas para el prompt positivo de Qwen.

negative_prompt_cu_seqlens (torch.Tensor, opcional) : Longitudes de secuencia acumuladas pregeneradas para el prompt negativo de Qwen.

output_type (str, opcional, por defecto "pil") : El formato de salida de la imagen generada.

return_dict (bool, opcional, por defecto True) : Si se devuelve o no una KandinskyImagePipelineOutput.

callback_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, opcional) : Una función que se llama al final de cada paso de desruido.

callback_on_step_end_tensor_inputs (List, opcional) : La lista de entradas de tensor para la función callback_on_step_end.

max_sequence_length (int, por defecto 512) : La longitud máxima de la secuencia para la codificación de texto.

Devuelve: ~KandinskyImagePipelineOutput o tuple

Si return_dict es True, se devuelve KandinskyImagePipelineOutput; en caso contrario, se devuelve una tuple cuyo primer elemento es una lista con las imágenes generadas.

La función de llamada al pipeline para la generación de texto a imagen.

Ejemplos:

>>> import torch
>>> from diffusers import Kandinsky5T2IPipeline

>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers

>>> model_id = "kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers"
>>> pipe = Kandinsky5T2IPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe = pipe.to("cuda")

>>> prompt = "A cat and a dog baking a cake together in a kitchen."

>>> output = pipe(
...     prompt=prompt,
...     negative_prompt="",
...     height=1024,
...     width=1024,
...     num_inference_steps=50,
...     guidance_scale=3.5,
... ).frames[0]

check_inputs[[diffusers.Kandinsky5T2IPipeline.check_inputs]]

check_inputs(prompt, negative_prompt, height, width, prompt_embeds_qwen = None, prompt_embeds_clip = None, negative_prompt_embeds_qwen = None, negative_prompt_embeds_clip = None, prompt_cu_seqlens = None, negative_prompt_cu_seqlens = None, callback_on_step_end_tensor_inputs = None, max_sequence_length = None)

Fuente

Parámetros:

prompt : Prompt de entrada

negative_prompt : Prompt negativo para la guía

height : Altura de la imagen

width : Ancho de la imagen

prompt_embeds_qwen : Embeddings de prompts de Qwen precalculados

prompt_embeds_clip : Embeddings de prompts CLIP precalculados

negative_prompt_embeds_qwen : Embeddings de prompts negativos precalculados de Qwen

negative_prompt_embeds_clip : Embeddings de prompts negativos precalculados de CLIP

prompt_cu_seqlens : Longitudes de secuencia acumuladas precalculadas para el prompt positivo de Qwen

negative_prompt_cu_seqlens : Longitudes de secuencia acumuladas precalculadas para el prompt negativo de Qwen

callback_on_step_end_tensor_inputs : Entradas de tensor de callback

Excepciones: ValueError

ValueError -- Si las entradas no son válidas

Validar los parámetros de entrada del pipeline.

encode_prompt[[diffusers.Kandinsky5T2IPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], num_images_per_prompt: int = 1, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)

Fuente

Parámetros:

prompt (str o list[str]) : Prompt que se codificará.

num_images_per_prompt (int, opcional, valor predeterminado 1) : Número de imágenes a generar por indicación.

max_sequence_length (int, opcional, valor predeterminado 512) : Longitud máxima de la secuencia para la codificación de texto. Debe ser menor que 1024

device (torch.device, opcional) : Dispositivo de Torch.

dtype (torch.dtype, opcional) : dtype de Torch.

Devuelve: tuple[torch.Tensor, torch.Tensor, torch.Tensor]

Incrustaciones de texto de Qwen de forma (batch_size * num_images_per_prompt, sequence_length, embedding_dim)
CLIP pooled embeddings de forma (batch_size * num_images_per_prompt, clip_embedding_dim)
Longitudes de secuencia acumuladas (cu_seqlens) para los embeddings de Qwen de forma (batch_size * num_images_per_prompt + 1,)

Codifica un único prompt (positivo o negativo) en estados ocultos del codificador de texto.

Este método combina los embeddings de los codificadores de texto de Qwen2.5-VL y CLIP para crear representaciones de texto integrales para la generación de imágenes.

prepare_latents[[diffusers.Kandinsky5T2IPipeline.prepare_latents]]

prepare_latents(batch_size: int, num_channels_latents: int = 16, height: int = 1024, width: int = 1024, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None)

Fuente

Parámetros:

batch_size (int) : Número de imágenes a generar

num_channels_latents (int) : Número de canales en el espacio latente

height (int) : Altura de la imagen generada

width (int) : Ancho de la imagen generada

dtype (torch.dtype) : Tipo de datos para los latentes

device (torch.device) : Dispositivo en el que se crearán los latentes

generator (torch.Generator) : Generador de números aleatorios

latents (torch.Tensor) : Latentes existentes para usar

Devuelve: torch.Tensor

Tensor latente preparado

Prepara las variables latentes iniciales para la generación de imágenes a partir de texto.

Este método crea latentes de ruido aleatorio

Kandinsky5I2IPipeline[[diffusers.Kandinsky5I2IPipeline]]

diffusers.Kandinsky5I2IPipeline[[diffusers.Kandinsky5I2IPipeline]]

diffusers.Kandinsky5I2IPipeline(transformer: Kandinsky5Transformer3DModel, vae: AutoencoderKL, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: FlowMatchEulerDiscreteScheduler)

Fuente

Parámetros:

transformer (Kandinsky5Transformer3DModel) : Transformer condicional para desruidar los latentes de imagen codificados.

vae (AutoencoderKL) : Modelo de Autoencoder Variacional black-forest-labs/FLUX.1-dev (vae) para codificar y decodificar videos a y desde representaciones latentes.

text_encoder (Qwen2_5_VLForConditionalGeneration) : codificador de texto congelado Qwen2.5-VL.

tokenizer (AutoProcessor) : Tokenizador para Qwen2.5-VL.

text_encoder_2 (CLIPTextModel) : CLIP congelado, específicamente la variante clip-vit-large-patch14.

tokenizer_2 (CLIPTokenizer) : Tokenizador para CLIP.

scheduler (FlowMatchEulerDiscreteScheduler) : Un programador para usar en combinación con transformer para desruidar los latentes de imagen codificados.

Pipeline para la generación de imagen a imagen usando Kandinsky 5.0.

call[[diffusers.Kandinsky5I2IPipeline.call]]

__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, prompt_embeds_clip: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_clip: typing.Optional[torch.Tensor] = None, prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, negative_prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int, NoneType], diffusers.callbacks.PipelineCallback | diffusers.callbacks.MultiPipelineCallbacks]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 1024)

Fuente

Parámetros:

image (PipelineImageInput) : La imagen de entrada para condicionar la generación. Debe ser una imagen, una lista de imágenes o un torch.Tensor.

prompt (str o list[str], opcional) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, pase prompt_embeds en su lugar.

height (int) : La altura en píxeles de la imagen generada.

width (int) : El ancho en píxeles de la imagen generada.