# Kandinsky S2V 1.0

Kandinsky S2V 1.0 génère une vidéo d'avatar à partir d'une image de référence et d'une piste audio. La personne dans l'image est animée pour correspondre à la parole — la figure entière, et non seulement la tête. La parole est une condition, et non une sortie : le modèle ne génère pas d'audio, et la bande-son du résultat est la piste que vous transmettez.

Les deux conditions passent par [Qwen2.5-Omni-7B](https://huggingface.co/Qwen/Qwen2.5-Omni-7B) : ses états cachés encodent le prompt et sa tour audio encodent la parole, qui entre dans le transformeur via des adaptateurs d'attention croisée alignés image par image, de sorte que chaque image latente ne porte attention qu'à la parole qu'elle couvre. Un clip est généré par blocs de 5 s (125 images à 25 ips), chacun portant la mémoire FramePack des précédents, afin que les pistes plus longues restent cohérentes aux frontières des blocs.

Kandinsky S2V 1.0 est intégré uniquement en tant que [pipeline modulaire](../../modular_diffusers/overview) ; il n'existe pas de classe `DiffusionPipeline` standard pour ce modèle.

## Points de contrôle

| Point de contrôle | Transformer | Blocs | Planificateur | Étapes | Orientation |
|---|---|---|---|---|---|
| [Lite][lite] | 2B | [KandinskyS2VAutoBlocks](/docs/diffusers/main/fr/api/pipelines/kandinsky_s2v#diffusers.KandinskyS2VAutoBlocks) | [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) | 50 | 3.0 |
| [Pro][pro] | 21B | [KandinskyS2VAutoBlocks](/docs/diffusers/main/fr/api/pipelines/kandinsky_s2v#diffusers.KandinskyS2VAutoBlocks) | [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) | 50 | 3.0 |
| [Distillé Lite][lite-distill] | 2B | [KandinskyS2VDistilledAutoBlocks](/docs/diffusers/main/fr/api/pipelines/kandinsky_s2v#diffusers.KandinskyS2VDistilledAutoBlocks) | [PiflowScheduler](/docs/diffusers/main/fr/api/schedulers/piflow#diffusers.PiflowScheduler) | 16 | off |
| [Pro distillé][pro-distill] | 21B | [KandinskyS2VDistilledAutoBlocks](/docs/diffusers/main/fr/api/pipelines/kandinsky_s2v#diffusers.KandinskyS2VDistilledAutoBlocks) | [PiflowScheduler](/docs/diffusers/main/fr/api/schedulers/piflow#diffusers.PiflowScheduler) | 16 | off |

Les points de contrôle distillés configurent `PiflowScheduler` avec `shift=10.0` et `n_grid=5`, et non avec ses valeurs par défaut.

[lite]: https://huggingface.co/kandinskylab/Kandinsky-S2V-1.0-Lite-Diffusers [pro]: https://huggingface.co/kandinskylab/Kandinsky-S2V-1.0-Pro-Diffusers [lite-distill]: https://huggingface.co/kandinskylab/Kandinsky-S2V-1.0-Lite-distill-Diffusers [pro-distill]: https://huggingface.co/kandinskylab/Kandinsky-S2V-1.0-Pro-distill-Diffusers

`ModularPipeline.from_pretrained` sélectionne les blocs à partir du checkpoint. Les étapes prennent par défaut les valeurs ci-dessus. Le classifier-free guidance est le composant `guider`, et non un argument d’appel : les checkpoints de base l’incluent à 3,0. Les checkpoints distillés n’ont ni guider ni `negative_prompt`, car le guidance fait déjà partie de l’étudiant.

## Utilisation

```py
import librosa
import torch
from diffusers import ModularPipeline
from diffusers.utils import encode_video, load_image

pipe = ModularPipeline.from_pretrained("kandinskylab/Kandinsky-S2V-1.0-Lite-distill-Diffusers")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")

image = load_image("reference.png")
audio, _ = librosa.load("speech.wav", sr=16000)  # a mono waveform at 16 kHz, for the model
speech, sample_rate = librosa.load("speech.wav", sr=None)  # the original track, added to the output video

video = pipe(image=image, audio=audio, output="videos")[0]
encode_video(
    video,
    fps=25,
    output_path="avatar.mp4",
    audio=torch.from_numpy(speech)[None],
    audio_sample_rate=sample_rate,
)
```

Les points de contrôle Pro ne tiennent pas sur un GPU de 80 Go à côté de l’encodeur vocal et texte 7B lorsque tous les composants sont sur l’appareil. Déchargez-les via un `ComponentsManager` :

```py
import librosa
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.utils import encode_video, load_image

manager = ComponentsManager()
pipe = ModularPipeline.from_pretrained("kandinskylab/Kandinsky-S2V-1.0-Pro-Diffusers", components_manager=manager)
pipe.load_components(dtype=torch.bfloat16)
manager.enable_auto_cpu_offload(device="cuda", memory_reserve_margin="40GiB")

image = load_image("reference.png")
audio, _ = librosa.load("speech.wav", sr=16000)
speech, sample_rate = librosa.load("speech.wav", sr=None)

video = pipe(image=image, audio=audio, output="videos")[0]
encode_video(
    video,
    fps=25,
    output_path="avatar.mp4",
    audio=torch.from_numpy(speech)[None],
    audio_sample_rate=sample_rate,
)
```

La marge est la mémoire laissée libre au-delà des poids lorsqu’un modèle est déplacé sur le GPU. Elle doit contenir le décodage VAE d’un bloc, soit environ 33 GiB à 512x768 : avec la valeur par défaut de 3 Go, le transformateur reste sur le GPU pendant le décodage, ce qui provoque ensuite un épuisement de la mémoire. Avec 40 GiB, le pic est d’environ 50 GiB sur un GPU de 80 Go. Activez le déchargement après `load_components`, afin qu’il s’applique à chaque composant.

## Notes

- `image` est une image PIL et `audio` une forme d’onde mono flottante dans [-1, 1] à 16 kHz, sous forme de tenseur ou de tableau de forme `(samples,)` ; le pipeline ne lit pas de fichiers.
- Les blocs de premier niveau (`text_encoder`, `vae_encoder`, `denoise`, `decode`) s'exécutent également de manière autonome ; transmettez les mêmes valeurs de `num_latent_frames` et `fps` à chacun lors de leur exécution séparée.
- Le nombre de segments suit la durée de la piste audio, sauf si `num_chunks` est transmis. La vidéo est de toute façon rognée à la durée de la piste, de sorte que les segments au-delà de sa fin sont calculés puis écartés, avec un avertissement.
- Avec le guidage, le passage inconditionnel insère le prompt négatif *et* atténue la parole, de sorte que le guidage est conjoint sur le texte et la parole.

## KandinskyS2VModularPipeline[[diffusers.KandinskyS2VModularPipeline]]

#### diffusers.KandinskyS2VModularPipeline[[diffusers.KandinskyS2VModularPipeline]]

```python
diffusers.KandinskyS2VModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/kandinsky_s2v/modular_pipeline.py#L91)

Un ModularPipeline pour la génération de vidéos à partir de la parole avec Kandinsky S2V 1.0.

## KandinskyS2VAutoBlocks[[diffusers.KandinskyS2VAutoBlocks]]

#### diffusers.KandinskyS2VAutoBlocks[[diffusers.KandinskyS2VAutoBlocks]]

```python
diffusers.KandinskyS2VAutoBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/kandinsky_s2v/modular_blocks_kandinsky_s2v.py#L108)

Pipeline modulaire pour la génération de vidéos à partir de la parole avec Kandinsky S2V 1.0 : une vidéo d'avatar à partir d'une image de référence et d'une piste audio, générée par morceaux.

Composants : text_encoder (`Qwen2_5OmniThinkerForConditionalGeneration`) tokenizer (`Qwen2_5OmniProcessor`) text_encoder_2 (`CLIPTextModel`) tokenizer_2 (`CLIPTokenizer`) vae (`AutoencoderKLHunyuanVideo`) video_processor (`VideoProcessor`) transformer (`KandinskyS2VTransformer3DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) guider (`ClassifierFreeGuidance`)

Entrées : prompt (`str`, *facultatif*, par défaut The video presents a stable medium close-up of a subject facing the camera directly. The subject exhibits natural, lifelike body dynamics: the head and shoulders move fluidly with the rhythm of speech. The lighting is even, maintaining a balanced natural exposure to clearly define facial features without washout. Throughout the sequence, the subject engages in continuous speech marked by precise, high-fidelity articulation. The lips move in a rhythmic, natural pattern: alternating between brief firm closures and relaxed openings. During these openings, the tips of the upper teeth are momentarily and realistically visible, exhibiting natural enamel texture. The upper lip lifts subtly over the teeth during enunciation, while the jaw performs minimal vertical oscillations synchronized with the speech cadence. Facial micro-expressions are active yet restrained; eyebrows rise and lower slightly with minute asymmetry. The eyes maintain a steady, engaged gaze forward, punctuated by smooth, deliberate blinks. ) : le prompt pour guider la génération. negative_prompt (`str`, *facultatif*) : le prompt pour le passage non conditionnel du guidage. Par défaut `DEFAULT_NEGATIVE_PROMPT` lorsque le guidage en a besoin. audio (`Tensor | ndarray`) : la piste audio qui pilote la génération : une forme d'onde mono flottante dans [-1, 1] à 16000 Hz, de forme (samples,). num_latent_frames (`int`, *facultatif*, par défaut 32) : nombre de frames latentes par chunk ; 32 donne 125 frames (5 s à 25 fps). fps (`int`, *facultatif*, par défaut 25) : taux de frames auquel la longueur du chunk est calculée. num_chunks (`int`, *facultatif*) : nombre de chunks à générer. Par défaut, autant qu'il en faut pour couvrir la piste audio ; la vidéo est de toute façon rognée à la longueur de la piste. image (`Image`) : la frame de référence à animer. height (`int`, *facultatif*) : la hauteur en pixels de la vidéo générée. Par défaut, le bucket 512 le plus proche de la frame de référence. width (`int`, *facultatif*) : la largeur en pixels de la vidéo générée, choisie conjointement avec `height`. generator (`Generator`, *facultatif*) : générateur Torch pour une génération déterministe. num_inference_steps (`int`, *facultatif*, par défaut 50) : le nombre d'étapes de débruitage. scale_factor (`tuple`, *facultatif*, par défaut (1.0, 2.0, 2.0)) : échelle RoPE par axe pour le bucket de résolution. output_type (`str`, *facultatif*, par défaut pil) : format de sortie : 'pil', 'np', 'pt'.

Sorties : vidéos (`list`) : Les vidéos générées.

## KandinskyS2VDistilledModularPipeline[[diffusers.KandinskyS2VDistilledModularPipeline]]

#### diffusers.KandinskyS2VDistilledModularPipeline[[diffusers.KandinskyS2VDistilledModularPipeline]]

```python
diffusers.KandinskyS2VDistilledModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/kandinsky_s2v/modular_pipeline.py#L109)

Un ModularPipeline pour les points de contrôle distillés de Kandinsky S2V 1.0 de pi-Flow.

Le guidage est distillé dans l’étudiant, de sorte que ses blocs ne disposent ni de guideur ni de prompt négatif, et qu’un seul passage avant est exécuté par segment.

## KandinskyS2VDistilledAutoBlocks[[diffusers.KandinskyS2VDistilledAutoBlocks]]

#### diffusers.KandinskyS2VDistilledAutoBlocks[[diffusers.KandinskyS2VDistilledAutoBlocks]]

```python
diffusers.KandinskyS2VDistilledAutoBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/kandinsky_s2v/modular_blocks_kandinsky_s2v_distilled.py#L103)

Pipeline modulaire pour la génération de vidéos à partir de la parole avec les points de contrôle distillés pi-Flow de Kandinsky S2V 1.0 : 16 segments par bloc et sans guidage, ce qui est distillé dans l'étudiant.

Composants : text_encoder (`Qwen2_5OmniThinkerForConditionalGeneration`) tokenizer (`Qwen2_5OmniProcessor`) text_encoder_2 (`CLIPTextModel`) tokenizer_2 (`CLIPTokenizer`) vae (`AutoencoderKLHunyuanVideo`) video_processor (`VideoProcessor`) transformer (`KandinskyS2VTransformer3DModel`) scheduler (`PiflowScheduler`)

Entrées : prompt (`str`, *facultatif*, par défaut The video presents a stable medium close-up of a subject facing the camera directly. The subject exhibits natural, lifelike body dynamics: the head and shoulders move fluidly with the rhythm of speech. The lighting is even, maintaining a balanced natural exposure to clearly define facial features without washout. Throughout the sequence, the subject engages in continuous speech marked by precise, high-fidelity articulation. The lips move in a rhythmic, natural pattern: alternating between brief firm closures and relaxed openings. During these openings, the tips of the upper teeth are momentarily and realistically visible, exhibiting natural enamel texture. The upper lip lifts subtly over the teeth during enunciation, while the jaw performs minimal vertical oscillations synchronized with the speech cadence. Facial micro-expressions are active yet restrained; eyebrows rise and lower slightly with minute asymmetry. The eyes maintain a steady, engaged gaze forward, punctuated by smooth, deliberate blinks. ): Le prompt pour guider la génération. audio (`Tensor | ndarray`): La piste audio qui pilote la génération : une forme d'onde mono flottante dans [-1, 1] à 16000 Hz, de forme (samples,). num_latent_frames (`int`, *facultatif*, par défaut 32): Trames latentes par bloc ; 32 donne 125 trames (5 s à 25 ips). fps (`int`, *facultatif*, par défaut 25): Taux de trames utilisé pour calculer la longueur du bloc. num_chunks (`int`, *facultatif*): Nombre de blocs à générer. Par défaut, le nombre nécessaire pour couvrir la piste audio ; la vidéo est de toute façon rognée à la longueur de la piste. image (`Image`): La trame de référence à animer. height (`int`, *facultatif*): La hauteur en pixels de la vidéo générée. Par défaut, le bucket de 512 le plus proche de la trame de référence. width (`int`, *facultatif*): La largeur en pixels de la vidéo générée, choisie conjointement avec `height`. generator (`Generator`, *facultatif*): Générateur Torch pour une génération déterministe. num_inference_steps (`int`, *facultatif*, par défaut 16): Le nombre d'étapes de débruitage. scale_factor (`tuple`, *facultatif*, par défaut (1.0, 2.0, 2.0)): Échelle RoPE par axe pour le bucket de résolution. output_type (`str`, *facultatif*, par défaut pil): Format de sortie : 'pil', 'np', 'pt'.

Sorties : vidéos (`list`) : Les vidéos générées.