Hugging Face's logo

Diffusers documentation

Kandinsky 6

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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 transformer de difusão 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 aumenta a escala do 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

ModelPipelineObservações
kandinskylab/Kandinsky-6.0-Pro-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 etapas
kandinskylab/Kandinsky-6.0-Pro-distill-5s-DiffusersKandinsky6TI2VAPipelineDestilado, guidance_scale=1.0, 10 etapas
kandinskylab/Kandinsky-6.0-Lite-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 etapas
kandinskylab/Kandinsky-6.0-Lite-distill-5s-DiffusersKandinsky6TI2VAPipelineDestilado, guidance_scale=1.0, 10 etapas
kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 etapas
kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-DiffusersKandinsky6TI2VAPipelineFlow matching, guidance_scale=5.0, 50 etapas
kandinskylab/Kandinsky-6.0-VSR-5s-DiffusersKandinsky6SRPipelineSuper-resolução por correspondência de fluxo
kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-DiffusersKandinsky6SRPipelineSuper-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 do 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 desruidamento, o que adiciona latência, mas não pesos de modelo extras.
  • Compile os blocos de transformer repetidos para uma inferência repetida mais rápida: 
    pipe.transformer.compile_repeated_blocks(fullgraph=True)

Kandinsky6TI2VAPipeline

classe diffusers.Kandinsky6TI2VAPipeline

< >

( transformer: Kandinsky6Transformer3DModelvae: AutoencoderKLHunyuanVideotext_encoder: Qwen2_5_VLForConditionalGenerationtokenizer: Qwen2_5_VLProcessortext_encoder_2: CLIPTextModeltokenizer_2: CLIPTokenizerscheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowScheduleraudio_vae: diffusers.models.autoencoders.autoencoder_mmaudio.MMAudioVAE | None = Nonevocoder: diffusers.models.autoencoders.mmaudio_vocoder.MMAudioVocoder | None = None )

Parâmetros

  • transformer (Kandinsky6Transformer3DModel) — Transformador 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 de text_encoder.
  • text_encoder_2 (CLIPTextModel) — Codificador de texto do CLIP que fornece a incorporação de texto agrupada.
  • tokenizer_2 (CLIPTokenizer) — Tokenizer de text_encoder_2.
  • scheduler (FlowMatchEulerDiscreteScheduler ou PiflowScheduler) — Scheduler usado com transformer para desruidar os latentes. 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__

< >

( prompt: str | list[str] | None = Noneimage: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonenegative_prompt: str | list[str] | None = Noneheight: int = 512width: int = 768num_frames: int = 121frame_rate: float = 24.0num_inference_steps: int = 50timesteps: list[int] | None = Nonesigmas: list[float] | None = Noneguidance_scale: float = 5.0num_videos_per_prompt: int = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneaudio_latents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonepooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonesample_audio: bool = Trueexpand_prompts: bool = Falsemax_sequence_length: int = 1024output_type: str = 'pil'return_dict: bool = Truecallback_on_step_end: collections.abc.Callable[[int, int, dict], None] | None = Nonecallback_on_step_end_tensor_inputs: list[str] = ['latents'] ) → Kandinsky6TI2VAPipelineOutput or tuple

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 remoção de ruído. Use 16 com os checkpoints destilados.
  • timesteps (list[int], opcional) — Timesteps 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) — Incorporações de texto pré-geradas do Qwen2.5-VL.
  • 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 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 modelo 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 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

< >

( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]height: intwidth: intdevice: devicedtype: dtypenum_videos_per_prompt: int = 1generator: typing.Optional[torch.Generator] = None )

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

< >

( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonepooled_prompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 1024device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )

Parâmetros

  • prompt (str ou list[str]) — Prompt a ser codificado.
  • negative_prompt (str ou list[str], opcional) — O prompt que não deve orientar a geração. Ignorado quando do_classifier_free_guidance é False.
  • do_classifier_free_guidance (bool, padrão True) — Se o prompt negativo também deve ser codificado.
  • 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) — Incorporações de texto pré-geradas do Qwen2.5-VL. 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 (padding) de 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 negativos pré-gerados.
  • negative_prompt_attention_mask (torch.Tensor, opcional) — Máscara booleana de preenchimento de negative_prompt_embeds.
  • max_sequence_length (int, padrão 1024) — Número máximo de tokens de prompt após o modelo 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

< >

( prompt: str | list[str]tokenizertext_encoderdevice: deviceimage: PIL.Image.Image | list[PIL.Image.Image] | None = Nonemax_sequence_length: int = 1024generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None ) → str or list[str]

Parâmetros

  • prompt (str ou list[str]) — Prompt ou prompts a serem expandidos.
  • 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 em que o codificador de texto será executado.
  • 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, de modo que 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

< >

( batch_size: intnum_channels_latents: intaudio_length: intdtype: dtypedevice: devicegenerator: typing.Union[torch.Generator, list[torch.Generator], NoneType]audio_latents: typing.Optional[torch.Tensor] = None )

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

< >

( batch_size: intnum_channels_latents: intheight: intwidth: intnum_frames: intdtype: dtypedevice: devicegenerator: typing.Union[torch.Generator, list[torch.Generator], NoneType]latents: typing.Optional[torch.Tensor] = None )

Retorna os latentes de vídeo no layout (batch_size, num_frames, height, width, channels) do transformer. Um tensor latents fornecido pelo usuário é esperado no layout (batch_size, channels, num_frames, height, width).

Kandinsky6SRPipeline

classe diffusers.Kandinsky6SRPipeline

< >

( transformer: Kandinsky6SRTransformer3DModelvae: Kandinsky6SRVAEscheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowSchedulerlatent_upscaler: diffusers.models.latent_upscaler.latent_upscaler_kandinsky6_sr.Kandinsky6SRLatentUpscalerBank | None = None )

Parâmetros

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__

< >

( video: typing.Union[list[PIL.Image.Image], list[list[PIL.Image.Image]], numpy.ndarray, torch.Tensor]resolution_scale: float = 2.25num_inference_steps: int = 4timesteps: list[int] | None = Nonesigmas: list[float] | None = Nonelq_noise_scale: float = 0.7min_overlap: float = 0.2tiles_batch_size: int = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Noneoutput_type: str = 'pil'return_dict: bool = True ) → Kandinsky6SRPipelineOutput or tuple

Parâmetros

  • video (list[PIL.Image.Image], np.ndarray or 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) — Ampliação espacial total: 2, 4 ou 2.25 (uma pré-ampliação bilinear de 1.125x seguida pelo caminho de 2x).
  • num_inference_steps (int, padrão 4) — O número de etapas de desruido por tile. Use 2 com os checkpoints destilados.
  • timesteps (list[int], opcional) — Timesteps 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 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

< >

( latents: Tensor )

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

encode_video

< >

( video: Tensor )

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

classe diffusers.Kandinsky6SRLatentUpscalerBank

< >

( in_channels: int = 64stage_channels: tuple[int, int, int] = (2048, 1024, 512)num_pre_blocks: int = 5num_mid_blocks: int = 3num_post_blocks: int = 3num_x2_adapter_blocks: int = 2scales: tuple[int, ...] = (2, 4)scaling_factor: float = 0.910344004631042 )

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)) — Escala espacial para a qual 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 por escala espacial suportada, operando sobre latentes K-VAE.

forward

< >

( latents: Tensorscale: intreturn_dict: bool = True )

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.

Kandinsky6TI2VAPipelineOutput

classe diffusers.Kandinsky6TI2VAPipelineOutput

< >

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

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

classe diffusers.Kandinsky6SRPipelineOutput

< >

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

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.

Update on GitHub

←Kandinsky 5.0 Video Kandinsky S2V 1.0→