# Kandinsky 6 Kandinsky 6 est une famille de modèles de génération vidéo de [Kandinsky Lab](https://huggingface.co/kandinskylab). Le modèle principal génère une vidéo et un audio synchronisés à partir d'un texte ou d'une image de référence au moyen d'un unique transformeur de diffusion multimodal : les latents vidéo et audio sont débruités ensemble à travers des blocs fusionnés qui effectuent une attention croisée entre les deux modalités, chacun étant conditionné par sa propre branche de texte Qwen2.5-VL et par un embedding CLIP agrégé. Un modèle de super-résolution distinct agrandit la vidéo générée tuile par tuile dans l'espace latent d'un K-VAE 3D causal. > [!TIP] > Consultez l'organisation [Kandinsky Lab](https://huggingface.co/kandinskylab) sur le Hub pour l'ensemble des points de contrôle officiels, y compris les variantes flow-matching et distillées des modèles de base et de super-résolution. > > Les points de contrôle distillés sont livrés avec le [PiflowScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/piflow#diffusers.PiflowScheduler) à étapes réduites et doivent être exécutés avec `guidance_scale=1.0`. ## Modèles disponibles | Modèle | Pipeline | Notes | |---|---|---| | [`kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 étapes | | [`kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Distillé, `guidance_scale=1.0`, 10 étapes | | [`kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 étapes | | [`kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Distillé, `guidance_scale=1.0`, 10 étapes | | [`kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 étapes | | [`kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 étapes | | [`kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers) | [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) | Super-résolution par correspondance de flux | | [`kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers) | [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) | Super-résolution distillée, 2 étapes | ## Texte/image-vers-vidéo-et-audio ```python import torch from diffusers import Kandinsky6TI2VAPipeline from diffusers.utils import encode_video pipe = Kandinsky6TI2VAPipeline.from_pretrained( "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16 ) pipe.enable_model_cpu_offload() output = pipe( prompt="A cat and a dog baking a cake together in a kitchen.", height=480, width=864, num_frames=121, num_inference_steps=10, guidance_scale=1.0, ) encode_video( output.frames[0], fps=24, output_path="output.mp4", audio=output.audio[0][None], audio_sample_rate=pipe.audio_sample_rate, ) ``` Passez `image=` pour conditionner la première image sur une image de référence, `sample_audio=False` pour générer uniquement la vidéo, et `expand_prompts=True` pour laisser l’encodeur de texte Qwen2.5-VL réécrire d’abord les prompts courts en prompts détaillés. ## Super-résolution vidéo [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) prend les images produites par [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) et les agrandit par un facteur de `2`, `4` ou `2.25` (un pré-agrandissement bilinéaire de 1,125x suivi du chemin 2x). La vidéo est découpée en tuiles chevauchantes, chaque tuile est affinée à l'une des tailles de tuiles sur lesquelles le transformeur SR a été entraîné, et les tuiles sont recombinées à l'aide de fenêtres de Hann. ```python # required: lets inductor pick flex-attention tiles that fit the SR block mask torch._inductor.config.max_autotune = True sr_pipe = Kandinsky6SRPipeline.from_pretrained( "kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers", torch_dtype=torch.bfloat16 ) # The SR transformer always runs NABLA sparse attention on the `flex` backend. Compile it, otherwise flex falls # back to an eager implementation that needs far more memory at video resolutions. sr_pipe.enable_model_cpu_offload() sr_pipe.transformer.set_attention_backend("flex") sr_pipe.transformer.compile_repeated_blocks(fullgraph=True) upscaled = sr_pipe(video=output.frames[0], resolution_scale=2.25, num_inference_steps=2).frames[0] ``` ## Optimisation de la mémoire Reportez-vous au guide [Réduire l’utilisation de la mémoire](../../optimization/memory) pour l’ensemble général des techniques. Les pipelines [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) et [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) prennent en charge le [model offloading](../../optimization/memory#model-offloading) (utilisé ci-dessus) et, pour une empreinte plus réduite au détriment de la vitesse, le [sequential CPU offloading](../../optimization/memory#cpu-offloading) : ```python pipe.enable_sequential_cpu_offload() ``` Le VAE vidéo de [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) prend également en charge le [décodage par tuiles](../../optimization/memory#vae-tiling) pour les hautes résolutions ou les vidéos longues : ```python pipe.vae.enable_tiling() ``` ## Notes - `height` et `width` doivent être divisibles par le ratio de compression spatiale du VAE vidéo multiplié par la taille de patch du transformer — `16` avec la configuration par défaut de [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) (`AutoencoderKLHunyuanVideo` avec un ratio de compression de `8`, `patch_size=(1, 2, 2)`). `480x864`, utilisé dans l’exemple ci-dessus, satisfait cette condition. - L'entrée `video` de [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) doit contenir `1 + k * vae_scale_factor_temporal` images pour un entier `k` (un ratio de compression temporelle de `4` avec la configuration K-VAE par défaut, donc `121` images fonctionne mais `120` non) — rognez ou complétez une vidéo qui ne satisfait pas déjà cette condition avant de l'augmenter. - `expand_prompts=True` réutilise l’encodeur de texte Qwen2.5-VL déjà chargé pour un passage de génération supplémentaire avant le débruitage, ce qui ajoute de la latence mais aucun poids de modèle supplémentaire. - Compiler les blocs de transformeurs répétés pour une inférence répétée plus rapide : ```python pipe.transformer.compile_repeated_blocks(fullgraph=True) ``` ## Kandinsky6TI2VAPipeline[[diffusers.Kandinsky6TI2VAPipeline]] #### diffusers.Kandinsky6TI2VAPipeline[[diffusers.Kandinsky6TI2VAPipeline]] ```python diffusers.Kandinsky6TI2VAPipeline(transformer: Kandinsky6Transformer3DModel, vae: AutoencoderKLHunyuanVideo, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2_5_VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowScheduler, audio_vae: diffusers.models.autoencoders.autoencoder_mmaudio.MMAudioVAE | None = None, vocoder: diffusers.models.autoencoders.mmaudio_vocoder.MMAudioVocoder | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L178) **Paramètres :** transformer ([Kandinsky6Transformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/kandinsky6_transformer#diffusers.Kandinsky6Transformer3DModel)) : Transformer multimodal qui débruite les latents vidéo et audio. vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : VAE vidéo utilisé pour encoder l'image de référence et décoder la vidéo générée. text_encoder ([Qwen2_5_VLForConditionalGeneration](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/qwen2_5_vl#transformers.Qwen2_5_VLForConditionalGeneration)) : modèle Qwen2.5-VL fournissant les embeddings de texte au niveau des jetons et, en option, l’expansion du prompt. tokenizer ([Qwen2_5_VLProcessor](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/qwen2_5_vl#transformers.Qwen2_5_VLProcessor)) : Processeur de `text_encoder`. text_encoder_2 ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : encodeur de texte CLIP fournissant l'embedding de texte agrégé. tokenizer_2 ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Tokenizer de `text_encoder_2`. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) ou [PiflowScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/piflow#diffusers.PiflowScheduler)) : planificateur utilisé avec `transformer` pour débruyer les latents. Les points de contrôle distillés sont fournis avec un [PiflowScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/piflow#diffusers.PiflowScheduler) et doivent être exécutés avec `guidance_scale=1.0`. audio_vae ([MMAudioVAE](/docs/diffusers/v0.43.0/fr/api/models/kandinsky6_vae#diffusers.MMAudioVAE), *facultatif*) : VAE audio utilisé pour décoder les latents audio générés en spectrogramme de mel. Nécessaire uniquement lorsque `sample_audio=True`. vocoder ([MMAudioVocoder](/docs/diffusers/v0.43.0/fr/api/models/kandinsky6_vae#diffusers.MMAudioVocoder), *facultatif*) : Vocodeur utilisé pour convertir le spectrogramme mel décodé par `audio_vae` en forme d’onde. Nécessaire uniquement lorsque `sample_audio=True`. Pipeline pour la génération de vidéo et d'audio à partir de texte/image avec Kandinsky 6. Les latents vidéo et audio sont débruités ensemble par un unique transformeur multimodal, conditionné par les jetons texte de Qwen2.5-VL et un embedding agrégé de CLIP. Une image de référence facultative conditionne la première image. 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.Kandinsky6TI2VAPipeline.__call__]] ```python __call__(prompt: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, num_inference_steps: int = 50, timesteps: list[int] | None = None, sigmas: list[float] | None = None, guidance_scale: float = 5.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, sample_audio: bool = True, expand_prompts: bool = False, max_sequence_length: int = 1024, output_type: str = 'pil', return_dict: bool = True, callback_on_step_end: collections.abc.Callable[[int, int, dict], None] | None = None, callback_on_step_end_tensor_inputs: list[str] = ['latents']) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L644) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération. Requis sauf si `prompt_embeds` est fourni. image (`PipelineImageInput`, *facultatif*) : Image(s) de référence conditionnant le premier plan (image-vers-vidéo-et-audio). negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération. Par défaut, le prompt négatif de Kandinsky 6 est utilisé. height (`int`, par défaut `512`) : Hauteur de la vidéo générée, en pixels. width (`int`, par défaut `768`) : Largeur de la vidéo générée en pixels. num_frames (`int`, par défaut `121`) : Nombre de frames générées. frame_rate (`float`, par défaut `24.0`) : Fréquence d'images à laquelle la vidéo est générée ; définit la durée de l'audio synchronisé. num_inference_steps (`int`, par défaut `50`) : Le nombre d'étapes de débruitage. Utilisez `16` avec les points de contrôle distillés. timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées pour les planificateurs qui les prennent en charge. sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés pour les planificateurs qui les prennent en charge. guidance_scale (`float`, par défaut `5.0`) : Échelle de guidage sans classifieur. Doit être `1.0` avec un [PiflowScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/piflow#diffusers.PiflowScheduler). num_videos_per_prompt (`int`, par défaut `1`) : Le nombre de vidéos à générer par invite. generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Générateur(s) utilisé(s) pour le bruit initial et l'encodage de l'image de référence. latents (`torch.Tensor`, *facultatif*) : Latents vidéo pré-générés de forme `(batch_size, channels, num_latent_frames, latent_height, latent_width)`. audio_latents (`torch.Tensor`, *facultatif*) : Latents audio pré-générés de forme `(batch_size, channels, audio_length)`. prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte Qwen2.5-VL pré-générés. pooled_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte CLIP pré-générés. negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatifs Qwen2.5-VL pré-générés. negative_pooled_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte CLIP pré-générés négatifs. sample_audio (`bool`, par défaut `True`) : Indique s'il faut générer un audio synchronisé. Nécessite que le pipeline dispose d'un `audio_vae` et d'un `vocoder`. expand_prompts (`bool`, par défaut `False`) : Indique s'il faut réécrire les prompts avec [expand_prompts()](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline.expand_prompts) avant l'encodage. max_sequence_length (`int`, par défaut `1024`) : Nombre maximal de jetons de prompt après le modèle de chat. output_type (`str`, par défaut `"pil"`) : Le format de sortie de la vidéo générée : `"pil"`, `"np"`, `"pt"` ou `"latent"`. return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un [Kandinsky6TI2VAPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipelineOutput) plutôt qu'un simple tuple. callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage avec `callback_on_step_end(self, step, timestep, callback_kwargs)`. Elle peut renvoyer un dictionnaire qui remplace les tenseurs listés. callback_on_step_end_tensor_inputs (`list[str]`, par défaut `["latents"]`) : Tenseurs d'entrée passés à `callback_on_step_end` ; un sous-ensemble de `_callback_tensor_inputs`. **Retourne :** [Kandinsky6TI2VAPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipelineOutput) ou `tuple` La vidéo et l'audio générés ; un tuple `(frames, audio)` lorsque `return_dict=False`. La fonction d'appel du pipeline pour la génération. Exemples : ```python >>> import torch >>> from diffusers import Kandinsky6TI2VAPipeline >>> from diffusers.utils import encode_video >>> pipe = Kandinsky6TI2VAPipeline.from_pretrained( ... "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16 ... ) >>> pipe.enable_model_cpu_offload() >>> output = pipe( ... prompt="A cat and a dog baking a cake together in a kitchen.", ... height=480, ... width=864, ... num_frames=121, ... num_inference_steps=16, ... guidance_scale=1.0, ... ) >>> encode_video( ... output.frames[0], ... fps=24, ... output_path="output.mp4", ... audio=output.audio[0][None], ... audio_sample_rate=pipe.audio_sample_rate, ... ) ``` #### encode_image[[diffusers.Kandinsky6TI2VAPipeline.encode_image]] ```python encode_image(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], height: int, width: int, device: device, dtype: dtype, num_videos_per_prompt: int = 1, generator: typing.Optional[torch.Generator] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L551) Encode les image(s) de référence en latents de première image de forme `(batch_size, latent_height, latent_width, latent_channels)`, mis à l'échelle par le `scaling_factor` du VAE. Les images PIL sont redimensionnées et recadrées au centre sur `height x width` ; les tenseurs et tableaux doivent déjà avoir cette taille. Les latents sont répétés `num_videos_per_prompt` fois le long de la dimension de lot. #### encode_prompt[[diffusers.Kandinsky6TI2VAPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, 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/kandinsky6/pipeline_kandinsky6_ti2va.py#L309) **Paramètres :** prompt (`str` ou `list[str]`) : Invite à encoder. negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt à ne pas utiliser pour guider la génération. Ignoré lorsque `do_classifier_free_guidance` est `False`. do_classifier_free_guidance (`bool`, par défaut `True`) : Indique s'il faut également encoder le prompt négatif. num_videos_per_prompt (`int`, par défaut `1`) : Nombre de vidéos générées par invite ; les embeddings sont répétés en conséquence. prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte Qwen2.5-VL pré-générés. Permet de passer l'encodage de `prompt`. pooled_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte CLIP pré-générés. Doit être fourni avec `prompt_embeds`. prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque de bourrage booléen de `prompt_embeds`. negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatifs Qwen2.5-VL pré-générés. negative_pooled_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte CLIP pré-générés négatifs. negative_prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque de bourrage booléen de `negative_prompt_embeds`. max_sequence_length (`int`, par défaut `1024`) : Nombre maximal de jetons de prompt après le modèle de chat. device (`torch.device`, *facultatif*) : Appareil sur lequel exécuter les encodeurs de texte. dtype (`torch.dtype`, *facultatif*) : Dtype des embeddings renvoyés. Encode le prompt dans les états cachés de l'encodeur de texte. #### expand_prompts[[diffusers.Kandinsky6TI2VAPipeline.expand_prompts]] ```python expand_prompts(prompt: str | list[str], tokenizer, text_encoder, device: device, image: PIL.Image.Image | list[PIL.Image.Image] | None = None, max_sequence_length: int = 1024, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L412) **Paramètres :** prompt (`str` ou `list[str]`) : Prompt ou prompts à développer. tokenizer : le processeur Qwen2.5-VL, par exemple `pipe.tokenizer`. text_encoder : le modèle Qwen2.5-VL, par exemple `pipe.text_encoder`. device (`torch.device`) : Appareil sur lequel exécuter l'encodeur de texte. image (`PIL.Image.Image` ou `list[PIL.Image.Image]`, *facultatif*) : Image(s) de référence pour un appel image-vers-vidéo. max_sequence_length (`int`, par défaut `1024`) : Nombre maximal de jetons générés par invite. generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Sème l'expansion échantillonnée ; une liste doit correspondre à la longueur de `prompt`, un générateur par élément. `generate` tire de la RNG globale, de sorte que la RNG globale est semée à partir de la graine de ce générateur ; les appels ultérieurs à `randn_tensor` continuent d'utiliser directement `generator`. **Retourne :** `str` ou `list[str]` Le(s) prompt(s) étendu(s). Réécrit les prompts courts en prompts vidéo+audio détaillés avec l’encodeur de texte Qwen2.5-VL, en s’appuyant sur l’image de référence lorsqu’une est fournie. Il s’agit d’une `staticmethod` afin qu’elle puisse être utilisée de manière autonome, avant l’exécution du pipeline. #### prepare_audio_latents[[diffusers.Kandinsky6TI2VAPipeline.prepare_audio_latents]] ```python prepare_audio_latents(batch_size: int, num_channels_latents: int, audio_length: int, dtype: dtype, device: device, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType], audio_latents: typing.Optional[torch.Tensor] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L607) Retourne les latents audio dans la disposition `(batch_size, audio_length, channels)` du transformer. Un tenseur `audio_latents` fourni par l'utilisateur est attendu dans la disposition `(batch_size, channels, audio_length)`. #### prepare_latents[[diffusers.Kandinsky6TI2VAPipeline.prepare_latents]] ```python prepare_latents(batch_size: int, num_channels_latents: int, height: int, width: int, num_frames: int, dtype: dtype, device: device, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType], latents: typing.Optional[torch.Tensor] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L578) Retourne les latents vidéo dans la disposition `(batch_size, num_frames, height, width, channels)` du transformer. Un tenseur `latents` fourni par l'utilisateur est attendu dans la disposition `(batch_size, channels, num_frames, height, width)`. ## Kandinsky6SRPipeline[[diffusers.Kandinsky6SRPipeline]] #### diffusers.Kandinsky6SRPipeline[[diffusers.Kandinsky6SRPipeline]] ```python diffusers.Kandinsky6SRPipeline(transformer: Kandinsky6SRTransformer3DModel, vae: Kandinsky6SRVAE, scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowScheduler, latent_upscaler: diffusers.models.latent_upscaler.latent_upscaler_kandinsky6_sr.Kandinsky6SRLatentUpscalerBank | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L143) **Paramètres :** transformer ([Kandinsky6SRTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/kandinsky6_transformer#diffusers.Kandinsky6SRTransformer3DModel)) : Transformer qui affine les tuiles latentes. vae ([Kandinsky6SRVAE](/docs/diffusers/v0.43.0/fr/api/models/kandinsky6_vae#diffusers.Kandinsky6SRVAE)) : K-VAE vidéo causal utilisé pour encoder la vidéo d’entrée et décoder les tuiles affinées. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) ou [PiflowScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/piflow#diffusers.PiflowScheduler)) : planificateur utilisé avec `transformer` pour débruitiser les tuiles. Les points de contrôle distillés sont fournis avec un [PiflowScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/piflow#diffusers.PiflowScheduler). latent_upscaler ([Kandinsky6SRLatentUpscalerBank](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRLatentUpscalerBank), *facultatif*) : Upscaleurs latents pour les échelles prises en charge. Pipeline de super-résolution vidéo avec Kandinsky 6. La vidéo est découpée en tuiles spatiales chevauchantes, chaque tuile est affinée par le transformeur SR à l'une des tailles de tuiles sur lesquelles le modèle a été entraîné (`transformer.config.tile_sizes`), et les tuiles affinées sont recombinées à l'aide de fenêtres de Hann. Lorsque le pipeline dispose d'un `latent_upscaler`, les tuiles sont extraites des latents K-VAE de la vidéo entière et agrandies dans l'espace latent ; sinon, les tuiles en pixels sont agrandies par interpolation bilinéaire puis encodées. 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.Kandinsky6SRPipeline.__call__]] ```python __call__(video: typing.Union[list[PIL.Image.Image], list[list[PIL.Image.Image]], numpy.ndarray, torch.Tensor], resolution_scale: float = 2.25, num_inference_steps: int = 4, timesteps: list[int] | None = None, sigmas: list[float] | None = None, lq_noise_scale: float = 0.7, min_overlap: float = 0.2, tiles_batch_size: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str = 'pil', return_dict: bool = True) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L228) **Paramètres :** video (`list[PIL.Image.Image]`, `np.ndarray` ou `torch.Tensor`) : La ou les vidéos basse résolution, dans n'importe quel format accepté par [preprocess_video()](/docs/diffusers/v0.43.0/fr/api/video_processor#diffusers.VideoProcessor.preprocess_video), avec `1 + k * 4` images. Les dimensions sont arrondies à la valeur inférieure multiple du facteur spatial du VAE. resolution_scale (`float`, par défaut `2.25`) : Mise à l'échelle spatiale totale : `2`, `4` ou `2.25` (une pré-mise à l'échelle bilinéaire de 1,125x suivie du chemin 2x). num_inference_steps (`int`, par défaut `4`) : Le nombre d'étapes de débruitage par tuile. Utilisez `2` avec les points de contrôle distillés. timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées pour les planificateurs qui les prennent en charge. sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés pour les planificateurs qui les prennent en charge. lq_noise_scale (`float`, par défaut `0.7`) : Quantité de bruit gaussien mélangée aux latents basse résolution (préservation de la variance) avant le débruitage. min_overlap (`float`, par défaut `0.2`) : Recouvrement minimal entre les tuiles voisines, exprimé en fraction de la taille de la tuile. tiles_batch_size (`int`, par défaut `1`) : Nombre de tuiles débruitées par appel du transformer. generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Générateur(s) utilisé(s) pour le bruit mélangé aux tuiles. output_type (`str`, par défaut `"pil"`) : Le format de sortie de la vidéo générée : `"pil"`, `"np"` ou `"pt"`. return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un [Kandinsky6SRPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipelineOutput) plutôt qu'un simple tuple. **Retourne :** [Kandinsky6SRPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipelineOutput) ou `tuple` La vidéo super-résolue ; un tuple à un élément lorsque `return_dict=False`. La fonction d'appel du pipeline pour la super-résolution. Exemples : ```python >>> import torch >>> from diffusers import Kandinsky6SRPipeline, Kandinsky6TI2VAPipeline >>> from diffusers.utils import export_to_video >>> pipe = Kandinsky6TI2VAPipeline.from_pretrained( ... "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16 ... ) >>> pipe.enable_model_cpu_offload() >>> video = pipe( ... prompt="A cat and a dog baking a cake together in a kitchen.", ... height=480, ... width=864, ... num_inference_steps=16, ... guidance_scale=1.0, ... sample_audio=False, ... ).frames[0] >>> sr_pipe = Kandinsky6SRPipeline.from_pretrained( ... "kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers", torch_dtype=torch.bfloat16 ... ) >>> # The transformer always runs attention through the `flex` backend; compiling avoids the eager >>> # fallback's much higher memory use at video resolutions. >>> sr_pipe.transformer.compile_repeated_blocks(fullgraph=True) >>> sr_pipe.enable_model_cpu_offload() >>> output = sr_pipe(video=video, resolution_scale=2.25, num_inference_steps=2) >>> export_to_video(output.frames[0], "output_sr.mp4", fps=24) ``` #### decode_latents[[diffusers.Kandinsky6SRPipeline.decode_latents]] ```python decode_latents(latents: Tensor) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L223) Décode les latents K-VAE mis à l'échelle en une vidéo de forme `(batch_size, channels, num_frames, height, width)` dans l'intervalle `[-1, 1]`. #### encode_video[[diffusers.Kandinsky6SRPipeline.encode_video]] ```python encode_video(video: Tensor) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L213) Encode une vidéo de forme `(batch_size, channels, num_frames, height, width)` dans `[-1, 1]` en latents K-VAE mis à l'échelle par le `scaling_factor` du VAE. ## Kandinsky6SRLatentUpscalerBank[[diffusers.Kandinsky6SRLatentUpscalerBank]] #### diffusers.Kandinsky6SRLatentUpscalerBank[[diffusers.Kandinsky6SRLatentUpscalerBank]] ```python diffusers.Kandinsky6SRLatentUpscalerBank(in_channels: int = 64, stage_channels: tuple[int, int, int] = (2048, 1024, 512), num_pre_blocks: int = 5, num_mid_blocks: int = 3, num_post_blocks: int = 3, num_x2_adapter_blocks: int = 2, scales: tuple[int, ...] = (2, 4), scaling_factor: float = 0.910344004631042) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/latent_upscaler/latent_upscaler_kandinsky6_sr.py#L251) **Paramètres :** in_channels (`int`, par défaut `64`) : Nombre de canaux latents. stage_channels (`tuple[int, int, int]`, par défaut `(2048, 1024, 512)`) : Largeurs des fonctionnalités des trois stades de la cascade. num_pre_blocks (`int`, par défaut `5`) : Blocs résiduels avant le premier upsample du modèle x4. num_mid_blocks (`int`, par défaut `3`) : Blocs résiduels entre les deux opérations d'augmentation de résolution. num_post_blocks (`int`, par défaut `3`) : Blocs résiduels après le dernier upsample. num_x2_adapter_blocks (`int`, par défaut `2`) : Blocs résiduels de l'adaptateur du modèle x2. scales (`tuple[int, ...]`, par défaut `(2, 4)`) : Échelles spatiales pour lesquelles la banque fournit un upscaler. scaling_factor (`float`, par défaut `0.910344`) : Échelle que les latents d'entrée sont censés porter (le `scaling_factor` du K-VAE). Banque de redimensionneurs latents utilisés par [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) : un `Kandinsky6SRLatentUpscaler` par échelle spatiale prise en charge, opérant sur les latents K-VAE. #### forward[[diffusers.Kandinsky6SRLatentUpscalerBank.forward]] ```python forward(latents: Tensor, scale: int, return_dict: bool = True) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/latent_upscaler/latent_upscaler_kandinsky6_sr.py#L305) **Paramètres :** latents (`torch.Tensor` de forme `(batch_size, in_channels, num_frames, height, width)`) : latents K-VAE mis à l'échelle par `scaling_factor`. scale (`int`) : Facteur de mise à l'échelle spatiale ; l'un des `scales`. return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `~models.autoencoder_kl.DecoderOutput` plutôt qu'un simple tuple. **Retourne :** Les latents agrandis de forme `(batch_size, in_channels, num_frames, height * scale, width * scale)`. ## Kandinsky6TI2VAPipelineOutput[[diffusers.Kandinsky6TI2VAPipelineOutput]] #### diffusers.Kandinsky6TI2VAPipelineOutput[[diffusers.Kandinsky6TI2VAPipelineOutput]] ```python diffusers.Kandinsky6TI2VAPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]], audio: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_output.py#L25) **Paramètres :** frames (`torch.Tensor`, `np.ndarray` ou `list[list[PIL.Image.Image]]`) : La vidéo générée. Une liste imbriquée de longueur `batch_size` contenant `num_frames` images PIL chacune, ou un tableau NumPy ou un tenseur torch de forme `(batch_size, num_frames, height, width, channels)` / `(batch_size, num_frames, channels, height, width)`. Avec `output_type="latent"`, les latents de la vidéo de forme `(batch_size, channels, num_latent_frames, latent_height, latent_width)`. audio (`torch.Tensor` ou `np.ndarray`, *facultatif*) : Les formes d'onde générées de forme `(batch_size, num_samples)` dans `[-1, 1]` à la fréquence d'échantillonnage du VAE audio, ou `None` si l'audio n'a pas été échantillonné. Avec `output_type="latent"`, les latents audio de forme `(batch_size, channels, audio_length)`. Classe de sortie pour [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline). ## Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]] #### diffusers.Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]] ```python diffusers.Kandinsky6SRPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]]) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky6/pipeline_output.py#L46) **Paramètres :** frames (`torch.Tensor`, `np.ndarray` ou `list[list[PIL.Image.Image]]`) : La vidéo super-résolue. Une liste imbriquée de longueur `batch_size` contenant `num_frames` images PIL chacune, ou un tableau NumPy ou un tenseur torch de forme `(batch_size, num_frames, height, width, channels)` / `(batch_size, num_frames, channels, height, width)`. Classe de sortie pour [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline).