Hugging Face's logo

Diffusers documentation

Kandinsky 5.0 Image

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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_idDescriptionCas d'utilisation
kandinskylab/Kandinsky-5.0-T2I-Lite-sft-DiffusersModè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-DiffusersModè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-DiffusersModèle pré-entraîné de base image 6BRecherche et fine-tuning
kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-DiffusersModèle pré-entraîné de base pour l'édition d'images 6BRecherche 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

classe diffusers.Kandinsky5T2IPipeline

< >

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

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

__call__

< >

( prompt: str | list[str] = Nonenegative_prompt: str | list[str] | None = Noneheight: int = 1024width: int = 1024num_inference_steps: int = 50guidance_scale: float = 3.5num_images_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 ) → ~KandinskyImagePipelineOutput or tuple

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.
  • 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é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 l’image générée.
  • return_dict (bool, facultatif, par défaut True) — Indique s'il faut 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 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

~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

< >

( 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 l'image
  • width — Largeur de l'image
  • 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

< >

( prompt: str | list[str]num_images_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_images_per_prompt (int, facultatif, valeur par défaut 1) — Nombre d'images à 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. 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

< >

( batch_size: intnum_channels_latents: int = 16height: int = 1024width: int = 1024dtype: 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 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

classe diffusers.Kandinsky5I2IPipeline

< >

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

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

__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] = Nonenegative_prompt: str | list[str] | None = Noneheight: int | None = Nonewidth: int | None = Nonenum_inference_steps: int = 50guidance_scale: float = 3.5num_images_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 = 1024 ) → ~KandinskyImagePipelineOutput 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 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.
  • 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é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 l’image générée.
  • return_dict (bool, facultatif, par défaut True) — Indique s'il faut 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 tensorielles 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

< >

( 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 l'image
  • width — Largeur de l'image
  • 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

< >

( prompt: str | list[str]image: Tensornum_images_per_prompt: int = 1max_sequence_length: int = 1024device: 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_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

< >

( 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 = 1024width: int = 1024dtype: 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 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
}
Update on GitHub

←Kandinsky 3 Kolors→