Buckets:
| # 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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) prend les images produites par [Kandinsky6TI2VAPipeline](/docs/diffusers/main/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/main/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) et [Kandinsky6SRPipeline](/docs/diffusers/main/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/main/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/main/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/main/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/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L178) | |
| **Paramètres :** | |
| transformer ([Kandinsky6Transformer3DModel](/docs/diffusers/main/fr/api/models/kandinsky6_transformer#diffusers.Kandinsky6Transformer3DModel)) : Transformer multimodal qui débruite les latents vidéo et audio. | |
| vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/main/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/main/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/main/en/model_doc/qwen2_5_vl#transformers.Qwen2_5_VLProcessor)) : Processeur de `text_encoder`. | |
| text_encoder_2 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/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/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Tokenizer de `text_encoder_2`. | |
| scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) ou [PiflowScheduler](/docs/diffusers/main/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/main/fr/api/schedulers/piflow#diffusers.PiflowScheduler) et doivent être exécutés avec `guidance_scale=1.0`. | |
| audio_vae ([MMAudioVAE](/docs/diffusers/main/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/main/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/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.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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L143) | |
| **Paramètres :** | |
| transformer ([Kandinsky6SRTransformer3DModel](/docs/diffusers/main/fr/api/models/kandinsky6_transformer#diffusers.Kandinsky6SRTransformer3DModel)) : Transformer qui affine les tuiles latentes. | |
| vae ([Kandinsky6SRVAE](/docs/diffusers/main/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/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) ou [PiflowScheduler](/docs/diffusers/main/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/main/fr/api/schedulers/piflow#diffusers.PiflowScheduler). | |
| latent_upscaler ([Kandinsky6SRLatentUpscalerBank](/docs/diffusers/main/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/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.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/main/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/main/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/main/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipelineOutput) plutôt qu'un simple tuple. | |
| **Retourne :** [Kandinsky6SRPipelineOutput](/docs/diffusers/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline). | |
Xet Storage Details
- Size:
- 37.1 kB
- Xet hash:
- 6e97f4331e72cb4abbe0aeb28a4a78da7f288c3a2b9546195621972e6293d25b
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.