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

Kandinsky 6

Kandinsky 6 é uma família de modelos de geração de vídeo da Kandinsky Lab. 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.

Confira a organização Kandinsky Lab 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 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	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 etapas
kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers	Kandinsky6TI2VAPipeline	Destilado, guidance_scale=1.0, 10 etapas
kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 etapas
kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers	Kandinsky6TI2VAPipeline	Destilado, guidance_scale=1.0, 10 etapas
kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 etapas
kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 etapas
kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers	Kandinsky6SRPipeline	Super-resolução por correspondência de fluxo
kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers	Kandinsky6SRPipeline	Super-resolução destilada, 2 etapas

Texto/imagem para vídeo e áudio

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 recebe os quadros produzidos por 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.

# 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 para o conjunto geral de técnicas. Tanto o Kandinsky6TI2VAPipeline quanto o Kandinsky6SRPipeline suportam model offloading (usado acima) e, para uma pegada menor em troca de velocidade, sequential CPU offloading:

pipe.enable_sequential_cpu_offload()

O VAE de vídeo do Kandinsky6TI2VAPipeline também suporta tiled decoding para altas resoluções ou vídeos longos:

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

  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)

Fonte

Parâmetros:

transformer (Kandinsky6Transformer3DModel) : Transformer multimodal que remove o ruído dos latentes de vídeo e áudio.

vae (AutoencoderKLHunyuanVideo) : VAE de vídeo usado para codificar a imagem de referência e decodificar o vídeo gerado.

text_encoder (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) : Processador do text_encoder.

text_encoder_2 (CLIPTextModel) : codificador de texto do CLIP que fornece a incorporação de texto agrupada.

tokenizer_2 (CLIPTokenizer) : Tokenizador de text_encoder_2.

scheduler (FlowMatchEulerDiscreteScheduler ou PiflowScheduler) : Agendador usado com transformer para desruidar os latentes. Os checkpoints destilados vêm com um PiflowScheduler e devem ser executados com guidance_scale=1.0.

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

__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

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.

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

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

Fonte

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

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

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

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

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

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

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

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

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

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

Parâmetros:

transformer (Kandinsky6SRTransformer3DModel) : Transformer que refina os tiles latentes.

vae (Kandinsky6SRVAE) : K-VAE de vídeo causal usado para codificar o vídeo de entrada e decodificar as tiles refinadas.

scheduler (FlowMatchEulerDiscreteScheduler ou PiflowScheduler) : Agendador usado com transformer para desruidar as tiles. Os checkpoints destilados vêm com um PiflowScheduler.

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

__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

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(), 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 em vez de uma tupla simples.

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

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

Fonte

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

encode_video(video: Tensor)

Fonte

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

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

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: um Kandinsky6SRLatentUpscaler para cada escala espacial suportada, operando sobre latentes do K-VAE.

forward[[diffusers.Kandinsky6SRLatentUpscalerBank.forward]]

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

Fonte

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

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

Fonte

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.

Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]]

diffusers.Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]]

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

Fonte

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.