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

Kandinsky 6

Kandinsky 6 est une famille de modèles de génération vidéo de Kandinsky Lab. 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.

Consultez l'organisation Kandinsky Lab 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 à é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	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 étapes
kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers	Kandinsky6TI2VAPipeline	Distillé, guidance_scale=1.0, 10 étapes
kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 étapes
kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers	Kandinsky6TI2VAPipeline	Distillé, guidance_scale=1.0, 10 étapes
kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 étapes
kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 étapes
kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers	Kandinsky6SRPipeline	Super-résolution par correspondance de flux
kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers	Kandinsky6SRPipeline	Super-résolution distillée, 2 étapes

Texte/image-vers-vidéo-et-audio

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 prend les images produites par 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.

# 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 pour l’ensemble général des techniques. Les pipelines Kandinsky6TI2VAPipeline et Kandinsky6SRPipeline prennent en charge le model offloading (utilisé ci-dessus) et, pour une empreinte plus réduite au détriment de la vitesse, le sequential CPU offloading :

pipe.enable_sequential_cpu_offload()

Le VAE vidéo de Kandinsky6TI2VAPipeline prend également en charge le décodage par tuiles pour les hautes résolutions ou les vidéos longues :

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 (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 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 :

  pipe.transformer.compile_repeated_blocks(fullgraph=True)
  

Kandinsky6TI2VAPipeline[[diffusers.Kandinsky6TI2VAPipeline]]

diffusers.Kandinsky6TI2VAPipeline[[diffusers.Kandinsky6TI2VAPipeline]]

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

Paramètres :

transformer (Kandinsky6Transformer3DModel) : Transformer multimodal qui débruite les latents vidéo et audio.

vae (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) : 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) : Processeur de text_encoder.

text_encoder_2 (CLIPTextModel) : encodeur de texte CLIP fournissant l'embedding de texte agrégé.

tokenizer_2 (CLIPTokenizer) : Tokenizer de text_encoder_2.

scheduler (FlowMatchEulerDiscreteScheduler ou PiflowScheduler) : planificateur utilisé avec transformer pour débruyer les latents. Les points de contrôle distillés sont fournis avec un PiflowScheduler et doivent être exécutés avec guidance_scale=1.0.

audio_vae (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, 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. 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]]

__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

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.

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() 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 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 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 :

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

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

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

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

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

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

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

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

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

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

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

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

Paramètres :

transformer (Kandinsky6SRTransformer3DModel) : Transformer qui affine les tuiles latentes.

vae (Kandinsky6SRVAE) : K-VAE vidéo causal utilisé pour encoder la vidéo d’entrée et décoder les tuiles affinées.

scheduler (FlowMatchEulerDiscreteScheduler ou PiflowScheduler) : planificateur utilisé avec transformer pour débruitiser les tuiles. Les points de contrôle distillés sont fournis avec un PiflowScheduler.

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

__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

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(), 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 plutôt qu'un simple tuple.

Retourne : 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 :

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

decode_latents(latents: Tensor)

Source

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

encode_video(video: Tensor)

Source

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

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

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 : un Kandinsky6SRLatentUpscaler par échelle spatiale prise en charge, opérant sur les latents K-VAE.

forward[[diffusers.Kandinsky6SRLatentUpscalerBank.forward]]

forward(latents: Tensor, scale: int, return_dict: bool = True)

Source

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

diffusers.Kandinsky6TI2VAPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]], audio: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None)

Source

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.

Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]]

diffusers.Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]]

diffusers.Kandinsky6SRPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]])

Source

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.