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 est une famille de modèles de génération vidéo de Kandinsky Lab. Le modèle principal génère une vidéo et un audio synchronisés à partir d'un texte ou d'une image de référence au moyen d'un unique transformeur de diffusion multimodal : les latents vidéo et audio sont débruités ensemble à travers des blocs fusionnés qui effectuent une attention croisée entre les deux modalités, chacun étant conditionné par sa propre branche de texte Qwen2.5-VL et par un embedding CLIP agrégé. Un modèle de super-résolution distinct agrandit la vidéo générée tuile par tuile dans l'espace latent d'un K-VAE causal 3D.

Consultez l’organisation Kandinsky Lab sur le Hub pour l’ensemble des points de contrôle officiels, y compris les variantes flow-matching et distillées des modèles de base et de super-résolution.

Les points de contrôle distillés sont livrés avec le PiflowScheduler à étapes réduites et doivent être exécutés avec guidance_scale=1.0.

Modèles disponibles

ModèlePipelineNotes
kandinskylab/Kandinsky-6.0-Pro-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 étapes
kandinskylab/Kandinsky-6.0-Pro-distill-5s-DiffusersKandinsky6TI2VAPipelineDistillé, guidance_scale=1.0, 10 étapes
kandinskylab/Kandinsky-6.0-Lite-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 étapes
kandinskylab/Kandinsky-6.0-Lite-distill-5s-DiffusersKandinsky6TI2VAPipelineDistillé, guidance_scale=1.0, 10 étapes
kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 étapes
kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 étapes
kandinskylab/Kandinsky-6.0-VSR-5s-DiffusersKandinsky6SRPipelineSuper-résolution par correspondance de flux
kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-DiffusersKandinsky6SRPipelineSuper-résolution distillée, 2 étapes

Texte/image-vers-vidéo-et-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,
)

Passez image= pour conditionner la première image sur une image de référence, sample_audio=False pour générer uniquement la vidéo, et expand_prompts=True pour laisser l’encodeur de texte Qwen2.5-VL réécrire d’abord les prompts courts en prompts détaillés.

Super-résolution vidéo

Kandinsky6SRPipeline prend les images produites par Kandinsky6TI2VAPipeline et les agrandit par un facteur de 2, 4 ou 2.25 (un pré-agrandissement bilinéaire de 1,125x suivi du chemin 2x). La vidéo est découpée en tuiles chevauchantes, chaque tuile est affinée à l'une des tailles de tuiles sur lesquelles le transformeur SR a été entraîné, et les tuiles sont recombinées à l'aide de fenêtres 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]

Optimisation de la mémoire

Reportez-vous au guide Réduire l’utilisation de la mémoire pour l’ensemble général des techniques. Les pipelines Kandinsky6TI2VAPipeline et Kandinsky6SRPipeline prennent en charge le model offloading (utilisé ci-dessus) et, pour une empreinte plus réduite au détriment de la vitesse, le sequential CPU offloading :

pipe.enable_sequential_cpu_offload()

Le VAE vidéo de Kandinsky6TI2VAPipeline prend également en charge le décodage par tuiles pour les hautes résolutions ou les vidéos longues :

pipe.vae.enable_tiling()

Notes

  • height et width doivent être divisibles par le ratio de compression spatiale du VAE vidéo multiplié par la taille de patch du transformer — 16 avec la configuration par défaut de Kandinsky6TI2VAPipeline (AutoencoderKLHunyuanVideo avec un ratio de compression de 8, patch_size=(1, 2, 2)). 480x864, utilisé dans l’exemple ci-dessus, satisfait cette condition.
  • L’entrée video de Kandinsky6SRPipeline doit contenir 1 + k * vae_scale_factor_temporal images pour un entier k donné (un ratio de compression temporelle de 4 avec la configuration K-VAE par défaut, donc 121 images fonctionne mais 120 non) — rogner ou compléter une vidéo qui ne satisfait pas déjà à cette condition avant de l’augmenter.
  • expand_prompts=True réutilise l’encodeur de texte Qwen2.5-VL déjà chargé pour un passage de génération supplémentaire avant le débruitage, ce qui ajoute de la latence mais aucun poids de modèle supplémentaire.
  • Compilez les blocs de transformer répétés pour une inférence répétée plus rapide : 
    pipe.transformer.compile_repeated_blocks(fullgraph=True)

Kandinsky6TI2VAPipeline

classe 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 )

Paramètres

  • transformer (Kandinsky6Transformer3DModel) — Transformeur multimodal qui débruite les latents vidéo et audio.
  • vae (AutoencoderKLHunyuanVideo) — VAE vidéo utilisé pour encoder l'image de référence et décoder la vidéo générée.
  • text_encoder (Qwen2_5_VLForConditionalGeneration) — Modèle Qwen2.5-VL fournissant les embeddings de texte au niveau des jetons et, en option, l’expansion du prompt.
  • tokenizer (Qwen2_5_VLProcessor) — Processeur de text_encoder.
  • text_encoder_2 (CLIPTextModel) — encodeur de texte CLIP fournissant l'embedding de texte poolé.
  • tokenizer_2 (CLIPTokenizer) — Tokenizer de text_encoder_2.
  • scheduler (FlowMatchEulerDiscreteScheduler ou PiflowScheduler) — Planificateur utilisé avec transformer pour débruisser les latents. Les points de contrôle distillés sont fournis avec un PiflowScheduler et doivent être exécutés avec guidance_scale=1.0.
  • audio_vae (MMAudioVAE, facultatif) — VAE audio utilisé pour décoder les latents audio générés en spectrogramme de mel. Nécessaire uniquement lorsque sample_audio=True.
  • vocoder (MMAudioVocoder, facultatif) — Vocodeur utilisé pour convertir le spectrogramme mel décodé par audio_vae en forme d’onde. Nécessaire uniquement lorsque sample_audio=True.

Pipeline pour la génération de vidéo et d'audio à partir de texte/image avec Kandinsky 6.

Les latents vidéo et audio sont débruités ensemble par un unique transformeur multimodal, conditionné par des jetons de texte Qwen2.5-VL et un embedding agrégé CLIP. Une image de référence facultative conditionne la première image.

Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, 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

Paramètres

  • prompt (str ou list[str], facultatif) — Le prompt ou les prompts pour guider la génération. Obligatoire sauf si prompt_embeds est fourni.
  • image (PipelineImageInput, facultatif) — Image(s) de référence conditionnant la première image (image-vers-vidéo-et-audio).
  • negative_prompt (str ou list[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération. Par défaut, le prompt négatif de Kandinsky 6 est utilisé.
  • height (int, par défaut 512) — Hauteur de la vidéo générée, en pixels.
  • width (int, par défaut 768) — Largeur de la vidéo générée, en pixels.
  • num_frames (int, par défaut 121) — Nombre de frames générées.
  • frame_rate (float, par défaut 24.0) — Fréquence d’images à laquelle la vidéo est générée ; définit la durée de l’audio synchronisé.
  • num_inference_steps (int, par défaut 50) — Le nombre d'étapes de débruitage. Utilisez 16 avec les points de contrôle distillés.
  • timesteps (list[int], facultatif) — Timesteps personnalisés pour les planificateurs qui les prennent en charge.
  • sigmas (list[float], facultatif) — Sigmas personnalisés pour les planificateurs qui les prennent en charge.
  • guidance_scale (float, par défaut 5.0) — Échelle de guidage sans classifieur. Doit être 1.0 avec un PiflowScheduler.
  • num_videos_per_prompt (int, par défaut 1) — Le nombre de vidéos à générer par invite.
  • generator (torch.Generator ou list[torch.Generator], facultatif) — Générateur(s) utilisé(s) pour le bruit initial et l'encodage de l'image de référence.
  • latents (torch.Tensor, facultatif) — Latents vidéo pré-générés de forme (batch_size, channels, num_latent_frames, latent_height, latent_width).
  • audio_latents (torch.Tensor, facultatif) — Latents audio pré-générés de forme (batch_size, channels, audio_length).
  • prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte Qwen2.5-VL pré-générés.
  • pooled_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte CLIP pré-générés.
  • negative_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs Qwen2.5-VL pré-générés.
  • negative_pooled_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte CLIP négatifs pré-générés.
  • sample_audio (bool, par défaut True) — Indique s'il faut générer un audio synchronisé. Nécessite que le pipeline dispose d'un audio_vae et d'un vocoder.
  • expand_prompts (bool, par défaut False) — Indique s'il faut réécrire les prompts avec expand_prompts() avant l'encodage.
  • max_sequence_length (int, par défaut 1024) — Nombre maximal de jetons de l'invite après le modèle de discussion.
  • output_type (str, par défaut "pil") — Le format de sortie de la vidéo générée : "pil", "np", "pt" ou "latent".
  • return_dict (bool, par défaut True) — Indique s'il faut retourner un Kandinsky6TI2VAPipelineOutput plutôt qu'un simple tuple.
  • callback_on_step_end (Callable, facultatif) — Une fonction appelée à la fin de chaque étape de débruitage avec callback_on_step_end(self, step, timestep, callback_kwargs). Elle peut renvoyer un dictionnaire qui remplace les tenseurs listés.
  • callback_on_step_end_tensor_inputs (list[str], par défaut ["latents"]) — Entrées tensorielles passées à callback_on_step_end ; un sous-ensemble de _callback_tensor_inputs.

Retourne

Kandinsky6TI2VAPipelineOutput ou tuple

La vidéo et l'audio générés ; un tuple (frames, audio) lorsque return_dict=False.

La fonction d'appel du pipeline pour la génération.

Exemples :

>>> 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 )

Encode les image(s) de référence en latents de première image de forme (batch_size, latent_height, latent_width, latent_channels), mis à l'échelle par le scaling_factor du VAE. Les images PIL sont redimensionnées et recadrées au centre sur height x width ; les tenseurs et tableaux doivent déjà avoir cette taille. Les latents sont répétés num_videos_per_prompt fois le long de la dimension de lot.

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 )

Paramètres

  • prompt (str ou list[str]) — Prompt à encoder.
  • negative_prompt (str ou list[str], facultatif) — Le prompt à ne pas utiliser pour guider la génération. Ignoré lorsque do_classifier_free_guidance est False.
  • do_classifier_free_guidance (bool, par défaut True) — Indique s'il faut également encoder le prompt négatif.
  • num_videos_per_prompt (int, par défaut 1) — Nombre de vidéos générées par invite ; les embeddings sont répétés en conséquence.
  • prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte Qwen2.5-VL pré-générés. Permet de passer l’encodage de prompt.
  • pooled_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte CLIP pré-générés. Doit être fourni avec prompt_embeds.
  • prompt_attention_mask (torch.Tensor, facultatif) — Masque de bourrage booléen de prompt_embeds.
  • negative_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs Qwen2.5-VL pré-générés.
  • negative_pooled_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte CLIP négatifs pré-générés.
  • negative_prompt_attention_mask (torch.Tensor, facultatif) — Masque de bourrage booléen de negative_prompt_embeds.
  • max_sequence_length (int, par défaut 1024) — Nombre maximal de jetons de l'invite après le modèle de discussion.
  • device (torch.device, facultatif) — Appareil sur lequel exécuter les encodeurs de texte.
  • dtype (torch.dtype, facultatif) — Dtype des embeddings renvoyés.

Encode le prompt dans les états cachés de l'encodeur de texte.

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]

Paramètres

  • prompt (str ou list[str]) — Prompt ou prompts à développer.
  • tokenizer — Le processeur Qwen2.5-VL, par exemple pipe.tokenizer.
  • text_encoder — Le modèle Qwen2.5-VL, par exemple pipe.text_encoder.
  • device (torch.device) — Appareil sur lequel exécuter l'encodeur de texte.
  • image (PIL.Image.Image ou list[PIL.Image.Image], facultatif) — Image(s) de référence pour un appel image-vers-vidéo.
  • max_sequence_length (int, par défaut 1024) — Nombre maximal de jetons générés par invite.
  • generator (torch.Generator ou list[torch.Generator], facultatif) — Sème l’expansion échantillonnée ; une liste doit correspondre à la longueur de prompt, un générateur par élément. generate tire de la RNG globale, de sorte que la RNG globale est semée à partir de la graine de ce générateur ; les appels ultérieurs à randn_tensor continuent d’utiliser generator directement.

Retourne

str ou list[str]

Le(s) prompt(s) étendu(s).

Réécrit les prompts courts en prompts vidéo+audio détaillés avec l’encodeur de texte Qwen2.5-VL, en s’appuyant sur l’image de référence lorsqu’une est fournie. Il s’agit d’une staticmethod afin qu’elle puisse être utilisée de manière autonome, avant l’exécution du 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 )

Retourne les latents audio dans la disposition (batch_size, audio_length, channels) du transformer. Un tenseur audio_latents fourni par l’utilisateur est attendu dans la disposition (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 )

Retourne les latents vidéo dans la disposition (batch_size, num_frames, height, width, channels) du transformer. Un tenseur latents fourni par l’utilisateur est attendu dans la disposition (batch_size, channels, num_frames, height, width).

Kandinsky6SRPipeline

classe 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 )

Paramètres

Pipeline de super-résolution vidéo avec Kandinsky 6.

La vidéo est découpée en tuiles spatiales chevauchantes, chaque tuile est affinée par le transformeur SR à l'une des tailles de tuiles sur lesquelles le modèle a été entraîné (transformer.config.tile_sizes), et les tuiles affinées sont recombinées à l'aide de fenêtres de Hann. Lorsque le pipeline dispose d'un latent_upscaler, les tuiles sont extraites des latents K-VAE de la vidéo entière et redimensionnées dans l'espace latent ; sinon, les tuiles en pixels sont redimensionnées par interpolation bilinéaire puis encodées.

Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, 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

Paramètres

  • video (list[PIL.Image.Image], np.ndarray ou torch.Tensor) — La ou les vidéos basse résolution, dans n’importe quel format accepté par preprocess_video(), avec 1 + k * 4 images. Les dimensions sont arrondies à la valeur inférieure multiple du facteur spatial du VAE.
  • resolution_scale (float, par défaut 2.25) — Agrandissement spatial total : 2, 4 ou 2.25 (un pré-agrandissement bilinéaire de 1,125x suivi du chemin 2x).
  • num_inference_steps (int, par défaut 4) — Le nombre d'étapes de débruitage par tuile. Utilisez 2 avec les points de contrôle distillés.
  • timesteps (list[int], facultatif) — Timesteps personnalisés pour les planificateurs qui les prennent en charge.
  • sigmas (list[float], facultatif) — Sigmas personnalisés pour les planificateurs qui les prennent en charge.
  • lq_noise_scale (float, par défaut 0.7) — Quantité de bruit gaussien mélangée aux latents basse résolution (préservant la variance) avant le débruitage.
  • min_overlap (float, par défaut 0.2) — Recouvrement minimal entre les tuiles voisines, exprimé en fraction de la taille de la tuile.
  • tiles_batch_size (int, par défaut 1) — Nombre de tuiles débruitées par appel au transformer.
  • generator (torch.Generator ou list[torch.Generator], facultatif) — Générateur(s) utilisé(s) pour le bruit mélangé aux tuiles.
  • output_type (str, par défaut "pil") — Le format de sortie de la vidéo générée : "pil", "np" ou "pt".
  • return_dict (bool, par défaut True) — Indique s'il faut retourner un Kandinsky6SRPipelineOutput plutôt qu'un simple tuple.

Retourne

Kandinsky6SRPipelineOutput ou tuple

La vidéo super-résolue ; un tuple à un élément lorsque return_dict=False.

La fonction d'appel du pipeline pour la super-résolution.

Exemples :

>>> 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 )

Décode les latents K-VAE mis à l'échelle en une vidéo de forme (batch_size, channels, num_frames, height, width) dans l'intervalle [-1, 1].

encode_video

< >

( video: Tensor )

Encode une vidéo de forme (batch_size, channels, num_frames, height, width) dans [-1, 1] en latents K-VAE mis à l'échelle par le scaling_factor du VAE.

Kandinsky6SRLatentUpscalerBank

classe 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 )

Paramètres

  • in_channels (int, par défaut 64) — Nombre de canaux latents.
  • stage_channels (tuple[int, int, int], par défaut (2048, 1024, 512)) — Largeurs des caractéristiques des trois étapes de la cascade.
  • num_pre_blocks (int, par défaut 5) — Blocs résiduels avant le premier upsample du modèle x4.
  • num_mid_blocks (int, par défaut 3) — Blocs résiduels entre les deux opérations de suréchantillonnage.
  • num_post_blocks (int, par défaut 3) — Blocs résiduels après le dernier upsample.
  • num_x2_adapter_blocks (int, par défaut 2) — Blocs résiduels de l’adaptateur du modèle x2.
  • scales (tuple[int, ...], par défaut (2, 4)) — Échelles spatiales pour lesquelles la banque fournit un upscaler.
  • scaling_factor (float, par défaut 0.910344) — Facteur d'échelle que les latents d'entrée sont censés porter (le scaling_factor du K-VAE).

Banque de redimensionneurs latents utilisés par Kandinsky6SRPipeline : un Kandinsky6SRLatentUpscaler par échelle spatiale prise en charge, opérant sur les latents K-VAE.

forward

< >

( latents: Tensorscale: intreturn_dict: bool = True )

Paramètres

  • latents (torch.Tensor de forme (batch_size, in_channels, num_frames, height, width)) — Latents K-VAE mis à l'échelle par scaling_factor.
  • scale (int) — Facteur de mise à l'échelle spatiale ; l'un des scales.
  • return_dict (bool, par défaut True) — Indique s'il faut retourner un ~models.autoencoder_kl.DecoderOutput plutôt qu'un simple tuple.

Kandinsky6TI2VAPipelineOutput

classe diffusers.Kandinsky6TI2VAPipelineOutput

< >

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

Paramètres

  • frames (torch.Tensor, np.ndarray ou list[list[PIL.Image.Image]]) — La vidéo générée. Une liste imbriquée de longueur batch_size contenant num_frames images PIL chacune, ou un tableau NumPy ou un tenseur torch de forme (batch_size, num_frames, height, width, channels) / (batch_size, num_frames, channels, height, width). Avec output_type="latent", les latents de la vidéo de forme (batch_size, channels, num_latent_frames, latent_height, latent_width).
  • audio (torch.Tensor ou np.ndarray, facultatif) — Les formes d’onde générées de forme (batch_size, num_samples) dans [-1, 1] à la fréquence d’échantillonnage du VAE audio, ou None si l’audio n’a pas été échantillonné. Avec output_type="latent", les latents audio de forme (batch_size, channels, audio_length).

Classe de sortie pour Kandinsky6TI2VAPipeline.

Kandinsky6SRPipelineOutput

classe diffusers.Kandinsky6SRPipelineOutput

< >

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

Paramètres

  • frames (torch.Tensor, np.ndarray ou list[list[PIL.Image.Image]]) — La vidéo super-résolue. Une liste imbriquée de longueur batch_size contenant num_frames images PIL chacune, ou un tableau NumPy ou un tenseur torch de forme (batch_size, num_frames, height, width, channels) / (batch_size, num_frames, channels, height, width).

Classe de sortie pour Kandinsky6SRPipeline.

Update on GitHub

←Kandinsky 5.0 Video Kandinsky S2V 1.0→