Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /es /api /pipelines /kandinsky6.md
mishig
3 days ago
preview code
download
raw
36.4 kB
# Kandinsky 6

Kandinsky 6 es una familia de modelos de generación de vídeo de [Kandinsky Lab](https://huggingface.co/kandinskylab). El modelo principal genera vídeo y audio sincronizado a partir de texto o una imagen de referencia mediante un único transformador de difusión multimodal: los latentes de vídeo y audio se desruidan juntos a través de bloques fusionados que realizan atención cruzada entre las dos modalidades, cada una condicionada por su propia rama de texto Qwen2.5-VL y un embedding CLIP agrupado. Un modelo de superresolución separado aumenta la resolución del vídeo generado, mosaico a mosaico, en el espacio latente de un K-VAE 3D causal.

> [!TIP]
> Consulta la organización [Kandinsky Lab](https://huggingface.co/kandinskylab) en el Hub para ver el conjunto completo de puntos de control oficiales, incluidas las variantes de flow-matching y destiladas de los modelos base y de superresolución.
>
> Los puntos de control destilados se distribuyen con el [PiflowScheduler](/docs/diffusers/main/es/api/schedulers/piflow#diffusers.PiflowScheduler) de pocos pasos y deben ejecutarse con `guidance_scale=1.0`.
## Modelos disponibles
| Modelo | Pipeline | Notas |
|---|---|---|
| [`kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 pasos |
| [`kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Destilado, `guidance_scale=1.0`, 10 pasos |
| [`kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 pasos |
| [`kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Destilado, `guidance_scale=1.0`, 10 pasos |
| [`kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 pasos |
| [`kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 pasos |
| [`kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers) | [Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) | Superresolución mediante flujo de correspondencia |
| [`kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers) | [Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) | Superresolución destilada, 2 pasos |

## Texto/imagen a video y 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,
)
```

Pase `image=` para condicionar el primer fotograma en una imagen de referencia, `sample_audio=False` para generar solo video y `expand_prompts=True` para que el codificador de texto Qwen2.5-VL reescriba primero los prompts cortos en prompts detallados.

## Superresolución de video

[Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) toma los fotogramas generados por [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) y los aumenta en `2`, `4` o `2.25` (un pre-aumento bilineal de 1.125x seguido de la ruta de 2x). El video se divide en mosaques superpuestos, cada mosaque se refina en uno de los tamaños de mosaque en los que se entrenó el transformador SR y los mosaques se combinan nuevamente con ventanas 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]
```

## Optimización de memoria

Consulte la guía [Reduce memory usage](../../optimization/memory) para el conjunto general de técnicas. Tanto [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) como [Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) admiten [model offloading](../../optimization/memory#model-offloading) (utilizado anteriormente) y, para una huella más pequeña a costa de la velocidad, [sequential CPU offloading](../../optimization/memory#cpu-offloading):

```python
pipe.enable_sequential_cpu_offload()
```

El VAE de video de [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) también admite [decodificación por mosaicos](../../optimization/memory#vae-tiling) para resoluciones altas o videos largos:

```python
pipe.vae.enable_tiling()
```

## Notas

- `height` y `width` deben ser divisibles por la relación de compresión espacial del VAE de video multiplicada por el tamaño de parche del transformer: `16` con la configuración predeterminada de [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) (`AutoencoderKLHunyuanVideo` con una relación de compresión de `8` y `patch_size=(1, 2, 2)`). `480x864`, utilizado en el ejemplo anterior, cumple esta condición.
- La entrada `video` de [Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) debe tener `1 + k * vae_scale_factor_temporal` fotogramas para algún entero `k` (una relación de compresión temporal de `4` con la configuración predeterminada de K-VAE, por lo que `121` fotogramas funciona pero `120` no) — recorta o rellena un video que no cumpla ya esta condición antes de aumentar su resolución.
- `expand_prompts=True` reutiliza el codificador de texto de Qwen2.5-VL ya cargado para una pasada de generación adicional antes del desruido, por lo que añade latencia pero no pesos de modelo adicionales.
- Compile los bloques de transformador repetidos para una inferencia repetida más rápida:
  ```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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L178)

**Parámetros:**

transformer ([Kandinsky6Transformer3DModel](/docs/diffusers/main/es/api/models/kandinsky6_transformer#diffusers.Kandinsky6Transformer3DModel)) : Transformer multimodal que desruidifica los latentes de video y audio.

vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/main/es/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : VAE de video utilizado para codificar la imagen de referencia y decodificar el video generado.

text_encoder ([Qwen2_5_VLForConditionalGeneration](https://huggingface.co/docs/transformers/main/en/model_doc/qwen2_5_vl#transformers.Qwen2_5_VLForConditionalGeneration)) : modelo Qwen2.5-VL que proporciona las incrustaciones de texto a nivel de token y, opcionalmente, la expansión del prompt.
tokenizer ([Qwen2_5_VLProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/qwen2_5_vl#transformers.Qwen2_5_VLProcessor)) : Procesador de `text_encoder`.

text_encoder_2 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)): codificador de texto de CLIP que proporciona la incrustación de texto agrupada.

tokenizer_2 ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Tokenizador de `text_encoder_2`.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) o [PiflowScheduler](/docs/diffusers/main/es/api/schedulers/piflow#diffusers.PiflowScheduler)): programador utilizado con `transformer` para desruidar los latentes. Los puntos de control destilados incluyen un [PiflowScheduler](/docs/diffusers/main/es/api/schedulers/piflow#diffusers.PiflowScheduler) y deben ejecutarse con `guidance_scale=1.0`.

audio_vae ([MMAudioVAE](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVAE), *opcional*) : VAE de audio utilizado para decodificar los latentes de audio generados en un espectrograma mel. Solo es necesario cuando `sample_audio=True`.

vocoder ([MMAudioVocoder](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVocoder), *opcional*) : Vocoder utilizado para convertir el espectrograma mel que decodifica `audio_vae` en una forma de onda. Solo es necesario cuando `sample_audio=True`.

Pipeline para la generación de video y audio a partir de texto/imagen con Kandinsky 6.

Los latentes de video y audio se desruidan juntos mediante un único transformer multimodal, condicionado por tokens de texto de Qwen2.5-VL y un embedding agrupado de CLIP. Una imagen de referencia opcional condiciona el primer fotograma.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

#### __call__[[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'])
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L644)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación. Obligatorio a menos que se proporcione `prompt_embeds`.

image (`PipelineImageInput`, *opcional*) : Imagen(es) de referencia que condicionan el primer fotograma (de imagen a vídeo y audio).

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación. Por defecto, se utiliza el prompt negativo de Kandinsky 6.
height (`int`, por defecto `512`) : Altura del video generado en píxeles.
width (`int`, por defecto `768`) : Ancho del video generado en píxeles.
num_frames (`int`, por defecto `121`) : Número de fotogramas generados.

frame_rate (`float`, por defecto `24.0`) : Tasa de fotogramas a la que se genera el vídeo; define la duración del audio sincronizado.
num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Usa `16` con los puntos de control destilados.
timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para programadores que los admiten.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para programadores que los admiten.
guidance_scale (`float`, por defecto `5.0`) : Escala de guía libre de clasificador. Debe ser `1.0` con un [PiflowScheduler](/docs/diffusers/main/es/api/schedulers/piflow#diffusers.PiflowScheduler).

num_videos_per_prompt (`int`, por defecto `1`) : El número de vídeos a generar por prompt.
generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Generador(es) utilizados para el ruido inicial y la codificación de la imagen de referencia.
latents (`torch.Tensor`, *opcional*) : Latentes de video pregenerados de forma `(batch_size, channels, num_latent_frames, latent_height, latent_width)`.

audio_latents (`torch.Tensor`, *opcional*) : Latentes de audio pregenerados de forma `(batch_size, channels, audio_length)`.
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto de Qwen2.5-VL pregenerados.

pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pregenerados.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados de Qwen2.5-VL.

negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP agrupados negativos pregenerados.
sample_audio (`bool`, por defecto `True`) : Si se debe generar audio sincronizado. Requiere que el pipeline tenga un `audio_vae` y un `vocoder`.

expand_prompts (`bool`, por defecto `False`) : Si se reescriben los prompts con [expand_prompts()](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline.expand_prompts) antes de codificarlos.
max_sequence_length (`int`, por defecto `1024`) : Número máximo de tokens de prompt después de la plantilla de chat.
output_type (`str`, por defecto `"pil"`) : El formato de salida del video generado: `"pil"`, `"np"`, `"pt"` o `"latent"`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver una [Kandinsky6TI2VAPipelineOutput](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipelineOutput) en lugar de una tupla simple.
callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido con `callback_on_step_end(self, step, timestep, callback_kwargs)`. Puede devolver un diccionario que sobrescriba los tensores enumerados.

callback_on_step_end_tensor_inputs (`list[str]`, por defecto `["latents"]`) : Entradas de tensor pasadas a `callback_on_step_end`; un subconjunto de `_callback_tensor_inputs`.
**Devuelve:** [Kandinsky6TI2VAPipelineOutput](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipelineOutput) o `tuple`
El video y el audio generados; una tupla `(frames, audio)` cuando `return_dict=False`.

La función de llamada para el pipeline de generación.

Ejemplos:
```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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L551)

Codifica la(s) imagen(es) de referencia en latentes del primer fotograma de forma `(batch_size, latent_height, latent_width, latent_channels)`, escalados por el `scaling_factor` del VAE. Las imágenes PIL se redimensionan y recortan por el centro a `height x width`; los tensores y arreglos deben tener ya ese tamaño. Los latentes se repiten `num_videos_per_prompt` veces a lo largo de la dimensión de lote.

#### 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L309)

**Parámetros:**

prompt (`str` o `list[str]`) : Prompt que se codificará.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt que no debe guiar la generación. Se ignora cuando `do_classifier_free_guidance` es `False`.

do_classifier_free_guidance (`bool`, por defecto `True`) : Si se debe codificar también el prompt negativo.
num_videos_per_prompt (`int`, por defecto `1`) : Número de vídeos generados por prompt; los embeddings se repiten en consecuencia.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto de Qwen2.5-VL pregenerados. Omite la codificación de `prompt`.
pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pregenerados. Debe proporcionarse junto con `prompt_embeds`.

prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara booleana de relleno para `prompt_embeds`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados de Qwen2.5-VL.

negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP agrupados negativos pregenerados.
negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara booleana de relleno para `negative_prompt_embeds`.

max_sequence_length (`int`, por defecto `1024`) : Número máximo de tokens de prompt después de la plantilla de chat.

device (`torch.device`, *opcional*) : Dispositivo en el que se ejecutarán los codificadores de texto.

dtype (`torch.dtype`, *opcional*) : Dtype de las incrustaciones devueltas.

Codifica el prompt en estados ocultos del codificador de texto.

#### 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L412)

**Parámetros:**

prompt (`str` o `list[str]`) : Prompt o prompts para expandir.

tokenizer : El procesador de Qwen2.5-VL, por ejemplo, `pipe.tokenizer`.

text_encoder : El modelo Qwen2.5-VL, por ejemplo, `pipe.text_encoder`.

device (`torch.device`) : Dispositivo en el que se ejecuta el codificador de texto.

image (`PIL.Image.Image` o `list[PIL.Image.Image]`, *opcional*) : Imagen(es) de referencia de una llamada de imagen a video.

max_sequence_length (`int`, por defecto `1024`) : Número máximo de tokens generados por prompt.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Siembra la expansión muestreada; una lista debe coincidir con la longitud de `prompt`, un generador por elemento. `generate` extrae del RNG global, por lo que el RNG global se siembra con la semilla de este generador; las llamadas posteriores a `randn_tensor` siguen usando `generator` directamente.

**Devuelve:** `str` o `list[str]`

El (los) prompt(s) expandido(s).

Reescribe prompts cortos en prompts detallados de video y audio con el codificador de texto Qwen2.5-VL, anclándolos en la imagen de referencia cuando se proporciona una. Es un `staticmethod` para que pueda usarse de forma independiente, antes de ejecutar el 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L607)

Devuelve los latentes de audio en el formato `(batch_size, audio_length, channels)` del transformer. Se espera que el tensor `audio_latents` proporcionado por el usuario esté en el formato `(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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_ti2va.py#L578)

Devuelve los latentes de video en el formato `(batch_size, num_frames, height, width, channels)` del transformer. Se espera que el tensor `latents` proporcionado por el usuario esté en el formato `(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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L143)

**Parámetros:**

transformer ([Kandinsky6SRTransformer3DModel](/docs/diffusers/main/es/api/models/kandinsky6_transformer#diffusers.Kandinsky6SRTransformer3DModel)) : Transformer que refina los mosaicos latentes.

vae ([Kandinsky6SRVAE](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.Kandinsky6SRVAE)) : K-VAE de video causal utilizado para codificar el video de entrada y decodificar los mosaicos refinados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) o [PiflowScheduler](/docs/diffusers/main/es/api/schedulers/piflow#diffusers.PiflowScheduler)): programador utilizado con `transformer` para desruidar los mosaicos. Los puntos de control destilados incluyen un [PiflowScheduler](/docs/diffusers/main/es/api/schedulers/piflow#diffusers.PiflowScheduler).

latent_upscaler ([Kandinsky6SRLatentUpscalerBank](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRLatentUpscalerBank), *opcional*) : Upscalers latentes para las escalas admitidas.
Pipeline para super-resolución de video con Kandinsky 6.
El video se divide en mosaicos espaciales superpuestos, cada mosaico se refina mediante el transformador SR en uno de los tamaños de mosaico en los que se entrenó el modelo (`transformer.config.tile_sizes`), y los mosaicos refinados se combinan nuevamente con ventanas de Hann. Cuando el pipeline tiene un `latent_upscaler`, los mosaicos se recortan de los latentes K-VAE del video completo y se escalan en el espacio latente; de lo contrario, los mosaicos de píxeles se escalan de forma bilineal y se codifican.
Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).
#### __call__[[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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L228)
**Parámetros:**
video (`list[PIL.Image.Image]`, `np.ndarray` o `torch.Tensor`) : El/los video(s) de baja resolución, en cualquier formato que acepte [preprocess_video()](/docs/diffusers/main/es/api/video_processor#diffusers.VideoProcessor.preprocess_video), con `1 + k * 4` fotogramas. Los tamaños se redondean hacia abajo a un múltiplo del factor espacial del VAE.
resolution_scale (`float`, por defecto `2.25`) : Ampliación espacial total: `2`, `4` o `2.25` (una preampliación bilineal de 1.125x seguida de la ruta de 2x).

num_inference_steps (`int`, por defecto `4`) : El número de pasos de desruido por mosaico. Usa `2` con los puntos de control destilados.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para programadores que los admiten.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para programadores que los admiten.

lq_noise_scale (`float`, por defecto `0.7`) : Cantidad de ruido gaussiano mezclado en los latentes de baja resolución (que preserva la varianza) antes del desruido.

min_overlap (`float`, por defecto `0.2`) : Solapamiento mínimo entre los mosaicos vecinos, expresado como una fracción del tamaño del mosaico.
tiles_batch_size (`int`, por defecto `1`) : Número de mosaicos desruidados por llamada al transformer.
generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Generador(es) utilizados para el ruido mezclado en los mosaicos.
output_type (`str`, por defecto `"pil"`) : El formato de salida del video generado: `"pil"`, `"np"` o `"pt"`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver una [Kandinsky6SRPipelineOutput](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipelineOutput) en lugar de una tupla simple.
**Devuelve:** [Kandinsky6SRPipelineOutput](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipelineOutput) o `tuple`
El video superresuelto; una tupla de un elemento cuando `return_dict=False`.

La función de llamada para la pipeline de super-resolución.

Ejemplos:
```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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L223)

Decodifica los latentes K-VAE escalados en un video de `(batch_size, channels, num_frames, height, width)` en `[-1, 1]`.

#### encode_video[[diffusers.Kandinsky6SRPipeline.encode_video]]

```python
encode_video(video: Tensor)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_kandinsky6_sr.py#L213)

Codifica un video de `(batch_size, channels, num_frames, height, width)` en `[-1, 1]` en latentes K-VAE escalados por el `scaling_factor` del 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/latent_upscaler/latent_upscaler_kandinsky6_sr.py#L251)

**Parámetros:**

in_channels (`int`, por defecto `64`) : Número de canales latentes.
stage_channels (`tuple[int, int, int]`, por defecto `(2048, 1024, 512)`) : Anchos de las características de las tres etapas de la cascada.

num_pre_blocks (`int`, por defecto `5`) : Bloques residuales antes del primer upsample del modelo x4.

num_mid_blocks (`int`, por defecto `3`) : Bloques residuales entre las dos operaciones de aumento de escala.

num_post_blocks (`int`, por defecto `3`) : Bloques residuales después del último upsample.

num_x2_adapter_blocks (`int`, por defecto `2`) : Bloques residuales del adaptador del modelo x2.
scales (`tuple[int, ...]`, por defecto `(2, 4)`) : Escalas espaciales para las que el banco proporciona un amplificador.
scaling_factor (`float`, por defecto `0.910344`) : Escala que se espera que tengan los latentes de entrada (el `scaling_factor` del K-VAE).

Banco de escaladores latentes utilizado por [Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline): un `Kandinsky6SRLatentUpscaler` por cada escala espacial admitida, que opera sobre latentes de K-VAE.

#### forward[[diffusers.Kandinsky6SRLatentUpscalerBank.forward]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/latent_upscaler/latent_upscaler_kandinsky6_sr.py#L305)

**Parámetros:**

latents (`torch.Tensor` de forma `(batch_size, in_channels, num_frames, height, width)`) : latentes de K-VAE escalados por `scaling_factor`.

scale (`int`) : Factor de ampliación espacial; uno de `scales`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un `~models.autoencoder_kl.DecoderOutput` en lugar de una tupla simple.

**Devuelve:**

Los latentes ampliados de forma `(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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_output.py#L25)

**Parámetros:**

frames (`torch.Tensor`, `np.ndarray` o `list[list[PIL.Image.Image]]`) : El video generado. Una lista anidada de longitud `batch_size` que contiene `num_frames` imágenes PIL cada una, o un array de NumPy o un tensor de torch de forma `(batch_size, num_frames, height, width, channels)` / `(batch_size, num_frames, channels, height, width)`. Con `output_type="latent"`, los latentes del video de forma `(batch_size, channels, num_latent_frames, latent_height, latent_width)`.

audio (`torch.Tensor` o `np.ndarray`, *opcional*) : Las formas de onda generadas de forma `(batch_size, num_samples)` en `[-1, 1]` a la tasa de muestreo del VAE de audio, o `None` cuando no se muestreó el audio. Con `output_type="latent"`, los latentes de audio de forma `(batch_size, channels, audio_length)`.

Clase de salida para [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/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]]])
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky6/pipeline_output.py#L46)

**Parámetros:**

frames (`torch.Tensor`, `np.ndarray` o `list[list[PIL.Image.Image]]`) : El video superresuelto. Una lista anidada de longitud `batch_size` que contiene `num_frames` imágenes PIL cada una, o un array de NumPy o un tensor de torch de forma `(batch_size, num_frames, height, width, channels)` / `(batch_size, num_frames, channels, height, width)`.

Clase de salida para [Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline).
Xet Storage Details

Size:: 36.4 kB
Xet hash:: 773bc67446a40dc0f9308871286bd63cdf463eb1582382760f7ca791185300b8
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.