Kandinsky 5.0 Video

Kandinsky 5.0 est une famille de modèles de diffusion pour la génération de vidéos et d'images.

Kandinsky 5.0 Lite, une gamme de modèles de génération vidéo légers (2 milliards de paramètres) qui se classe n°1 parmi les modèles open source de sa catégorie. Il surpasse les modèles plus volumineux et offre la meilleure compréhension des concepts russes dans l'écosystème open source.

Kandinsky 5.0 Pro, gamme de grands modèles de génération vidéo de haute qualité (19 milliards de paramètres). Il offre une génération de haute qualité en HD et davantage de formats de génération tels que I2V.

Le modèle introduit plusieurs innovations clés :

Pipeline de diffusion latente avec Flow Matching pour une stabilité d'entraînement améliorée
Diffusion Transformer (DiT) comme architecture générative principale, avec une attention croisée vers les embeddings de texte
Encodage de texte double à l'aide de Qwen2.5-VL et de CLIP pour une compréhension complète du texte
HunyuanVideo 3D VAE pour un encodage et un décodage vidéo efficaces
Mécanismes d'attention creuse (NABLA) pour le traitement efficace de séquences longues

Le code source original peut être trouvé sur kandinskylab/Kandinsky-5.

Consultez l'organisation Kandinsky Lab sur le Hub pour les points de contrôle officiels des modèles de génération de texte vers vidéo, incluant les variantes préentraînées, SFT, no-CFG et distillées.

Modèles disponibles

Kandinsky 5.0 T2V Pro :

model_id	Description	Cas d'utilisation
kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers	Modèle Pro de génération de vidéo à partir de texte en 5 secondes	Génération de vidéos à partir de texte de haute qualité
kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers	Modèle Image-vers-Vidéo Pro de 5 secondes	Génération d'images en vidéo de haute qualité

Kandinsky 5.0 T2V Lite : | model_id | Description | Cas d'usage | |------------|-------------|-----------| | kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers | Modèle Supervised Fine-Tuned de 5 secondes | Qualité de génération la plus élevée | | kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers | Modèle Supervised Fine-Tuned de 10 secondes | Qualité de génération la plus élevée | | kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-5s-Diffusers | Distillation Classifier-Free Guidance de 5 secondes | Inférence 2× plus rapide | | kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-10s-Diffusers | Distillation Classifier-Free Guidance de 10 secondes | Inférence 2× plus rapide | | kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers | Distillation Diffusion de 5 secondes en 16 étapes | Inférence 6× plus rapide, perte de qualité minimale | | kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-10s-Diffusers | Distillation Diffusion de 10 secondes en 16 étapes | Inférence 6× plus rapide, perte de qualité minimale | | kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-5s-Diffusers | Modèle de base pré-entraîné de 5 secondes | Recherche et fine-tuning | | kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-10s-Diffusers | Modèle de base pré-entraîné de 10 secondes | Recherche et fine-tuning |

Exemples d'utilisation

Génération de base de texte en vidéo

Pro

⚠️ Avertissement ! Tous les modèles Pro doivent être inférés avec pipeline.enable_model_cpu_offload()

import torch
from diffusers import Kandinsky5T2VPipeline
from diffusers.utils import export_to_video

# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers"
pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16)

pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"
pipeline.transformer.set_attention_backend("flex")                            # <--- Set attention backend to Flex
pipeline.enable_model_cpu_offload()                                           # <--- Enable cpu offloading for single GPU inference
pipeline.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=True) # <--- Compile with max-autotune-no-cudagraphs

# Generate video
prompt = "A cat and a dog baking a cake together in a kitchen."
negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=768,
    width=1024,
    num_frames=121,  # ~5 seconds at 24fps
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)

Lite

import torch
from diffusers import Kandinsky5T2VPipeline
from diffusers.utils import export_to_video

# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers"
pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

# Generate video
prompt = "A cat and a dog baking a cake together in a kitchen."
negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=512,
    width=768,
    num_frames=121,  # ~5 seconds at 24fps
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)

Modèles en 10 secondes

⚠️ Avertissement ! tous les modèles de 10 secondes doivent être utilisés avec Flex attention et la compilation max-autotune-no-cudagraphs :

pipe = Kandinsky5T2VPipeline.from_pretrained(
    "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers", 
    dtype=torch.bfloat16
)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

pipe.transformer.set_attention_backend(
    "flex"
)                                       # <--- Set attention backend to Flex
pipe.transformer.compile(
    mode="max-autotune-no-cudagraphs", 
    dynamic=True
)                                       # <--- Compile with max-autotune-no-cudagraphs

prompt = "A cat and a dog baking a cake together in a kitchen."
negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=512,
    width=768,
    num_frames=241,
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)

Modèle Diffusion Distilled

⚠️ Attention ! tous les modèles nocfg et diffusion distillés doivent être inférés sans CFG (guidance_scale=1.0) :

model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers"
pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

output = pipe(
    prompt="A beautiful sunset over mountains",
    num_inference_steps=16,  # <--- Model is distilled in 16 steps
    guidance_scale=1.0,      # <--- no CFG
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)

Génération d'images en vidéo de base

⚠️ Avertissement ! Tous les modèles Pro doivent être inférés avec pipeline.enable_model_cpu_offload()

import torch
from diffusers import Kandinsky5T2VPipeline
from diffusers.utils import export_to_video

# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers"
pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16)

pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"
pipeline.transformer.set_attention_backend("flex")                            # <--- Set attention backend to Flex
pipeline.enable_model_cpu_offload()                                           # <--- Enable cpu offloading for single GPU inference
pipeline.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=True) # <--- Compile with max-autotune-no-cudagraphs

# Generate video
image = load_image(
    "https://huggingface.co/kandinsky-community/kandinsky-3/resolve/main/assets/title.jpg?download=true"
)
height = 896
width = 896
image = image.resize((width, height))

prompt = "An funny furry creture smiles happily and holds a sign that says 'Kandinsky'"
negative_prompt = ""

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=height,
    width=width,
    num_frames=121,  # ~5 seconds at 24fps
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)

Évaluation côte à côte de Kandinsky 5.0 Pro


Comparaison avec Veo 3	Comparaison avec Veo 3 fast

Comparaison avec le mode Text-to-Video de Wan 2.2 A14B	Comparaison avec le mode Image-vers-Vidéo de Wan 2.2 A14B

Évaluation côte à côte de Kandinsky 5.0 Lite

L'évaluation est basée sur les prompts étendus du Movie Gen benchmark, disponibles dans la colonne expanded_prompt du fichier benchmark/moviegen_bench.csv.

Évaluation côte à côte de Kandinsky 5.0 Lite Distill

Kandinsky5T2VPipeline

classe diffusers.Kandinsky5T2VPipeline

< source >

( transformer: Kandinsky5Transformer3DModelvae: AutoencoderKLHunyuanVideotext_encoder: Qwen2_5_VLForConditionalGenerationtokenizer: Qwen2VLProcessortext_encoder_2: CLIPTextModeltokenizer_2: CLIPTokenizerscheduler: FlowMatchEulerDiscreteScheduler )

Paramètres

transformer (Kandinsky5Transformer3DModel) — Transformer conditionnel pour débruyer les latents vidéo encodés.
vae (AutoencoderKLHunyuanVideo) — Modèle de Variational Auto-Encoder hunyuanvideo-community/HunyuanVideo (vae) pour encoder et décoder des vidéos vers et depuis des représentations latentes.
text_encoder (Qwen2_5_VLForConditionalGeneration) — Encodeur de texte figé Qwen2.5-VL.
tokenizer (AutoProcessor) — Tokeniseur pour Qwen2.5-VL.
text_encoder_2 (CLIPTextModel) — CLIP figé, plus précisément la variante clip-vit-large-patch14.
tokenizer_2 (CLIPTokenizer) — Tokeniseur pour CLIP.
scheduler (FlowMatchEulerDiscreteScheduler) — Un planificateur à utiliser en combinaison avec transformer pour débruyer les latents vidéo encodés.

Pipeline pour la génération de vidéos à partir de texte utilisant Kandinsky 5.0.

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

< source >

( prompt: str | list[str] = Nonenegative_prompt: str | list[str] | None = Noneheight: int = 512width: int = 768num_frames: int = 121num_inference_steps: int = 50guidance_scale: float = 5.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds_qwen: typing.Optional[torch.Tensor] = Noneprompt_embeds_clip: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds_qwen: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds_clip: typing.Optional[torch.Tensor] = Noneprompt_cu_seqlens: typing.Optional[torch.Tensor] = Nonenegative_prompt_cu_seqlens: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 512 ) → ~KandinskyPipelineOutput or tuple

Paramètres

prompt (str ou list[str], facultatif) — Le prompt ou les prompts pour guider la génération de la vidéo. S'il n'est pas défini, passez plutôt prompt_embeds.
negative_prompt (str ou list[str], facultatif) — Le prompt ou les prompts à éviter lors de la génération de la vidéo. S'il n'est pas défini, passez plutôt negative_prompt_embeds. Ignoré lorsque le guidage n'est pas utilisé (guidance_scale < 1).
height (int, par défaut 512) — La hauteur en pixels de la vidéo générée.
width (int, par défaut 768) — La largeur en pixels de la vidéo générée.
num_frames (int, par défaut 25) — Le nombre de frames dans la vidéo générée.
num_inference_steps (int, par défaut 50) — Le nombre d'étapes de débruitage.
guidance_scale (float, par défaut 5.0) — Échelle de guidage telle que définie dans le guidage sans classifieur.
num_videos_per_prompt (int, facultatif, valeur par défaut 1) — Le nombre de vidéos à générer par invite.
generator (torch.Generator ou list[torch.Generator], facultatif) — Un générateur torch pour rendre la génération déterministe.
latents (torch.Tensor, facultatif) — Latents bruités pré-générés.
prompt_embeds_qwen (torch.Tensor, facultatif) — Embeddings de texte pré-générés par l’encodeur texte Qwen.
prompt_embeds_clip (torch.Tensor, facultatif) — Embeddings de texte pré-générés par l’encodeur de texte CLIP.
negative_prompt_embeds_qwen (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés par l’encodeur de texte Qwen.
negative_prompt_embeds_clip (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés par l’encodeur de texte CLIP.
prompt_cu_seqlens (torch.Tensor, facultatif) — Longueurs cumulées des séquences pour les embeddings de prompt Qwen, utilisées pour l'attention de longueur variable.
negative_prompt_cu_seqlens (torch.Tensor, facultatif) — Longueurs cumulées des séquences pour les embeddings du prompt négatif de Qwen, utilisées pour l'attention de longueur variable.
output_type (str, facultatif, par défaut "pil") — Le format de sortie de la vidéo générée.
return_dict (bool, facultatif, par défaut True) — Indique s'il faut retourner un KandinskyPipelineOutput.
callback_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, facultatif) — Une fonction appelée à la fin de chaque étape de débruitage.
callback_on_step_end_tensor_inputs (list, facultatif) — La liste des entrées tensorielles pour la fonction callback_on_step_end.
max_sequence_length (int, par défaut 512) — La longueur maximale de séquence pour l'encodage du texte.

Retourne

~KandinskyPipelineOutput ou tuple

Si return_dict est True, KandinskyPipelineOutput est renvoyé, sinon un tuple est renvoyé dont le premier élément est une liste contenant les images générées.

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

Exemples :

>>> import torch
>>> from diffusers import Kandinsky5T2VPipeline
>>> from diffusers.utils import export_to_video

>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-10s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-10s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-10s-Diffusers

>>> model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers"
>>> pipe = Kandinsky5T2VPipeline.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."
>>> negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

>>> output = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     height=512,
...     width=768,
...     num_frames=121,
...     num_inference_steps=50,
...     guidance_scale=5.0,
... ).frames[0]

>>> export_to_video(output, "output.mp4", fps=24, quality=9)

check_inputs

< source >

( promptnegative_promptheightwidthprompt_embeds_qwen = Noneprompt_embeds_clip = Nonenegative_prompt_embeds_qwen = Nonenegative_prompt_embeds_clip = Noneprompt_cu_seqlens = Nonenegative_prompt_cu_seqlens = Nonecallback_on_step_end_tensor_inputs = Nonemax_sequence_length = None )

Paramètres

prompt — Invite d'entrée
negative_prompt — Prompt négatif pour le guidage
height — Hauteur de la vidéo
width — Largeur de la vidéo
prompt_embeds_qwen — Embeddings de prompt Qwen précalculés
prompt_embeds_clip — Embeddings de prompt CLIP précalculés
negative_prompt_embeds_qwen — Embeddings de prompt négatif Qwen précalculés
negative_prompt_embeds_clip — Embeddings de prompts négatifs CLIP précalculés
prompt_cu_seqlens — Longueurs cumulées précalculées des séquences pour le prompt positif de Qwen
negative_prompt_cu_seqlens — Longueurs cumulées de séquences précalculées pour le prompt négatif de Qwen
callback_on_step_end_tensor_inputs — Entrées de tenseurs du callback

Lève

ValueError

ValueError — Si les entrées sont invalides

Valider les paramètres d'entrée du pipeline.

encode_prompt

< source >

( prompt: str | list[str]num_videos_per_prompt: int = 1max_sequence_length: int = 512device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None ) → tuple[torch.Tensor, torch.Tensor, torch.Tensor]

Paramètres

prompt (str ou list[str]) — Prompt à encoder.
num_videos_per_prompt (int, facultatif, valeur par défaut 1) — Nombre de vidéos à générer par invite.
max_sequence_length (int, facultatif, par défaut 512) — Longueur maximale de la séquence pour l'encodage du texte.
device (torch.device, facultatif) — Appareil Torch.
dtype (torch.dtype, facultatif) — dtype Torch.

Retourne

tuple[torch.Tensor, torch.Tensor, torch.Tensor]

Embeddings de texte Qwen de forme (batch_size * num_videos_per_prompt, sequence_length, embedding_dim)
Embeddings CLIP agrégés de forme (batch_size * num_videos_per_prompt, clip_embedding_dim)
Longueurs de séquences cumulées (cu_seqlens) pour les embeddings Qwen de forme (batch_size * num_videos_per_prompt + 1,)

Encode un prompt unique (positif ou négatif) en états cachés de l'encodeur de texte.

Cette méthode combine les embeddings des encodeurs de texte Qwen2.5-VL et CLIP pour créer des représentations de texte complètes destinées à la génération de vidéos.

fast_sta_nabla

< source >

( T: intH: intW: intwT: int = 3wH: int = 3wW: int = 3device = 'cuda' ) → torch.Tensor

Paramètres

T (int) — Nombre de trames temporelles
H (int) — Hauteur dans l'espace latent
W (int) — Largeur dans l'espace latent
wT (int) — Taille de la fenêtre d'attention temporelle
wH (int) — Taille de la fenêtre d'attention en hauteur
wW (int) — Taille de la fenêtre d'attention
device (str) — Appareil sur lequel créer le tenseur

Retourne

torch.Tensor

Masque d'attention creux de forme (THW, THW)

Créer un masque d'attention temporelle creuse (STA) pour une génération de vidéos efficace.

Cette méthode génère un masque qui limite l'attention aux images et positions spatiales voisines, réduisant ainsi la complexité computationnelle pour la génération de vidéos.

get_sparse_params

< source >

( sampledevice ) → Dict

Paramètres

sample (torch.Tensor) — Tenseur d'échantillon d'entrée
device (torch.device) — Appareil sur lequel placer les tenseurs

Retourne

Dict

Dictionnaire contenant les paramètres d'attention creuse

Générer les paramètres d'attention creuse pour le transformateur en fonction des dimensions de l'échantillon.

Cette méthode calcule la configuration d'attention creuse nécessaire au traitement efficace des vidéos dans le modèle transformer.

prepare_latents

< source >

( batch_size: intnum_channels_latents: int = 16height: int = 480width: int = 832num_frames: int = 81dtype: typing.Optional[torch.dtype] = Nonedevice: typing.Optional[torch.device] = Nonegenerator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = None ) → torch.Tensor

Paramètres

batch_size (int) — Nombre de vidéos à générer
num_channels_latents (int) — Nombre de canaux dans l'espace latent
height (int) — Hauteur de la vidéo générée
width (int) — Largeur de la vidéo générée
num_frames (int) — Nombre de frames dans la vidéo
dtype (torch.dtype) — Type de données pour les latents
device (torch.device) — Appareil sur lequel créer les latents
generator (torch.Generator) — Générateur de nombres aléatoires
latents (torch.Tensor) — Latents existants à utiliser

Retourne

torch.Tensor

Tenseur latent préparé

Préparez les variables latentes initiales pour la génération de vidéos.

Cette méthode crée des latents de bruit aléatoires ou utilise les latents fournis comme point de départ pour le processus de débruitage.

Kandinsky5I2VPipeline

classe diffusers.Kandinsky5I2VPipeline

< source >

Paramètres

transformer (Kandinsky5Transformer3DModel) — Transformer conditionnel pour débruyer les latents vidéo encodés.
vae (AutoencoderKLHunyuanVideo) — Modèle de Variational Auto-Encoder hunyuanvideo-community/HunyuanVideo (vae) pour encoder et décoder des vidéos vers et depuis des représentations latentes.
text_encoder (Qwen2_5_VLForConditionalGeneration) — Encodeur de texte figé Qwen2.5-VL.
tokenizer (AutoProcessor) — Tokeniseur pour Qwen2.5-VL.
text_encoder_2 (CLIPTextModel) — CLIP figé, plus précisément la variante clip-vit-large-patch14.
tokenizer_2 (CLIPTokenizer) — Tokeniseur pour CLIP.
scheduler (FlowMatchEulerDiscreteScheduler) — Un planificateur à utiliser en combinaison avec transformer pour débruyer les latents vidéo encodés.

Pipeline pour la génération de vidéos à partir d'images utilisant Kandinsky 5.0.

call

< source >

( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]prompt: str | list[str] = Nonenegative_prompt: str | list[str] | None = Noneheight: int = 512width: int = 768num_frames: int = 121num_inference_steps: int = 50guidance_scale: float = 5.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds_qwen: typing.Optional[torch.Tensor] = Noneprompt_embeds_clip: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds_qwen: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds_clip: typing.Optional[torch.Tensor] = Noneprompt_cu_seqlens: typing.Optional[torch.Tensor] = Nonenegative_prompt_cu_seqlens: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecallback_on_step_end: typing.Optional[typing.Callable[[int, int, NoneType], diffusers.callbacks.PipelineCallback | diffusers.callbacks.MultiPipelineCallbacks]] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 512 ) → ~KandinskyPipelineOutput or tuple

Paramètres

image (PipelineImageInput) — L'image d'entrée sur laquelle conditionner la génération. Doit être une image, une liste d'images ou un torch.Tensor.
prompt (str ou list[str], facultatif) — Le prompt ou les prompts pour guider la génération de la vidéo. S'il n'est pas défini, passez plutôt prompt_embeds.
negative_prompt (str ou list[str], facultatif) — Le prompt ou les prompts à éviter lors de la génération de la vidéo. S'il n'est pas défini, passez plutôt negative_prompt_embeds. Ignoré lorsque le guidage n'est pas utilisé (guidance_scale < 1).
height (int, par défaut 512) — La hauteur en pixels de la vidéo générée.
width (int, par défaut 768) — La largeur en pixels de la vidéo générée.
num_frames (int, par défaut 121) — Le nombre de frames dans la vidéo générée.
num_inference_steps (int, par défaut 50) — Le nombre d'étapes de débruitage.
guidance_scale (float, par défaut 5.0) — Échelle de guidage telle que définie dans le guidage sans classifieur.
num_videos_per_prompt (int, facultatif, valeur par défaut 1) — Le nombre de vidéos à générer par invite.
generator (torch.Generator ou list[torch.Generator], facultatif) — Un générateur torch pour rendre la génération déterministe.
latents (torch.Tensor, facultatif) — Latents bruités pré-générés.
prompt_embeds_qwen (torch.Tensor, facultatif) — Embeddings de texte Qwen pré-générés.
prompt_embeds_clip (torch.Tensor, facultatif) — Embeddings de texte CLIP pré-générés.
negative_prompt_embeds_qwen (torch.Tensor, facultatif) — Embeddings de texte négatif Qwen pré-générés.
negative_prompt_embeds_clip (torch.Tensor, facultatif) — Embeddings de texte négatif CLIP pré-générés.
prompt_cu_seqlens (torch.Tensor, facultatif) — Longueurs cumulées de séquences pré-générées pour le prompt positif de Qwen.
negative_prompt_cu_seqlens (torch.Tensor, facultatif) — Longueurs cumulées de séquences pré-générées pour le prompt négatif de Qwen.
output_type (str, facultatif, par défaut "pil") — Le format de sortie de la vidéo générée.
return_dict (bool, facultatif, par défaut True) — Indique s'il faut retourner un KandinskyPipelineOutput.
callback_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, facultatif) — Une fonction appelée à la fin de chaque étape de débruitage.
callback_on_step_end_tensor_inputs (List, facultatif) — La liste des entrées tensorielles pour la fonction callback_on_step_end.
max_sequence_length (int, par défaut 512) — La longueur maximale de séquence pour l'encodage du texte.

Retourne

~KandinskyPipelineOutput ou tuple

Si return_dict est True, KandinskyPipelineOutput est renvoyé, sinon un tuple est renvoyé dont le premier élément est une liste contenant les vidéos générées.

La fonction d'appel du pipeline pour la génération d'images en vidéo.

Exemples :

>>> import torch
>>> from diffusers import Kandinsky5I2VPipeline
>>> from diffusers.utils import export_to_video, load_image

>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers

>>> model_id = "kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers"
>>> pipe = Kandinsky5I2VPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe = pipe.to("cuda")

>>> image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
... )
>>> prompt = "An astronaut floating in space with Earth in the background, cinematic shot"
>>> negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

>>> output = pipe(
...     image=image,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     height=512,
...     width=768,
...     num_frames=121,
...     num_inference_steps=50,
...     guidance_scale=5.0,
... ).frames[0]

>>> export_to_video(output, "output.mp4", fps=24, quality=9)

check_inputs

< source >

( promptnegative_promptimageheightwidthprompt_embeds_qwen = Noneprompt_embeds_clip = Nonenegative_prompt_embeds_qwen = Nonenegative_prompt_embeds_clip = Noneprompt_cu_seqlens = Nonenegative_prompt_cu_seqlens = Nonecallback_on_step_end_tensor_inputs = Nonemax_sequence_length = None )

Paramètres

prompt — Invite d'entrée
negative_prompt — Prompt négatif pour le guidage
image — Image d'entrée pour le conditionnement
height — Hauteur de la vidéo
width — Largeur de la vidéo
prompt_embeds_qwen — Embeddings de prompt Qwen précalculés
prompt_embeds_clip — Embeddings de prompt CLIP précalculés
negative_prompt_embeds_qwen — Embeddings de prompt négatif Qwen précalculés
negative_prompt_embeds_clip — Embeddings de prompts négatifs CLIP précalculés
prompt_cu_seqlens — Longueurs cumulées précalculées des séquences pour le prompt positif de Qwen
negative_prompt_cu_seqlens — Longueurs cumulées de séquences précalculées pour le prompt négatif de Qwen
callback_on_step_end_tensor_inputs — Entrées de tenseurs du callback

Lève

ValueError

ValueError — Si les entrées sont invalides

Valider les paramètres d'entrée du pipeline.

encode_prompt

< source >

Paramètres

prompt (str ou list[str]) — Prompt à encoder.
num_videos_per_prompt (int, facultatif, valeur par défaut 1) — Nombre de vidéos à générer par invite.
max_sequence_length (int, facultatif, par défaut 512) — Longueur maximale de la séquence pour l'encodage du texte.
device (torch.device, facultatif) — Appareil Torch.
dtype (torch.dtype, facultatif) — dtype Torch.

Retourne

tuple[torch.Tensor, torch.Tensor, torch.Tensor]

Embeddings de texte Qwen de forme (batch_size * num_videos_per_prompt, sequence_length, embedding_dim)
Embeddings CLIP agrégés de forme (batch_size * num_videos_per_prompt, clip_embedding_dim)
Longueurs de séquences cumulées (cu_seqlens) pour les embeddings Qwen de forme (batch_size * num_videos_per_prompt + 1,)

Encode un prompt unique (positif ou négatif) en états cachés de l'encodeur de texte.

Cette méthode combine les embeddings des encodeurs de texte Qwen2.5-VL et CLIP pour créer des représentations de texte complètes destinées à la génération de vidéos.

fast_sta_nabla

< source >

( T: intH: intW: intwT: int = 3wH: int = 3wW: int = 3device = 'cuda' ) → torch.Tensor

Paramètres

T (int) — Nombre de trames temporelles
H (int) — Hauteur dans l'espace latent
W (int) — Largeur dans l'espace latent
wT (int) — Taille de la fenêtre d'attention temporelle
wH (int) — Taille de la fenêtre d'attention en hauteur
wW (int) — Taille de la fenêtre d'attention
device (str) — Appareil sur lequel créer le tenseur

Retourne

torch.Tensor

Masque d'attention creux de forme (THW, THW)

Créer un masque d'attention temporelle creuse (STA) pour une génération de vidéos efficace.

Cette méthode génère un masque qui limite l'attention aux images et positions spatiales voisines, réduisant ainsi la complexité computationnelle pour la génération de vidéos.

get_sparse_params

< source >

( sampledevice ) → Dict

Paramètres

sample (torch.Tensor) — Tenseur d'échantillon d'entrée
device (torch.device) — Appareil sur lequel placer les tenseurs

Retourne

Dict

Dictionnaire contenant les paramètres d'attention creuse

Générer les paramètres d'attention creuse pour le transformateur en fonction des dimensions de l'échantillon.

Cette méthode calcule la configuration d'attention creuse nécessaire au traitement efficace des vidéos dans le modèle transformer.

prepare_latents

< source >

( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]batch_size: intnum_channels_latents: int = 16height: int = 480width: int = 832num_frames: int = 81dtype: typing.Optional[torch.dtype] = Nonedevice: typing.Optional[torch.device] = Nonegenerator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = None ) → torch.Tensor

Paramètres

image (PipelineImageInput) — Image d'entrée sur laquelle conditionner la génération
batch_size (int) — Nombre de vidéos à générer
num_channels_latents (int) — Nombre de canaux dans l'espace latent
height (int) — Hauteur de la vidéo générée
width (int) — Largeur de la vidéo générée
num_frames (int) — Nombre de frames dans la vidéo
dtype (torch.dtype) — Type de données pour les latents
device (torch.device) — Appareil sur lequel créer les latents
generator (torch.Generator) — Générateur de nombres aléatoires
latents (torch.Tensor) — Latents existants à utiliser

Retourne

torch.Tensor

Tenseur latent préparé avec la première image encodée

Préparez les variables latentes initiales pour la génération d'images en vidéos.

Cette méthode crée des latents de bruit aléatoires pour tous les cadres, à l'exception du premier, qui est remplacé par l'image d'entrée encodée.

Citation

@misc{kandinsky2025,
    author = {Alexander Belykh and Alexander Varlamov and Alexey Letunovskiy and Anastasia Aliaskina and Anastasia Maltseva and Anastasiia Kargapoltseva and Andrey Shutkin and Anna Averchenkova and Anna Dmitrienko and Bulat Akhmatov and Denis Dimitrov and Denis Koposov and Denis Parkhomenko and Dmitrii and Ilya Vasiliev and Ivan Kirillov and Julia Agafonova and Kirill Chernyshev and Kormilitsyn Semen and Lev Novitskiy and Maria Kovaleva and Mikhail Mamaev and Mikhailov and Nikita Kiselev and Nikita Osterov and Nikolai Gerasimenko and Nikolai Vaulin and Olga Kim and Olga Vdovchenko and Polina Gavrilova and Polina Mikhailova and Tatiana Nikulina and Viacheslav Vasilev and Vladimir Arkhipkin and Vladimir Korviakov and Vladimir Polovnikov and Yury Kolabushin},
    title = {Kandinsky 5.0: A family of diffusion models for Video & Image generation},
    howpublished = {\url{https://github.com/kandinskylab/Kandinsky-5}},
    year = 2025
}

Update on GitHub

Diffusers

Kandinsky 5.0 Video

Modèles disponibles

Exemples d'utilisation

Génération de base de texte en vidéo

Pro

Lite

Modèles en 10 secondes

Modèle Diffusion Distilled

Génération d'images en vidéo de base

Évaluation côte à côte de Kandinsky 5.0 Pro

Évaluation côte à côte de Kandinsky 5.0 Lite

Évaluation côte à côte de Kandinsky 5.0 Lite Distill

Kandinsky5T2VPipeline

classe diffusers.Kandinsky5T2VPipeline

__call__

check_inputs

encode_prompt

fast_sta_nabla

get_sparse_params

prepare_latents

Kandinsky5I2VPipeline

classe diffusers.Kandinsky5I2VPipeline

__call__

check_inputs

encode_prompt

fast_sta_nabla

get_sparse_params

prepare_latents

Citation

call

call