Hugging Face's logo

Diffusers documentation

Kandinsky 6

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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 agrupado de CLIP. 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 causal 3D.

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

ModeloPipelineNotas
kandinskylab/Kandinsky-6.0-Pro-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 pasos
kandinskylab/Kandinsky-6.0-Pro-distill-5s-DiffusersKandinsky6TI2VAPipelineDestilado, guidance_scale=1.0, 10 pasos
kandinskylab/Kandinsky-6.0-Lite-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 pasos
kandinskylab/Kandinsky-6.0-Lite-distill-5s-DiffusersKandinsky6TI2VAPipelineDestilado, guidance_scale=1.0, 10 pasos
kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 pasos
kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 pasos
kandinskylab/Kandinsky-6.0-VSR-5s-DiffusersKandinsky6SRPipelineSuperresolución mediante flujo de correspondencia
kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-DiffusersKandinsky6SRPipelineSuperresolució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 altas resoluciones 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.
  • Compila los bloques de transformer repetidos para una inferencia repetida más rápida: 
    pipe.transformer.compile_repeated_blocks(fullgraph=True)

Kandinsky6TI2VAPipeline

clase diffusers.Kandinsky6TI2VAPipeline

< >

( transformer: Kandinsky6Transformer3DModelvae: AutoencoderKLHunyuanVideotext_encoder: Qwen2_5_VLForConditionalGenerationtokenizer: Qwen2_5_VLProcessortext_encoder_2: CLIPTextModeltokenizer_2: CLIPTokenizerscheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowScheduleraudio_vae: diffusers.models.autoencoders.autoencoder_mmaudio.MMAudioVAE | None = Nonevocoder: diffusers.models.autoencoders.mmaudio_vocoder.MMAudioVocoder | None = None )

Parámetros

  • transformer (Kandinsky6Transformer3DModel) — Transformador 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) — Tokenizer 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__

< >

( prompt: str | list[str] | None = Noneimage: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonenegative_prompt: str | list[str] | None = Noneheight: int = 512width: int = 768num_frames: int = 121frame_rate: float = 24.0num_inference_steps: int = 50timesteps: list[int] | None = Nonesigmas: list[float] | None = Noneguidance_scale: float = 5.0num_videos_per_prompt: int = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneaudio_latents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonepooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonesample_audio: bool = Trueexpand_prompts: bool = Falsemax_sequence_length: int = 1024output_type: str = 'pil'return_dict: bool = Truecallback_on_step_end: collections.abc.Callable[[int, int, dict], None] | None = Nonecallback_on_step_end_tensor_inputs: list[str] = ['latents'] ) → Kandinsky6TI2VAPipelineOutput or tuple

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 video 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) — Frecuencia 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 que se generarán 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) — Incrustaciones de texto de Qwen2.5-VL pregeneradas.
  • pooled_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto CLIP agrupadas pregeneradas.
  • negative_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto negativas de Qwen2.5-VL pregeneradas.
  • negative_pooled_prompt_embeds (torch.Tensor, opcional) — Embeddings de texto CLIP 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 del 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) — Indica si se debe devolver un 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

< >

( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]height: intwidth: intdevice: devicedtype: dtypenum_videos_per_prompt: int = 1generator: typing.Optional[torch.Generator] = None )

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

< >

( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonepooled_prompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 1024device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )

Parámetros

  • prompt (str o list[str]) — Prompt a 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) — Incrustaciones de texto de Qwen2.5-VL pregeneradas. Omite la codificación de prompt.
  • pooled_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto CLIP agrupadas pregeneradas. Debe proporcionarse junto con prompt_embeds.
  • prompt_attention_mask (torch.Tensor, opcional) — Máscara booleana de relleno de prompt_embeds.
  • negative_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto negativas de Qwen2.5-VL pregeneradas.
  • negative_pooled_prompt_embeds (torch.Tensor, opcional) — Embeddings de texto CLIP negativos pregenerados.
  • negative_prompt_attention_mask (torch.Tensor, opcional) — Máscara booleana de relleno de negative_prompt_embeds.
  • max_sequence_length (int, por defecto 1024) — Número máximo de tokens del 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

< >

( prompt: str | list[str]tokenizertext_encoderdevice: deviceimage: PIL.Image.Image | list[PIL.Image.Image] | None = Nonemax_sequence_length: int = 1024generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None ) → str or list[str]

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, basándose en la imagen de referencia cuando se proporciona una. Es un staticmethod para que pueda usarse de forma independiente, antes de ejecutar la pipeline.

prepare_audio_latents

< >

( batch_size: intnum_channels_latents: intaudio_length: intdtype: dtypedevice: devicegenerator: typing.Union[torch.Generator, list[torch.Generator], NoneType]audio_latents: typing.Optional[torch.Tensor] = None )

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

< >

( batch_size: intnum_channels_latents: intheight: intwidth: intnum_frames: intdtype: dtypedevice: devicegenerator: typing.Union[torch.Generator, list[torch.Generator], NoneType]latents: typing.Optional[torch.Tensor] = None )

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

clase diffusers.Kandinsky6SRPipeline

< >

( transformer: Kandinsky6SRTransformer3DModelvae: Kandinsky6SRVAEscheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowSchedulerlatent_upscaler: diffusers.models.latent_upscaler.latent_upscaler_kandinsky6_sr.Kandinsky6SRLatentUpscalerBank | None = None )

Parámetros

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__

< >

( video: typing.Union[list[PIL.Image.Image], list[list[PIL.Image.Image]], numpy.ndarray, torch.Tensor]resolution_scale: float = 2.25num_inference_steps: int = 4timesteps: list[int] | None = Nonesigmas: list[float] | None = Nonelq_noise_scale: float = 0.7min_overlap: float = 0.2tiles_batch_size: int = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Noneoutput_type: str = 'pil'return_dict: bool = True ) → Kandinsky6SRPipelineOutput or tuple

Parámetros

  • video (list[PIL.Image.Image], np.ndarray or torch.Tensor) — El o los videos 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 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) — Indica si se debe devolver un 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

< >

( latents: Tensor )

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

encode_video

< >

( video: Tensor )

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

clase diffusers.Kandinsky6SRLatentUpscalerBank

< >

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

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 aumento de resolución del modelo x4.
  • num_mid_blocks (int, por defecto 3) — Bloques residuales entre las dos capas de aumento de resolución.
  • 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)) — Escala espacial para la 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

< >

( latents: Tensorscale: intreturn_dict: bool = True )

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.

Kandinsky6TI2VAPipelineOutput

clase diffusers.Kandinsky6TI2VAPipelineOutput

< >

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

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

clase diffusers.Kandinsky6SRPipelineOutput

< >

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

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 tensor de torch de forma (batch_size, num_frames, height, width, channels) / (batch_size, num_frames, channels, height, width).

Clase de salida para Kandinsky6SRPipeline.

Update on GitHub

←Kandinsky 5.0 Video Kandinsky S2V 1.0→