diffusers/main/fr/api/pipelines/kandinsky5_image.md

Kandinsky 5.0 Image

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

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

model_id	Description	Cas d'utilisation
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	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	Modèle pré-entraîné de base image 6B	Recherche et fine-tuning
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

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

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

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

Source

Paramètres :

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

vae (AutoencoderKL) : modèle Variational Auto-Encoder black-forest-labs/FLUX.1-dev (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) : Tokenizer pour Qwen2.5-VL.

text_encoder_2 (CLIPTextModel) : CLIP figé, plus précisément la variante clip-vit-large-patch14.

tokenizer_2 (CLIPTokenizer) : Tokenizer pour CLIP.

scheduler (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. 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]]

__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[str] = ['latents'], max_sequence_length: int = 512)

Source

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 :

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

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

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

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

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

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

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

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

Source

Paramètres :

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

vae (AutoencoderKL) : modèle Variational Auto-Encoder black-forest-labs/FLUX.1-dev (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) : Tokenizer pour Qwen2.5-VL.

text_encoder_2 (CLIPTextModel) : CLIP figé, plus précisément la variante clip-vit-large-patch14.

tokenizer_2 (CLIPTokenizer) : Tokenizer pour CLIP.

scheduler (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. 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]]

__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[str] = ['latents'], max_sequence_length: int = 1024)

Source

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 :

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

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

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

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

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

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

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

@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
}