diffusers/main/es/api/pipelines/kandinsky6.md

Kandinsky 6

Kandinsky 6 es una familia de modelos de generación de vídeo de Kandinsky Lab. El modelo principal genera vídeo y audio sincronizado a partir de texto o una imagen de referencia mediante un único transformador de difusión multimodal: los latentes de vídeo y audio se desruidan juntos a través de bloques fusionados que realizan atención cruzada entre las dos modalidades, cada una condicionada por su propia rama de texto Qwen2.5-VL y un embedding CLIP agrupado. Un modelo de superresolución separado aumenta la resolución del vídeo generado, mosaico a mosaico, en el espacio latente de un K-VAE 3D causal.

Consulta la organización Kandinsky Lab en el Hub para ver el conjunto completo de puntos de control oficiales, incluidas las variantes de flow-matching y destiladas de los modelos base y de superresolución.

Los puntos de control destilados se distribuyen con el PiflowScheduler de pocos pasos y deben ejecutarse con guidance_scale=1.0.

Modelos disponibles

Modelo	Pipeline	Notas
kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 pasos
kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers	Kandinsky6TI2VAPipeline	Destilado, guidance_scale=1.0, 10 pasos
kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 pasos
kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers	Kandinsky6TI2VAPipeline	Destilado, guidance_scale=1.0, 10 pasos
kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 pasos
kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 pasos
kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers	Kandinsky6SRPipeline	Superresolución mediante flujo de correspondencia
kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers	Kandinsky6SRPipeline	Superresolución destilada, 2 pasos

Texto/imagen a video y audio

import torch
from diffusers import Kandinsky6TI2VAPipeline
from diffusers.utils import encode_video

pipe = Kandinsky6TI2VAPipeline.from_pretrained(
    "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

output = pipe(
    prompt="A cat and a dog baking a cake together in a kitchen.",
    height=480,
    width=864,
    num_frames=121,
    num_inference_steps=10,
    guidance_scale=1.0,
)
encode_video(
    output.frames[0],
    fps=24,
    output_path="output.mp4",
    audio=output.audio[0][None],
    audio_sample_rate=pipe.audio_sample_rate,
)

Pase image= para condicionar el primer fotograma en una imagen de referencia, sample_audio=False para generar solo video y expand_prompts=True para que el codificador de texto Qwen2.5-VL reescriba primero los prompts cortos en prompts detallados.

Superresolución de video

Kandinsky6SRPipeline toma los fotogramas generados por Kandinsky6TI2VAPipeline y los aumenta en 2, 4 o 2.25 (un pre-aumento bilineal de 1.125x seguido de la ruta de 2x). El video se divide en mosaques superpuestos, cada mosaque se refina en uno de los tamaños de mosaque en los que se entrenó el transformador SR y los mosaques se combinan nuevamente con ventanas de Hann.

# required: lets inductor pick flex-attention tiles that fit the SR block mask
torch._inductor.config.max_autotune = True  

sr_pipe = Kandinsky6SRPipeline.from_pretrained(
    "kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers", torch_dtype=torch.bfloat16
)
# The SR transformer always runs NABLA sparse attention on the `flex` backend. Compile it, otherwise flex falls
# back to an eager implementation that needs far more memory at video resolutions.
sr_pipe.enable_model_cpu_offload()
sr_pipe.transformer.set_attention_backend("flex")
sr_pipe.transformer.compile_repeated_blocks(fullgraph=True)

upscaled = sr_pipe(video=output.frames[0], resolution_scale=2.25, num_inference_steps=2).frames[0]

Optimización de memoria

Consulte la guía Reduce memory usage para el conjunto general de técnicas. Tanto Kandinsky6TI2VAPipeline como Kandinsky6SRPipeline admiten model offloading (utilizado anteriormente) y, para una huella más pequeña a costa de la velocidad, sequential CPU offloading:

pipe.enable_sequential_cpu_offload()

El VAE de video de Kandinsky6TI2VAPipeline también admite decodificación por mosaicos para resoluciones altas o videos largos:

pipe.vae.enable_tiling()

Notas

• height y width deben ser divisibles por la relación de compresión espacial del VAE de video multiplicada por el tamaño de parche del transformer: 16 con la configuración predeterminada de Kandinsky6TI2VAPipeline (AutoencoderKLHunyuanVideo con una relación de compresión de 8 y patch_size=(1, 2, 2)). 480x864, utilizado en el ejemplo anterior, cumple esta condición.
• La entrada video de Kandinsky6SRPipeline debe tener 1 + k * vae_scale_factor_temporal fotogramas para algún entero k (una relación de compresión temporal de 4 con la configuración predeterminada de K-VAE, por lo que 121 fotogramas funciona pero 120 no) — recorta o rellena un video que no cumpla ya esta condición antes de aumentar su resolución.
• expand_prompts=True reutiliza el codificador de texto de Qwen2.5-VL ya cargado para una pasada de generación adicional antes del desruido, por lo que añade latencia pero no pesos de modelo adicionales.
• Compile los bloques de transformador repetidos para una inferencia repetida más rápida:

  pipe.transformer.compile_repeated_blocks(fullgraph=True)
  

Kandinsky6TI2VAPipeline[[diffusers.Kandinsky6TI2VAPipeline]]

diffusers.Kandinsky6TI2VAPipeline[[diffusers.Kandinsky6TI2VAPipeline]]

diffusers.Kandinsky6TI2VAPipeline(transformer: Kandinsky6Transformer3DModel, vae: AutoencoderKLHunyuanVideo, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2_5_VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowScheduler, audio_vae: diffusers.models.autoencoders.autoencoder_mmaudio.MMAudioVAE | None = None, vocoder: diffusers.models.autoencoders.mmaudio_vocoder.MMAudioVocoder | None = None)

Fuente

Parámetros:

transformer (Kandinsky6Transformer3DModel) : Transformer multimodal que desruidifica los latentes de video y audio.

vae (AutoencoderKLHunyuanVideo) : VAE de video utilizado para codificar la imagen de referencia y decodificar el video generado.

text_encoder (Qwen2_5_VLForConditionalGeneration) : modelo Qwen2.5-VL que proporciona las incrustaciones de texto a nivel de token y, opcionalmente, la expansión del prompt.

tokenizer (Qwen2_5_VLProcessor) : Procesador de text_encoder.

text_encoder_2 (CLIPTextModel): codificador de texto de CLIP que proporciona la incrustación de texto agrupada.

tokenizer_2 (CLIPTokenizer) : Tokenizador de text_encoder_2.

scheduler (FlowMatchEulerDiscreteScheduler o PiflowScheduler): programador utilizado con transformer para desruidar los latentes. Los puntos de control destilados incluyen un PiflowScheduler y deben ejecutarse con guidance_scale=1.0.

audio_vae (MMAudioVAE, opcional) : VAE de audio utilizado para decodificar los latentes de audio generados en un espectrograma mel. Solo es necesario cuando sample_audio=True.

vocoder (MMAudioVocoder, opcional) : Vocoder utilizado para convertir el espectrograma mel que decodifica audio_vae en una forma de onda. Solo es necesario cuando sample_audio=True.

Pipeline para la generación de video y audio a partir de texto/imagen con Kandinsky 6.

Los latentes de video y audio se desruidan juntos mediante un único transformer multimodal, condicionado por tokens de texto de Qwen2.5-VL y un embedding agrupado de CLIP. Una imagen de referencia opcional condiciona el primer fotograma.

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.Kandinsky6TI2VAPipeline.call]]

__call__(prompt: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, num_inference_steps: int = 50, timesteps: list[int] | None = None, sigmas: list[float] | None = None, guidance_scale: float = 5.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, sample_audio: bool = True, expand_prompts: bool = False, max_sequence_length: int = 1024, output_type: str = 'pil', return_dict: bool = True, callback_on_step_end: collections.abc.Callable[[int, int, dict], None] | None = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'])

Fuente

Parámetros:

prompt (str o list[str], opcional) : El prompt o los prompts para guiar la generación. Obligatorio a menos que se proporcione prompt_embeds.

image (PipelineImageInput, opcional) : Imagen(es) de referencia que condicionan el primer fotograma (de imagen a vídeo y audio).

negative_prompt (str o list[str], opcional) : El prompt o prompts que no deben guiar la generación. Por defecto, se utiliza el prompt negativo de Kandinsky 6.

height (int, por defecto 512) : Altura del video generado en píxeles.

width (int, por defecto 768) : Ancho del video generado en píxeles.

num_frames (int, por defecto 121) : Número de fotogramas generados.

frame_rate (float, por defecto 24.0) : Tasa de fotogramas a la que se genera el vídeo; define la duración del audio sincronizado.

num_inference_steps (int, por defecto 50) : El número de pasos de desruido. Usa 16 con los puntos de control destilados.

timesteps (list[int], opcional) : Pasos de tiempo personalizados para programadores que los admiten.

sigmas (list[float], opcional) : Sigmas personalizados para programadores que los admiten.

guidance_scale (float, por defecto 5.0) : Escala de guía libre de clasificador. Debe ser 1.0 con un PiflowScheduler.

num_videos_per_prompt (int, por defecto 1) : El número de vídeos a generar por prompt.

generator (torch.Generator o list[torch.Generator], opcional) : Generador(es) utilizados para el ruido inicial y la codificación de la imagen de referencia.

latents (torch.Tensor, opcional) : Latentes de video pregenerados de forma (batch_size, channels, num_latent_frames, latent_height, latent_width).

audio_latents (torch.Tensor, opcional) : Latentes de audio pregenerados de forma (batch_size, channels, audio_length).

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto de Qwen2.5-VL pregenerados.

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

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativos pregenerados de Qwen2.5-VL.

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

sample_audio (bool, por defecto True) : Si se debe generar audio sincronizado. Requiere que el pipeline tenga un audio_vae y un vocoder.

expand_prompts (bool, por defecto False) : Si se reescriben los prompts con expand_prompts() antes de codificarlos.

max_sequence_length (int, por defecto 1024) : Número máximo de tokens de prompt después de la plantilla de chat.

output_type (str, por defecto "pil") : El formato de salida del video generado: "pil", "np", "pt" o "latent".

return_dict (bool, por defecto True) : Si se debe devolver una Kandinsky6TI2VAPipelineOutput en lugar de una tupla simple.

callback_on_step_end (Callable, opcional) : Una función que se llama al final de cada paso de desruido con callback_on_step_end(self, step, timestep, callback_kwargs). Puede devolver un diccionario que sobrescriba los tensores enumerados.

callback_on_step_end_tensor_inputs (list[str], por defecto ["latents"]) : Entradas de tensor pasadas a callback_on_step_end; un subconjunto de _callback_tensor_inputs.

Devuelve: Kandinsky6TI2VAPipelineOutput o tuple

El video y el audio generados; una tupla (frames, audio) cuando return_dict=False.

La función de llamada para el pipeline de generación.

Ejemplos:

>>> import torch
>>> from diffusers import Kandinsky6TI2VAPipeline
>>> from diffusers.utils import encode_video

>>> pipe = Kandinsky6TI2VAPipeline.from_pretrained(
...     "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16
... )
>>> pipe.enable_model_cpu_offload()

>>> output = pipe(
...     prompt="A cat and a dog baking a cake together in a kitchen.",
...     height=480,
...     width=864,
...     num_frames=121,
...     num_inference_steps=16,
...     guidance_scale=1.0,
... )
>>> encode_video(
...     output.frames[0],
...     fps=24,
...     output_path="output.mp4",
...     audio=output.audio[0][None],
...     audio_sample_rate=pipe.audio_sample_rate,
... )

encode_image[[diffusers.Kandinsky6TI2VAPipeline.encode_image]]

encode_image(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], height: int, width: int, device: device, dtype: dtype, num_videos_per_prompt: int = 1, generator: typing.Optional[torch.Generator] = None)

Fuente

Codifica la(s) imagen(es) de referencia en latentes del primer fotograma de forma (batch_size, latent_height, latent_width, latent_channels), escalados por el scaling_factor del VAE. Las imágenes PIL se redimensionan y recortan por el centro a height x width; los tensores y arreglos deben tener ya ese tamaño. Los latentes se repiten num_videos_per_prompt veces a lo largo de la dimensión de lote.

encode_prompt[[diffusers.Kandinsky6TI2VAPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)

Fuente

Parámetros:

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

negative_prompt (str o list[str], opcional) : El prompt que no debe guiar la generación. Se ignora cuando do_classifier_free_guidance es False.

do_classifier_free_guidance (bool, por defecto True) : Si se debe codificar también el prompt negativo.

num_videos_per_prompt (int, por defecto 1) : Número de vídeos generados por prompt; los embeddings se repiten en consecuencia.

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto de Qwen2.5-VL pregenerados. Omite la codificación de prompt.

pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto CLIP pregenerados. Debe proporcionarse junto con prompt_embeds.

prompt_attention_mask (torch.Tensor, opcional) : Máscara booleana de relleno para prompt_embeds.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativos pregenerados de Qwen2.5-VL.

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

negative_prompt_attention_mask (torch.Tensor, opcional) : Máscara booleana de relleno para negative_prompt_embeds.

max_sequence_length (int, por defecto 1024) : Número máximo de tokens de prompt después de la plantilla de chat.

device (torch.device, opcional) : Dispositivo en el que se ejecutarán los codificadores de texto.

dtype (torch.dtype, opcional) : Dtype de las incrustaciones devueltas.

Codifica el prompt en estados ocultos del codificador de texto.

expand_prompts[[diffusers.Kandinsky6TI2VAPipeline.expand_prompts]]

expand_prompts(prompt: str | list[str], tokenizer, text_encoder, device: device, image: PIL.Image.Image | list[PIL.Image.Image] | None = None, max_sequence_length: int = 1024, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None)

Fuente

Parámetros:

prompt (str o list[str]) : Prompt o prompts para expandir.

tokenizer : El procesador de Qwen2.5-VL, por ejemplo, pipe.tokenizer.

text_encoder : El modelo Qwen2.5-VL, por ejemplo, pipe.text_encoder.

device (torch.device) : Dispositivo en el que se ejecuta el codificador de texto.

image (PIL.Image.Image o list[PIL.Image.Image], opcional) : Imagen(es) de referencia de una llamada de imagen a video.

max_sequence_length (int, por defecto 1024) : Número máximo de tokens generados por prompt.

generator (torch.Generator o list[torch.Generator], opcional) : Siembra la expansión muestreada; una lista debe coincidir con la longitud de prompt, un generador por elemento. generate extrae del RNG global, por lo que el RNG global se siembra con la semilla de este generador; las llamadas posteriores a randn_tensor siguen usando generator directamente.

Devuelve: str o list[str]

El (los) prompt(s) expandido(s).

Reescribe prompts cortos en prompts detallados de video y audio con el codificador de texto Qwen2.5-VL, anclándolos en la imagen de referencia cuando se proporciona una. Es un staticmethod para que pueda usarse de forma independiente, antes de ejecutar el pipeline.

prepare_audio_latents[[diffusers.Kandinsky6TI2VAPipeline.prepare_audio_latents]]

prepare_audio_latents(batch_size: int, num_channels_latents: int, audio_length: int, dtype: dtype, device: device, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType], audio_latents: typing.Optional[torch.Tensor] = None)

Fuente

Devuelve los latentes de audio en el formato (batch_size, audio_length, channels) del transformer. Se espera que el tensor audio_latents proporcionado por el usuario esté en el formato (batch_size, channels, audio_length).

prepare_latents[[diffusers.Kandinsky6TI2VAPipeline.prepare_latents]]

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

Fuente

Devuelve los latentes de video en el formato (batch_size, num_frames, height, width, channels) del transformer. Se espera que el tensor latents proporcionado por el usuario esté en el formato (batch_size, channels, num_frames, height, width).

Kandinsky6SRPipeline[[diffusers.Kandinsky6SRPipeline]]

diffusers.Kandinsky6SRPipeline[[diffusers.Kandinsky6SRPipeline]]

diffusers.Kandinsky6SRPipeline(transformer: Kandinsky6SRTransformer3DModel, vae: Kandinsky6SRVAE, scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowScheduler, latent_upscaler: diffusers.models.latent_upscaler.latent_upscaler_kandinsky6_sr.Kandinsky6SRLatentUpscalerBank | None = None)

Fuente

Parámetros:

transformer (Kandinsky6SRTransformer3DModel) : Transformer que refina los mosaicos latentes.

vae (Kandinsky6SRVAE) : K-VAE de video causal utilizado para codificar el video de entrada y decodificar los mosaicos refinados.

scheduler (FlowMatchEulerDiscreteScheduler o PiflowScheduler): programador utilizado con transformer para desruidar los mosaicos. Los puntos de control destilados incluyen un PiflowScheduler.

latent_upscaler (Kandinsky6SRLatentUpscalerBank, opcional) : Upscalers latentes para las escalas admitidas.

Pipeline para super-resolución de video con Kandinsky 6.

El video se divide en mosaicos espaciales superpuestos, cada mosaico se refina mediante el transformador SR en uno de los tamaños de mosaico en los que se entrenó el modelo (transformer.config.tile_sizes), y los mosaicos refinados se combinan nuevamente con ventanas de Hann. Cuando el pipeline tiene un latent_upscaler, los mosaicos se recortan de los latentes K-VAE del video completo y se escalan en el espacio latente; de lo contrario, los mosaicos de píxeles se escalan de forma bilineal y se codifican.

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.Kandinsky6SRPipeline.call]]

__call__(video: typing.Union[list[PIL.Image.Image], list[list[PIL.Image.Image]], numpy.ndarray, torch.Tensor], resolution_scale: float = 2.25, num_inference_steps: int = 4, timesteps: list[int] | None = None, sigmas: list[float] | None = None, lq_noise_scale: float = 0.7, min_overlap: float = 0.2, tiles_batch_size: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str = 'pil', return_dict: bool = True)

Fuente

Parámetros:

video (list[PIL.Image.Image], np.ndarray o torch.Tensor) : El/los video(s) de baja resolución, en cualquier formato que acepte preprocess_video(), con 1 + k * 4 fotogramas. Los tamaños se redondean hacia abajo a un múltiplo del factor espacial del VAE.

resolution_scale (float, por defecto 2.25) : Ampliación espacial total: 2, 4 o 2.25 (una preampliación bilineal de 1.125x seguida de la ruta de 2x).

num_inference_steps (int, por defecto 4) : El número de pasos de desruido por mosaico. Usa 2 con los puntos de control destilados.

timesteps (list[int], opcional) : Pasos de tiempo personalizados para programadores que los admiten.

sigmas (list[float], opcional) : Sigmas personalizados para programadores que los admiten.

lq_noise_scale (float, por defecto 0.7) : Cantidad de ruido gaussiano mezclado en los latentes de baja resolución (que preserva la varianza) antes del desruido.

min_overlap (float, por defecto 0.2) : Solapamiento mínimo entre los mosaicos vecinos, expresado como una fracción del tamaño del mosaico.

tiles_batch_size (int, por defecto 1) : Número de mosaicos desruidados por llamada al transformer.

generator (torch.Generator o list[torch.Generator], opcional) : Generador(es) utilizados para el ruido mezclado en los mosaicos.

output_type (str, por defecto "pil") : El formato de salida del video generado: "pil", "np" o "pt".

return_dict (bool, por defecto True) : Si se debe devolver una Kandinsky6SRPipelineOutput en lugar de una tupla simple.

Devuelve: Kandinsky6SRPipelineOutput o tuple

El video superresuelto; una tupla de un elemento cuando return_dict=False.

La función de llamada para la pipeline de super-resolución.

Ejemplos:

>>> import torch
>>> from diffusers import Kandinsky6SRPipeline, Kandinsky6TI2VAPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = Kandinsky6TI2VAPipeline.from_pretrained(
...     "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16
... )
>>> pipe.enable_model_cpu_offload()
>>> video = pipe(
...     prompt="A cat and a dog baking a cake together in a kitchen.",
...     height=480,
...     width=864,
...     num_inference_steps=16,
...     guidance_scale=1.0,
...     sample_audio=False,
... ).frames[0]

>>> sr_pipe = Kandinsky6SRPipeline.from_pretrained(
...     "kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers", torch_dtype=torch.bfloat16
... )
>>> # The transformer always runs attention through the `flex` backend; compiling avoids the eager
>>> # fallback's much higher memory use at video resolutions.
>>> sr_pipe.transformer.compile_repeated_blocks(fullgraph=True)
>>> sr_pipe.enable_model_cpu_offload()
>>> output = sr_pipe(video=video, resolution_scale=2.25, num_inference_steps=2)
>>> export_to_video(output.frames[0], "output_sr.mp4", fps=24)

decode_latents[[diffusers.Kandinsky6SRPipeline.decode_latents]]

decode_latents(latents: Tensor)

Fuente

Decodifica los latentes K-VAE escalados en un video de (batch_size, channels, num_frames, height, width) en [-1, 1].

encode_video[[diffusers.Kandinsky6SRPipeline.encode_video]]

encode_video(video: Tensor)

Fuente

Codifica un video de (batch_size, channels, num_frames, height, width) en [-1, 1] en latentes K-VAE escalados por el scaling_factor del VAE.

Kandinsky6SRLatentUpscalerBank[[diffusers.Kandinsky6SRLatentUpscalerBank]]

diffusers.Kandinsky6SRLatentUpscalerBank[[diffusers.Kandinsky6SRLatentUpscalerBank]]

diffusers.Kandinsky6SRLatentUpscalerBank(in_channels: int = 64, stage_channels: tuple[int, int, int] = (2048, 1024, 512), num_pre_blocks: int = 5, num_mid_blocks: int = 3, num_post_blocks: int = 3, num_x2_adapter_blocks: int = 2, scales: tuple[int, ...] = (2, 4), scaling_factor: float = 0.910344004631042)

Fuente

Parámetros:

in_channels (int, por defecto 64) : Número de canales latentes.

stage_channels (tuple[int, int, int], por defecto (2048, 1024, 512)) : Anchos de las características de las tres etapas de la cascada.

num_pre_blocks (int, por defecto 5) : Bloques residuales antes del primer upsample del modelo x4.

num_mid_blocks (int, por defecto 3) : Bloques residuales entre las dos operaciones de aumento de escala.

num_post_blocks (int, por defecto 3) : Bloques residuales después del último upsample.

num_x2_adapter_blocks (int, por defecto 2) : Bloques residuales del adaptador del modelo x2.

scales (tuple[int, ...], por defecto (2, 4)) : Escalas espaciales para las que el banco proporciona un amplificador.

scaling_factor (float, por defecto 0.910344) : Escala que se espera que tengan los latentes de entrada (el scaling_factor del K-VAE).

Banco de escaladores latentes utilizado por Kandinsky6SRPipeline: un Kandinsky6SRLatentUpscaler por cada escala espacial admitida, que opera sobre latentes de K-VAE.

forward[[diffusers.Kandinsky6SRLatentUpscalerBank.forward]]

forward(latents: Tensor, scale: int, return_dict: bool = True)

Fuente

Parámetros:

latents (torch.Tensor de forma (batch_size, in_channels, num_frames, height, width)) : latentes de K-VAE escalados por scaling_factor.

scale (int) : Factor de ampliación espacial; uno de scales.

return_dict (bool, por defecto True) : Si se debe devolver un ~models.autoencoder_kl.DecoderOutput en lugar de una tupla simple.

Devuelve:

Los latentes ampliados de forma (batch_size, in_channels, num_frames, height * scale, width * scale).

Kandinsky6TI2VAPipelineOutput[[diffusers.Kandinsky6TI2VAPipelineOutput]]

diffusers.Kandinsky6TI2VAPipelineOutput[[diffusers.Kandinsky6TI2VAPipelineOutput]]

diffusers.Kandinsky6TI2VAPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]], audio: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None)

Fuente

Parámetros:

frames (torch.Tensor, np.ndarray o list[list[PIL.Image.Image]]) : El video generado. Una lista anidada de longitud batch_size que contiene num_frames imágenes PIL cada una, o un array de NumPy o un tensor de torch de forma (batch_size, num_frames, height, width, channels) / (batch_size, num_frames, channels, height, width). Con output_type="latent", los latentes del video de forma (batch_size, channels, num_latent_frames, latent_height, latent_width).

audio (torch.Tensor o np.ndarray, opcional) : Las formas de onda generadas de forma (batch_size, num_samples) en [-1, 1] a la tasa de muestreo del VAE de audio, o None cuando no se muestreó el audio. Con output_type="latent", los latentes de audio de forma (batch_size, channels, audio_length).

Clase de salida para Kandinsky6TI2VAPipeline.

Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]]

diffusers.Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]]

diffusers.Kandinsky6SRPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]])

Fuente

Parámetros:

frames (torch.Tensor, np.ndarray o list[list[PIL.Image.Image]]) : El video superresuelto. Una lista anidada de longitud batch_size que contiene num_frames imágenes PIL cada una, o un array de NumPy o un tensor de torch de forma (batch_size, num_frames, height, width, channels) / (batch_size, num_frames, channels, height, width).

Clase de salida para Kandinsky6SRPipeline.