# Kandinsky 6

Kandinsky 6 é uma família de modelos de geração de vídeo da [Kandinsky Lab](https://huggingface.co/kandinskylab). O modelo principal gera vídeo e áudio sincronizados a partir de texto ou de uma imagem de referência com um único difusor de transformador multimodal: os latentes de vídeo e áudio são desruidados juntos por meio de blocos fundidos que realizam atenção cruzada entre as duas modalidades, cada um condicionado em seu próprio ramo de texto Qwen2.5-VL e em um embedding agregado do CLIP. Um modelo separado de super-resolução amplia o vídeo gerado, tile a tile, no espaço latente de um K-VAE 3D causal.

> [!TIP]
> Confira a organização [Kandinsky Lab](https://huggingface.co/kandinskylab) no Hub para o conjunto completo de checkpoints oficiais, incluindo as variantes de flow-matching e destiladas dos modelos base e de super-resolução.
>
> Os checkpoints destilados são fornecidos com o [PiflowScheduler](/docs/diffusers/main/pt/api/schedulers/piflow#diffusers.PiflowScheduler) de poucas etapas e devem ser executados com `guidance_scale=1.0`.

## Modelos disponíveis

| Model | Pipeline | Observações |
|---|---|---|
| [`kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 etapas |
| [`kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Destilado, `guidance_scale=1.0`, 10 etapas |
| [`kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 etapas |
| [`kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Destilado, `guidance_scale=1.0`, 10 etapas |
| [`kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 etapas |
| [`kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers) | [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) | Flow matching, `guidance_scale=5.0`, 50 etapas |
| [`kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers) | [Kandinsky6SRPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) | Super-resolução por correspondência de fluxo |
| [`kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers`](https://huggingface.co/kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers) | [Kandinsky6SRPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) | Super-resolução destilada, 2 etapas |

## Texto/imagem para vídeo e áudio

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

Passe `image=` para condicionar o primeiro quadro em uma imagem de referência, `sample_audio=False` para gerar apenas vídeo e `expand_prompts=True` para permitir que o codificador de texto Qwen2.5-VL reescreva prompts curtos em prompts detalhados primeiro.

## Super-resolução de vídeo

[Kandinsky6SRPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) recebe os quadros produzidos por [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) e aumenta sua resolução por `2`, `4` ou `2.25` (um pré-aumento bilinear de 1.125x seguido pelo caminho de 2x). O vídeo é dividido em tiles sobrepostos, cada tile é refinado em um dos tamanhos de tile nos quais o transformer SR foi treinado, e os tiles são mesclados novamente com janelas 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]
```

## Otimização de memória

Consulte o guia [Redução do uso de memória](../../optimization/memory) para o conjunto geral de técnicas. Tanto o [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) quanto o [Kandinsky6SRPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) suportam [model offloading](../../optimization/memory#model-offloading) (usado acima) e, para uma pegada menor em troca de velocidade, [sequential CPU offloading](../../optimization/memory#cpu-offloading):

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

O VAE de vídeo do [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) também suporta [tiled decoding](../../optimization/memory#vae-tiling) para altas resoluções ou vídeos longos:

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

## Observações

- `height` e `width` devem ser divisíveis pela razão de compressão espacial do VAE de vídeo multiplicada pelo tamanho do patch do transformer — `16` na configuração padrão do [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) (`AutoencoderKLHunyuanVideo` com uma razão de compressão de `8`, `patch_size=(1, 2, 2)`). `480x864`, usado no exemplo acima, atende a esse requisito.
- A entrada `video` de [Kandinsky6SRPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) deve ter `1 + k * vae_scale_factor_temporal` quadros para algum inteiro `k` (uma razão de compressão temporal de `4` com a configuração padrão do K-VAE, portanto `121` quadros funciona, mas `120` não) — recorte ou acrescente quadros a um vídeo que ainda não atenda a esse requisito antes de aumentar sua resolução.
- `expand_prompts=True` reutiliza o codificador de texto Qwen2.5-VL já carregado para uma passagem extra de geração antes do desruido, o que adiciona latência, mas não pesos de modelo adicionais.
- Compile os blocos de transformer repetidos para uma inferência repetida mais 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)
```

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

**Parâmetros:**

transformer ([Kandinsky6Transformer3DModel](/docs/diffusers/main/pt/api/models/kandinsky6_transformer#diffusers.Kandinsky6Transformer3DModel)) : Transformer multimodal que remove o ruído dos latentes de vídeo e áudio.

vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/main/pt/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : VAE de vídeo usado para codificar a imagem de referência e decodificar o vídeo gerado.

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 fornece embeddings de texto em nível de token e, opcionalmente, expansão de prompt.

tokenizer ([Qwen2_5_VLProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/qwen2_5_vl#transformers.Qwen2_5_VLProcessor)) : Processador do `text_encoder`.

text_encoder_2 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : codificador de texto do CLIP que fornece a incorporação 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/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) ou [PiflowScheduler](/docs/diffusers/main/pt/api/schedulers/piflow#diffusers.PiflowScheduler)) : Agendador usado com `transformer` para desruidar os latentes. Os checkpoints destilados vêm com um [PiflowScheduler](/docs/diffusers/main/pt/api/schedulers/piflow#diffusers.PiflowScheduler) e devem ser executados com `guidance_scale=1.0`.

audio_vae ([MMAudioVAE](/docs/diffusers/main/pt/api/models/kandinsky6_vae#diffusers.MMAudioVAE), *opcional*) : VAE de áudio usado para decodificar os latentes de áudio gerados em um espectrograma mel. Necessário apenas quando `sample_audio=True`.

vocoder ([MMAudioVocoder](/docs/diffusers/main/pt/api/models/kandinsky6_vae#diffusers.MMAudioVocoder), *opcional*) : Vocoder usado para converter o espectrograma mel decodificado pelo `audio_vae` em uma forma de onda. Necessário apenas quando `sample_audio=True`.

Pipeline para geração de vídeo e áudio a partir de texto/imagem com Kandinsky 6.

Os latentes de vídeo e áudio são desruidados juntos por um único transformador multimodal, condicionado em tokens de texto do Qwen2.5-VL e em um embedding agregado do CLIP. Uma imagem de referência opcional condiciona o primeiro quadro.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um 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'])
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração. Obrigatório, a menos que `prompt_embeds` seja fornecido.

image (`PipelineImageInput`, *opcional*) : Imagem(ns) de referência que condiciona o primeiro quadro (imagem para vídeo e áudio).

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração. O padrão é o prompt negativo do Kandinsky 6.

height (`int`, padrão `512`) : Altura do vídeo gerado em pixels.

width (`int`, padrão `768`) : Largura do vídeo gerado em pixels.

num_frames (`int`, padrão `121`) : Número de frames gerados.

frame_rate (`float`, padrão `24.0`) : Taxa de quadros na qual o vídeo é gerado; define a duração do áudio sincronizado.

num_inference_steps (`int`, padrão `50`) : O número de etapas de desruido. Use `16` com os checkpoints destilados.

timesteps (`list[int]`, *opcional*) : Passos de tempo personalizados para agendadores que os suportam.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para agendadores que os suportam.

guidance_scale (`float`, padrão `5.0`) : Escala de orientação sem classificador. Deve ser `1.0` com um [PiflowScheduler](/docs/diffusers/main/pt/api/schedulers/piflow#diffusers.PiflowScheduler).

num_videos_per_prompt (`int`, padrão `1`) : O número de vídeos a serem gerados por prompt.

generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Gerador(es) usados para o ruído inicial e a codificação da imagem de referência.

latents (`torch.Tensor`, *opcional*) : Latentes de vídeo pré-gerados com forma `(batch_size, channels, num_latent_frames, latent_height, latent_width)`.

audio_latents (`torch.Tensor`, *opcional*) : Latentes de áudio pré-gerados com forma `(batch_size, channels, audio_length)`.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto do Qwen2.5-VL pré-gerados.

pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pré-gerados.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados do Qwen2.5-VL.

negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP agrupados negativos pré-gerados.

sample_audio (`bool`, padrão `True`) : Se deve gerar áudio sincronizado. Exige que o pipeline tenha um `audio_vae` e um `vocoder`.

expand_prompts (`bool`, padrão `False`) : Se reescrever os prompts com [expand_prompts()](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline.expand_prompts) antes da codificação.

max_sequence_length (`int`, padrão `1024`) : Número máximo de tokens de prompt após o template de chat.

output_type (`str`, padrão `"pil"`) : O formato de saída do vídeo gerado: `"pil"`, `"np"`, `"pt"` ou `"latent"`.

return_dict (`bool`, padrão `True`) : Se deve ou não retornar um [Kandinsky6TI2VAPipelineOutput](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipelineOutput) em vez de uma tupla simples.

callback_on_step_end (`Callable`, *opcional*) : Uma função chamada no final de cada etapa de desruidamento com `callback_on_step_end(self, step, timestep, callback_kwargs)`. Ela pode retornar um dicionário que substitui os tensores listados.

callback_on_step_end_tensor_inputs (`list[str]`, padrão `["latents"]`) : Entradas de Tensor passadas para `callback_on_step_end`; um subconjunto de `_callback_tensor_inputs`.

**Retorna:** [Kandinsky6TI2VAPipelineOutput](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipelineOutput) ou `tuple`

O vídeo e o áudio gerados; uma tupla `(frames, audio)` quando `return_dict=False`.

A função de chamada do pipeline para geração.

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

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

Codifica a(s) imagem(ns) de referência em latentes do primeiro quadro com forma `(batch_size, latent_height, latent_width, latent_channels)`, escalados pelo `scaling_factor` do VAE. Imagens PIL são redimensionadas e recortadas centralmente para `height x width`; tensores e arrays já devem ter esse tamanho. Os latentes são repetidos `num_videos_per_prompt` vezes ao longo da dimensão 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)
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`) : Prompt a ser codificado.

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt para orientar a geração. Ignorado quando `do_classifier_free_guidance` é `False`.

do_classifier_free_guidance (`bool`, padrão `True`) : Se também deve codificar o prompt negativo.

num_videos_per_prompt (`int`, padrão `1`) : Número de vídeos gerados por prompt; os embeddings são repetidos de acordo.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto do Qwen2.5-VL pré-gerados. Pula a codificação de `prompt`.

pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pré-gerados. Deve ser fornecido junto com `prompt_embeds`.

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

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados do Qwen2.5-VL.

negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP agrupados negativos pré-gerados.

negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara booleana de preenchimento para `negative_prompt_embeds`.

max_sequence_length (`int`, padrão `1024`) : Número máximo de tokens de prompt após o template de chat.

device (`torch.device`, *opcional*) : Dispositivo em que os codificadores de texto serão executados.

dtype (`torch.dtype`, *opcional*) : Dtype dos embeddings retornados.

Codifica o prompt em estados ocultos do 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)
```

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

**Parâmetros:**

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

tokenizer : O processador do Qwen2.5-VL, por exemplo, `pipe.tokenizer`.

text_encoder : O modelo Qwen2.5-VL, por exemplo, `pipe.text_encoder`.

device (`torch.device`) : Dispositivo para executar o codificador de texto.

image (`PIL.Image.Image` ou `list[PIL.Image.Image]`, *opcional*) : Imagem(ns) de referência de uma chamada de imagem para vídeo.

max_sequence_length (`int`, padrão `1024`) : Número máximo de tokens gerados por prompt.

generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Define a semente da expansão amostrada; uma lista deve corresponder ao comprimento de `prompt`, com um gerador por item. `generate` extrai do RNG global, portanto o RNG global é semeado a partir da semente deste gerador; chamadas posteriores de `randn_tensor` continuam usando `generator` diretamente.

**Retorna:** `str` ou `list[str]`

O(s) prompt(s) expandido(s).

Reescreve prompts curtos em prompts detalhados de vídeo+áudio com o codificador de texto Qwen2.5-VL, ancorando-os na imagem de referência quando uma é fornecida. Um `staticmethod` para que possa ser usado de forma independente, antes de executar o 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)
```

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

Retorna os latentes de áudio no layout `(batch_size, audio_length, channels)` do transformer. É esperado que o tensor `audio_latents` fornecido pelo usuário esteja no layout `(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)
```

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

Retorna os latentes de vídeo no layout `(batch_size, num_frames, height, width, channels)` do transformer. Espera-se que o tensor `latents` fornecido pelo usuário esteja no layout `(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)
```

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

**Parâmetros:**

transformer ([Kandinsky6SRTransformer3DModel](/docs/diffusers/main/pt/api/models/kandinsky6_transformer#diffusers.Kandinsky6SRTransformer3DModel)) : Transformer que refina os tiles latentes.

vae ([Kandinsky6SRVAE](/docs/diffusers/main/pt/api/models/kandinsky6_vae#diffusers.Kandinsky6SRVAE)) : K-VAE de vídeo causal usado para codificar o vídeo de entrada e decodificar as tiles refinadas.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) ou [PiflowScheduler](/docs/diffusers/main/pt/api/schedulers/piflow#diffusers.PiflowScheduler)) : Agendador usado com `transformer` para desruidar as tiles. Os checkpoints destilados vêm com um [PiflowScheduler](/docs/diffusers/main/pt/api/schedulers/piflow#diffusers.PiflowScheduler).

latent_upscaler ([Kandinsky6SRLatentUpscalerBank](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRLatentUpscalerBank), *opcional*) : Upscalers latentes para as escalas suportadas.

Pipeline para super-resolução de vídeo com Kandinsky 6.

O vídeo é dividido em tiles espaciais sobrepostos, cada tile é refinado pelo transformer SR em um dos tamanhos de tile nos quais o modelo foi treinado (`transformer.config.tile_sizes`), e os tiles refinados são mesclados de volta com janelas de Hann. Quando o pipeline possui um `latent_upscaler`, os tiles são cortados dos latentes do K-VAE do vídeo inteiro e ampliados no espaço latente; caso contrário, os tiles de pixels são ampliados bilinearmente e codificados.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um 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)
```

[Fonte](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` ou `torch.Tensor`) : O(s) vídeo(s) de baixa resolução, em qualquer formato aceito por [preprocess_video()](/docs/diffusers/main/pt/api/video_processor#diffusers.VideoProcessor.preprocess_video), com `1 + k * 4` quadros. Os tamanhos são arredondados para baixo até um múltiplo do fator espacial do VAE.

resolution_scale (`float`, padrão `2.25`) : Upscale espacial total: `2`, `4` ou `2.25` (um pré-upscale bilinear de 1.125x seguido pelo caminho de 2x).

num_inference_steps (`int`, padrão `4`) : O número de etapas de desruidamento por tile. Use `2` com os checkpoints destilados.

timesteps (`list[int]`, *opcional*) : Passos de tempo personalizados para agendadores que os suportam.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para agendadores que os suportam.

lq_noise_scale (`float`, padrão `0.7`) : Quantidade de ruído gaussiano misturado nos latentes de baixa resolução (preservando a variância) antes do desruído.

min_overlap (`float`, padrão `0.2`) : Sobreposição mínima entre tiles vizinhos, como fração do tamanho do tile.

tiles_batch_size (`int`, padrão `1`) : Número de tiles desruídos por chamada do transformer.

generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Gerador(es) usados para o ruído misturado nas tiles.

output_type (`str`, padrão `"pil"`) : O formato de saída do vídeo gerado: `"pil"`, `"np"` ou `"pt"`.

return_dict (`bool`, padrão `True`) : Se deve ou não retornar um [Kandinsky6SRPipelineOutput](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipelineOutput) em vez de uma tupla simples.

**Retorna:** [Kandinsky6SRPipelineOutput](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipelineOutput) ou `tuple`

O vídeo super-resolvido; uma tupla de um elemento quando `return_dict=False`.

A função de chamada para o pipeline de super-resolução.

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

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

Decodifica latentes K-VAE escalonados em um vídeo `(batch_size, channels, num_frames, height, width)` em `[-1, 1]`.

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

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

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

Codifica um vídeo `(batch_size, channels, num_frames, height, width)` em `[-1, 1]` em latentes K-VAE escalados pelo `scaling_factor` do 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)
```

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

**Parâmetros:**

in_channels (`int`, padrão `64`) : Número de canais latentes.

stage_channels (`tuple[int, int, int]`, padrão `(2048, 1024, 512)`) : Larguras dos recursos das três etapas da cascata.

num_pre_blocks (`int`, padrão `5`) : Blocos residuais antes do primeiro upsample do modelo x4.

num_mid_blocks (`int`, padrão `3`) : Blocos residuais entre as duas operações de upsample.

num_post_blocks (`int`, padrão `3`) : Blocos residuais após o último upsample.

num_x2_adapter_blocks (`int`, padrão `2`) : Blocos residuais do adaptador do modelo x2.

scales (`tuple[int, ...]`, padrão `(2, 4)`) : Escalas espaciais para as quais o banco fornece um upscaler.

scaling_factor (`float`, padrão `0.910344`) : Escala que se espera que os latentes de entrada carreguem (o `scaling_factor` do K-VAE).

Banco de upscalers latentes usado por [Kandinsky6SRPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline): um `Kandinsky6SRLatentUpscaler` para cada escala espacial suportada, operando sobre latentes do K-VAE.

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

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

[Fonte](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 do K-VAE escalados por `scaling_factor`.

scale (`int`) : Fator de ampliação espacial; um dos `scales`.

return_dict (`bool`, padrão `True`) : Se deve retornar um `~models.autoencoder_kl.DecoderOutput` em vez de uma tupla simples.

**Retorna:**

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

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

**Parâmetros:**

frames (`torch.Tensor`, `np.ndarray` ou `list[list[PIL.Image.Image]]`) : O vídeo gerado. Uma lista aninhada de comprimento `batch_size` contendo `num_frames` imagens PIL cada, ou um array NumPy ou tensor torch de forma `(batch_size, num_frames, height, width, channels)` / `(batch_size, num_frames, channels, height, width)`. Com `output_type="latent"`, os latentes do vídeo de forma `(batch_size, channels, num_latent_frames, latent_height, latent_width)`.

audio (`torch.Tensor` ou `np.ndarray`, *opcional*) : As formas de onda geradas com forma `(batch_size, num_samples)` em `[-1, 1]` na taxa de amostragem do VAE de áudio, ou `None` quando o áudio não foi amostrado. Com `output_type="latent"`, os latentes de áudio com forma `(batch_size, channels, audio_length)`.

Classe de saída para [Kandinsky6TI2VAPipeline](/docs/diffusers/main/pt/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]]])
```

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

**Parâmetros:**

frames (`torch.Tensor`, `np.ndarray` ou `list[list[PIL.Image.Image]]`) : O vídeo super-resolvido. Uma lista aninhada de comprimento `batch_size` contendo `num_frames` imagens PIL cada, ou um array NumPy ou tensor torch de forma `(batch_size, num_frames, height, width, channels)` / `(batch_size, num_frames, channels, height, width)`.

Classe de saída para [Kandinsky6SRPipeline](/docs/diffusers/main/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline).