# Kandinsky 5.0 Image

[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 Image Lite est un modèle de génération d'images léger (6B paramètres).

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
- **Flux VAE** pour un encodage et un décodage d'images efficaces

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 Image Lite :

| model_id | Description | Cas d'utilisation |
|------------|-------------|-----------|
| [**kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers) | Modèle 6B d'images entraîné par fine-tuning supervisé | Qualité de génération la plus élevée |
| [**kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers) | Modèle 6B d'édition d'images entraîné par fine-tuning supervisé | Qualité de génération la plus élevée |
| [**kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers) | Modèle pré-entraîné de base image 6B | Recherche et fine-tuning |
| [**kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers) | Modèle pré-entraîné de base pour l'édition d'images 6B | Recherche et fine-tuning |

## Exemples d'utilisation

### Génération de base de texte en image

```python
import torch
from diffusers import Kandinsky5T2IPipeline

# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers"
pipe = Kandinsky5T2IPipeline.from_pretrained(model_id)
_ = pipe.to(device='cuda',dtype=torch.bfloat16)  # or "mps", "xpu", "cpu"

# Generate image
prompt = "A fluffy, expressive cat wearing a bright red hat with a soft, slightly textured fabric. The hat should look cozy and well-fitted on the cat’s head. On the front of the hat, add clean, bold white text that reads “SWEET”, clearly visible and neatly centered. Ensure the overall lighting highlights the hat’s color and the cat’s fur details."

output = pipe(
    prompt=prompt,
    negative_prompt="",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).image[0]
```

### Génération d'image à partir d'image de base

```python
import torch
from diffusers import Kandinsky5I2IPipeline
from diffusers.utils import load_image 
# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers"
pipe = Kandinsky5I2IPipeline.from_pretrained(model_id)

_ = pipe.to(device='cuda',dtype=torch.bfloat16)  # or "mps", "xpu", "cpu"
pipe.enable_model_cpu_offload()                                               # <--- Enable CPU offloading for single GPU inference

# Edit the input image
image = load_image(
    "https://huggingface.co/kandinsky-community/kandinsky-3/resolve/main/assets/title.jpg?download=true"
)

prompt = "Change the background from a winter night scene to a bright summer day. Place the character on a sandy beach with clear blue sky, soft sunlight, and gentle waves in the distance. Replace the winter clothing with a light short-sleeved T-shirt (in soft pastel colors) and casual shorts. Ensure the character’s fur reflects warm daylight instead of cold winter tones. Add small beach details such as seashells, footprints in the sand, and a few scattered beach toys nearby. Keep the oranges in the scene, but place them naturally on the sand."
negative_prompt = ""

output = pipe(
    image=image,
    prompt=prompt,
    negative_prompt=negative_prompt,
    guidance_scale=3.5,
).image[0]
```

## Kandinsky5T2IPipeline[[diffusers.Kandinsky5T2IPipeline]]

#### diffusers.Kandinsky5T2IPipeline[[diffusers.Kandinsky5T2IPipeline]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L120)

**Paramètres :**

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

vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : modèle Variational Auto-Encoder [black-forest-labs/FLUX.1-dev (vae)](https://huggingface.co/black-forest-labs/FLUX.1-dev) 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/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.

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

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/main/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.Kandinsky5T2IPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 1024, width: int = 1024, num_inference_steps: int = 50, guidance_scale: float = 3.5, num_images_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 = ['latents'], max_sequence_length: int = 512)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L534)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. 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 d’image. 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 `1024`) : La hauteur en pixels de l'image générée.

width (`int`, par défaut `1024`) : La largeur en pixels de l'image 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_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à 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 l'image générée.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ou non retourner un `KandinskyImagePipelineOutput`.

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 :** `~KandinskyImagePipelineOutput` ou `tuple`

Si `return_dict` est `True`, `KandinskyImagePipelineOutput` 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 d'images à partir de texte.

Exemples :

```python
>>> import torch
>>> from diffusers import Kandinsky5T2IPipeline

>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers

>>> model_id = "kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers"
>>> pipe = Kandinsky5T2IPipeline.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."

>>> output = pipe(
...     prompt=prompt,
...     negative_prompt="",
...     height=1024,
...     width=1024,
...     num_inference_steps=50,
...     guidance_scale=3.5,
... ).frames[0]
```

#### check_inputs[[diffusers.Kandinsky5T2IPipeline.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/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L380)

**Paramètres :**

prompt : Invite d'entrée

negative_prompt : Prompt négatif pour le guidage

height : Hauteur de l'image

width : Largeur de l'image

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.Kandinsky5T2IPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_images_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/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L289)

**Paramètres :**

prompt (`str` ou `list[str]`) : Invite à encoder.

num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre d'images à 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. Doit être inférieure à 1024

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_images_per_prompt, sequence_length, embedding_dim)
- Embeddings CLIP agrégés de forme (batch_size * num_images_per_prompt, clip_embedding_dim)
- Longueurs de séquences cumulées (`cu_seqlens`) pour les embeddings Qwen de forme (batch_size * num_images_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 d'images.

#### prepare_latents[[diffusers.Kandinsky5T2IPipeline.prepare_latents]]

```python
prepare_latents(batch_size: int, num_channels_latents: int = 16, height: int = 1024, width: int = 1024, 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/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L469)

**Paramètres :**

batch_size (int) : Nombre d'images à générer

num_channels_latents (int) : Nombre de canaux dans l'espace latent

height (int) : Hauteur de l'image générée

width (int) : Largeur de l'image générée

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 d’images à partir de texte.

Cette méthode crée des latents de bruit aléatoires

## Kandinsky5I2IPipeline[[diffusers.Kandinsky5I2IPipeline]]

#### diffusers.Kandinsky5I2IPipeline[[diffusers.Kandinsky5I2IPipeline]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L120)

**Paramètres :**

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

vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : modèle Variational Auto-Encoder [black-forest-labs/FLUX.1-dev (vae)](https://huggingface.co/black-forest-labs/FLUX.1-dev) 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/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.

Pipeline pour la génération d'image à partir d'image utilisant Kandinsky 5.0.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/main/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.Kandinsky5I2IPipeline.__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 | None = None, width: int | None = None, num_inference_steps: int = 50, guidance_scale: float = 3.5, num_images_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 = ['latents'], max_sequence_length: int = 1024)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L567)

**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 d’image. 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 d’image. 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`) : La hauteur en pixels de l'image générée.

width (`int`) : La largeur en pixels de l'image 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_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à 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 l'image générée.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ou non retourner un `KandinskyImagePipelineOutput`.

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 `1024`) : La longueur de séquence maximale pour l'encodage texte et image de qwen. Doit être inférieure à 1024

**Retourne :** `~KandinskyImagePipelineOutput` ou `tuple`

Si `return_dict` est `True`, `KandinskyImagePipelineOutput` 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 d'image à partir d'image.

Exemples :

```python
>>> import torch
>>> from diffusers import Kandinsky5I2IPipeline

>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers
>>> # kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers

>>> model_id = "kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers"
>>> pipe = Kandinsky5I2IPipeline.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."

>>> output = pipe(
...     prompt=prompt,
...     negative_prompt="",
...     height=1024,
...     width=1024,
...     num_inference_steps=50,
...     guidance_scale=3.5,
... ).frames[0]
```

#### check_inputs[[diffusers.Kandinsky5I2IPipeline.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/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L388)

**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 l'image

width : Largeur de l'image

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.Kandinsky5I2IPipeline.encode_prompt]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L295)

**Paramètres :**

prompt (`str` ou `list[str]`) : Invite à encoder.

num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre d'images à générer par invite.

max_sequence_length (`int`, *facultatif*, valeur par défaut 1024) : Longueur maximale de la séquence pour l'encodage du texte. Doit être inférieure à 1024

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_images_per_prompt, sequence_length, embedding_dim)
- Embeddings CLIP agrégés de forme (batch_size * num_images_per_prompt, clip_embedding_dim)
- Longueurs de séquences cumulées (`cu_seqlens`) pour les embeddings Qwen de forme (batch_size * num_images_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 d'images.

#### prepare_latents[[diffusers.Kandinsky5I2IPipeline.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 = 1024, width: int = 1024, 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/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L482)

**Paramètres :**

image (PipelineImageInput) : Image d'entrée pour conditionner la génération

batch_size (int) : Nombre d'images à générer

num_channels_latents (int) : Nombre de canaux dans l'espace latent

height (int) : Hauteur de l'image générée

width (int) : Largeur de l'image générée

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 l'image encodée

Préparez les variables latentes initiales pour la génération d'image à partir d'image.

Cette méthode crée des latents de bruit aléatoire avec l'image 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
}
```