# Kandinsky 5.0 Video

[Kandinsky 5.0](https://arxiv.org/abs/2511.14993) 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](https://github.com/kandinskylab/Kandinsky-5).

> [!TIP]
> Consultez l'organisation [Kandinsky Lab](https://huggingface.co/kandinskylab) 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'utilisation |
|------------|-------------|-----------|
| **kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers** | Modèle Supervised Fine-Tuned en 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 en 10 secondes | Qualité de génération la plus élevée |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-5s-Diffusers** | 5 secondes de Classifier-Free Guidance distillé | Inférence 2× plus rapide |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-10s-Diffusers** | 10 secondes de Classifier-Free Guidance distillé | Inférence 2× plus rapide |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers** | Diffusion 5 secondes distillée en 16 étapes | Inférence 6× plus rapide, perte de qualité minimale |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-10s-Diffusers** | Diffusion 10 secondes distillée en 16 étapes | Inférence 6× plus rapide, perte de qualité minimale |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-5s-Diffusers** | Modèle pré-entraîné Base de 5 secondes | Recherche et fine-tuning |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-10s-Diffusers** | Modèle pré-entraîné de base en 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()
```python
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
```python
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 :

```python
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```) :

```python
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()
```python
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](https://github.com/facebookresearch/MovieGenBench), disponibles dans la colonne expanded_prompt du fichier benchmark/moviegen_bench.csv.

  
      
          
      
      
          
      
  
      
          
      
      
          
      
  
      
          
      

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

  
      
          
      
      
          
      

## Kandinsky5T2VPipeline[[diffusers.Kandinsky5T2VPipeline]]

#### diffusers.Kandinsky5T2VPipeline[[diffusers.Kandinsky5T2VPipeline]]

```python
diffusers.Kandinsky5T2VPipeline(transformer: Kandinsky5Transformer3DModel, vae: AutoencoderKLHunyuanVideo, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: FlowMatchEulerDiscreteScheduler)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L131)

**Paramètres :**

transformer (`Kandinsky5Transformer3DModel`) : Transformer conditionnel pour débruyer les latents vidéo encodés.

vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : Modèle de Variational Auto-Encoder [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) 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](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).

tokenizer (`AutoProcessor`) : Tokenizer pour Qwen2.5-VL.

text_encoder_2 (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) figé, plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).

tokenizer_2 (`CLIPTokenizer`) : Tokenizer pour CLIP.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.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](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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.).

#### __appel__[[diffusers.Kandinsky5T2VPipeline.__call__]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L680)

**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 (classifier-free guidance).

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*) : Incrustations de texte pré-générées par l'encodeur de texte Qwen.

prompt_embeds_clip (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées par l'encodeur de texte CLIP.

negative_prompt_embeds_qwen (`torch.Tensor`, *facultatif*) : Incrustations de texte négatif pré-générées 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 ou non 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 de tenseurs pour la fonction `callback_on_step_end`.

max_sequence_length (`int`, par défaut `512`) : La longueur de séquence maximale 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 :

```python
>>> 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[[diffusers.Kandinsky5T2VPipeline.check_inputs]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L511)

**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 prompts Qwen précalculés

prompt_embeds_clip : Embeddings de prompts CLIP précalculés

negative_prompt_embeds_qwen : Embeddings de prompts négatifs 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 de 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 rappel

**Levée :** ``ValueError``

- ``ValueError`` -- Si les entrées sont invalides

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

#### encode_prompt[[diffusers.Kandinsky5T2VPipeline.encode_prompt]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L418)

**Paramètres :**

prompt (`str` ou `list[str]`) : Invite à 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*, valeur 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[[diffusers.Kandinsky5T2VPipeline.fast_sta_nabla]]

```python
fast_sta_nabla(T: int, H: int, W: int, wT: int = 3, wH: int = 3, wW: int = 3, device = 'cuda')
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L229)

**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 (T*H*W, T*H*W)

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[[diffusers.Kandinsky5T2VPipeline.get_sparse_params]]

```python
get_sparse_params(sample, device)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L264)

**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[[diffusers.Kandinsky5T2VPipeline.prepare_latents]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L597)

**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[[diffusers.Kandinsky5I2VPipeline]]

#### diffusers.Kandinsky5I2VPipeline[[diffusers.Kandinsky5I2VPipeline]]

```python
diffusers.Kandinsky5I2VPipeline(transformer: Kandinsky5Transformer3DModel, vae: AutoencoderKLHunyuanVideo, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: FlowMatchEulerDiscreteScheduler)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L128)

**Paramètres :**

transformer (`Kandinsky5Transformer3DModel`) : Transformer conditionnel pour débruyer les latents vidéo encodés.

vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : Modèle de Variational Auto-Encoder [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) 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](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).

tokenizer (`AutoProcessor`) : Tokenizer pour Qwen2.5-VL.

text_encoder_2 (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) figé, plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).

tokenizer_2 (`CLIPTokenizer`) : Tokenizer pour CLIP.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.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.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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.).

#### __appel__[[diffusers.Kandinsky5I2VPipeline.__call__]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L748)

**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 (classifier-free guidance).

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équence 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 ou non 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 de tenseurs pour la fonction `callback_on_step_end`.

max_sequence_length (`int`, par défaut `512`) : La longueur de séquence maximale 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 :

```python
>>> 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[[diffusers.Kandinsky5I2VPipeline.check_inputs]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L545)

**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 prompts Qwen précalculés

prompt_embeds_clip : Embeddings de prompts CLIP précalculés

negative_prompt_embeds_qwen : Embeddings de prompts négatifs 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 de 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 rappel

**Levée :** ``ValueError``

- ``ValueError`` -- Si les entrées sont invalides

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

#### encode_prompt[[diffusers.Kandinsky5I2VPipeline.encode_prompt]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L454)

**Paramètres :**

prompt (`str` ou `list[str]`) : Invite à 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*, valeur 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[[diffusers.Kandinsky5I2VPipeline.fast_sta_nabla]]

```python
fast_sta_nabla(T: int, H: int, W: int, wT: int = 3, wH: int = 3, wW: int = 3, device = 'cuda')
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L226)

**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 (T*H*W, T*H*W)

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[[diffusers.Kandinsky5I2VPipeline.get_sparse_params]]

```python
get_sparse_params(sample, device)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L261)

**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[[diffusers.Kandinsky5I2VPipeline.prepare_latents]]

```python
prepare_latents(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], batch_size: int, num_channels_latents: int = 16, height: int = 480, width: int = 832, num_frames: int = 81, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L636)

**Paramètres :**

image (PipelineImageInput) : Image d'entrée pour 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
```bibtex
@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
}
```