Buckets:
| # Kandinsky 5.0 Video | |
| [Kandinsky 5.0](https://arxiv.org/abs/2511.14993) é uma família de modelos de difusão para geração de Vídeo & Imagem. | |
| Kandinsky 5.0 Lite linha de modelos leves de geração de vídeo (2B parâmetros) que ocupa o 1º lugar entre os modelos de código aberto em sua classe. Ele supera modelos maiores e oferece a melhor compreensão de conceitos russos no ecossistema de código aberto. | |
| Kandinsky 5.0 Pro linha de modelos de geração de vídeo de alta qualidade e grande porte (19B parâmetros). Oferece geração de alta qualidade em HD e mais formatos de geração, como I2V. | |
| O modelo introduz várias inovações principais: | |
| - **Pipeline de difusão latente** com **Flow Matching** para melhorar a estabilidade do treinamento | |
| - **Diffusion Transformer (DiT)** como o backbone generativo principal, com cross-attention para embeddings de texto | |
| - Codificação dupla de texto usando **Qwen2.5-VL** e **CLIP** para uma compreensão abrangente do texto | |
| - **HunyuanVideo 3D VAE** para codificação e decodificação eficientes de vídeo | |
| - **Mecanismos de atenção esparsa** (NABLA) para processamento eficiente de sequências longas | |
| O código-fonte original pode ser encontrado em [kandinskylab/Kandinsky-5](https://github.com/kandinskylab/Kandinsky-5). | |
| > [!TIP] | |
| > Confira a organização [Kandinsky Lab](https://huggingface.co/kandinskylab) no Hub para os checkpoints oficiais de modelos para geração de texto para vídeo, incluindo variantes pré-treinadas, SFT, no-CFG e destiladas. | |
| ## Modelos Disponíveis | |
| Kandinsky 5.0 T2V Pro: | |
| | model_id | Descrição | Casos de Uso | | |
| |------------|-------------|-----------| | |
| | **kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers** | Modelo Pro de Texto para Vídeo de 5 segundos | Geração de texto para vídeo de alta qualidade | | |
| | **kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers** | Modelo Pro de Imagem para Vídeo de 5 segundos | Geração de vídeo a partir de imagem de alta qualidade | | |
| Kandinsky 5.0 T2V Lite: | |
| | model_id | Descrição | Casos de Uso | | |
| |------------|-------------|-----------| | |
| | **kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers** | Modelo Supervised Fine-Tuned de 5 segundos | Maior qualidade de geração | | |
| | **kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers** | Modelo Supervised Fine-Tuned de 10 segundos | Maior qualidade de geração | | |
| | **kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-5s-Diffusers** | Classificador sem orientação (Classifier-Free Guidance) destilado em 5 segundos | Inferência 2× mais rápida | | |
| | **kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-10s-Diffusers** | Classificador sem orientação (Classifier-Free Guidance) destilado em 10 segundos | Inferência 2× mais rápida | | |
| | **kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers** | Diffusão de 5 segundos destilada para 16 etapas | Inferência 6× mais rápida, perda mínima de qualidade | | |
| | **kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-10s-Diffusers** | Diffusão de 10 segundos destilada para 16 etapas | Inferência 6× mais rápida, perda mínima de qualidade | | |
| | **kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-5s-Diffusers** | Modelo Base pré-treinado de 5 segundos | Pesquisa e ajuste fino | | |
| | **kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-10s-Diffusers** | Modelo Base pré-treinado de 10 segundos | Pesquisa e ajuste fino | | |
| ## Exemplos de uso | |
| ### Geração básica de texto para vídeo | |
| #### Pro | |
| **⚠️ Aviso!** todos os modelos Pro devem ser inferidos com pipeline.enable_model_cpu_offload() | |
| ```python | |
| import torch | |
| from diffusers import Kandinsky5T2VPipeline | |
| from diffusers.utils import export_to_video | |
| # Load the pipeline | |
| model_id = "kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers" | |
| pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16) | |
| pipe = pipe.to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline.transformer.set_attention_backend("flex") # <--- Set attention backend to Flex | |
| pipeline.enable_model_cpu_offload() # <--- Enable cpu offloading for single GPU inference | |
| pipeline.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=True) # <--- Compile with max-autotune-no-cudagraphs | |
| # Generate video | |
| prompt = "A cat and a dog baking a cake together in a kitchen." | |
| negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards" | |
| output = pipe( | |
| prompt=prompt, | |
| negative_prompt=negative_prompt, | |
| height=768, | |
| width=1024, | |
| num_frames=121, # ~5 seconds at 24fps | |
| num_inference_steps=50, | |
| guidance_scale=5.0, | |
| ).frames[0] | |
| export_to_video(output, "output.mp4", fps=24, quality=9) | |
| ``` | |
| #### Lite | |
| ```python | |
| import torch | |
| from diffusers import Kandinsky5T2VPipeline | |
| from diffusers.utils import export_to_video | |
| # Load the pipeline | |
| model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers" | |
| pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16) | |
| pipe = pipe.to("cuda") # or "mps", "xpu", "cpu" | |
| # Generate video | |
| prompt = "A cat and a dog baking a cake together in a kitchen." | |
| negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards" | |
| output = pipe( | |
| prompt=prompt, | |
| negative_prompt=negative_prompt, | |
| height=512, | |
| width=768, | |
| num_frames=121, # ~5 seconds at 24fps | |
| num_inference_steps=50, | |
| guidance_scale=5.0, | |
| ).frames[0] | |
| export_to_video(output, "output.mp4", fps=24, quality=9) | |
| ``` | |
| ### Modelos de 10 segundos | |
| **⚠️ Aviso!** todos os modelos de 10 segundos devem ser usados com Flex attention e compilação max-autotune-no-cudagraphs: | |
| ```python | |
| pipe = Kandinsky5T2VPipeline.from_pretrained( | |
| "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers", | |
| dtype=torch.bfloat16 | |
| ) | |
| pipe = pipe.to("cuda") # or "mps", "xpu", "cpu" | |
| pipe.transformer.set_attention_backend( | |
| "flex" | |
| ) # <--- Set attention backend to Flex | |
| pipe.transformer.compile( | |
| mode="max-autotune-no-cudagraphs", | |
| dynamic=True | |
| ) # <--- Compile with max-autotune-no-cudagraphs | |
| prompt = "A cat and a dog baking a cake together in a kitchen." | |
| negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards" | |
| output = pipe( | |
| prompt=prompt, | |
| negative_prompt=negative_prompt, | |
| height=512, | |
| width=768, | |
| num_frames=241, | |
| num_inference_steps=50, | |
| guidance_scale=5.0, | |
| ).frames[0] | |
| export_to_video(output, "output.mp4", fps=24, quality=9) | |
| ``` | |
| ### Modelo de Difusão Destilada | |
| **⚠️ Aviso!** todos os modelos nocfg e diffusion distilled devem ser inferidos sem CFG (```guidance_scale=1.0```): | |
| ```python | |
| model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers" | |
| pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16) | |
| pipe = pipe.to("cuda") # or "mps", "xpu", "cpu" | |
| output = pipe( | |
| prompt="A beautiful sunset over mountains", | |
| num_inference_steps=16, # <--- Model is distilled in 16 steps | |
| guidance_scale=1.0, # <--- no CFG | |
| ).frames[0] | |
| export_to_video(output, "output.mp4", fps=24, quality=9) | |
| ``` | |
| ### Geração básica de imagem para vídeo | |
| **⚠️ Aviso!** todos os modelos Pro devem ser inferidos com pipeline.enable_model_cpu_offload() | |
| ```python | |
| import torch | |
| from diffusers import Kandinsky5T2VPipeline | |
| from diffusers.utils import export_to_video | |
| # Load the pipeline | |
| model_id = "kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers" | |
| pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16) | |
| pipe = pipe.to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline.transformer.set_attention_backend("flex") # <--- Set attention backend to Flex | |
| pipeline.enable_model_cpu_offload() # <--- Enable cpu offloading for single GPU inference | |
| pipeline.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=True) # <--- Compile with max-autotune-no-cudagraphs | |
| # Generate video | |
| image = load_image( | |
| "https://huggingface.co/kandinsky-community/kandinsky-3/resolve/main/assets/title.jpg?download=true" | |
| ) | |
| height = 896 | |
| width = 896 | |
| image = image.resize((width, height)) | |
| prompt = "An funny furry creture smiles happily and holds a sign that says 'Kandinsky'" | |
| negative_prompt = "" | |
| output = pipe( | |
| prompt=prompt, | |
| negative_prompt=negative_prompt, | |
| height=height, | |
| width=width, | |
| num_frames=121, # ~5 seconds at 24fps | |
| num_inference_steps=50, | |
| guidance_scale=5.0, | |
| ).frames[0] | |
| export_to_video(output, "output.mp4", fps=24, quality=9) | |
| ``` | |
| ## Avaliação lado a lado do Kandinsky 5.0 Pro | |
| Comparação com Veo 3 | |
| Comparação com Veo 3 fast | |
| Comparação com o modo Texto para Vídeo do Wan 2.2 A14B | |
| Comparação com o modo de Imagem para Vídeo do Wan 2.2 A14B | |
| ## Avaliação lado a lado do Kandinsky 5.0 Lite | |
| A avaliação é baseada nos prompts expandidos do [Movie Gen benchmark](https://github.com/facebookresearch/MovieGenBench), que estão disponíveis na coluna expanded_prompt do arquivo benchmark/moviegen_bench.csv. | |
| ## Avaliação lado a lado do Kandinsky 5.0 Lite Distill | |
| ## Kandinsky5T2VPipeline[[diffusers.Kandinsky5T2VPipeline]] | |
| #### diffusers.Kandinsky5T2VPipeline[[diffusers.Kandinsky5T2VPipeline]] | |
| ```python | |
| diffusers.Kandinsky5T2VPipeline(transformer: Kandinsky5Transformer3DModel, vae: AutoencoderKLHunyuanVideo, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: FlowMatchEulerDiscreteScheduler) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L131) | |
| **Parâmetros:** | |
| transformer (`Kandinsky5Transformer3DModel`) : Transformer condicional para desruidar os latentes de vídeo codificados. | |
| vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/main/pt/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : Modelo de Autoencoder Variacional [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) para codificar e decodificar vídeos para e a partir de representações latentes. | |
| text_encoder (`Qwen2_5_VLForConditionalGeneration`) : codificador de texto congelado [Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). | |
| tokenizer (`AutoProcessor`) : Tokenizador para Qwen2.5-VL. | |
| text_encoder_2 (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) congelado, especificamente a variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). | |
| tokenizer_2 (`CLIPTokenizer`) : Tokenizador para CLIP. | |
| scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes de vídeo codificados. | |
| Pipeline para geração de texto para vídeo usando Kandinsky 5.0. | |
| 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.Kandinsky5T2VPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, num_inference_steps: int = 50, guidance_scale: float = 5.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, prompt_embeds_clip: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_clip: typing.Optional[torch.Tensor] = None, prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, negative_prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L680) | |
| **Parâmetros:** | |
| prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração do vídeo. Se não definido, passe `prompt_embeds` em vez disso. | |
| negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts a evitar durante a geração de vídeo. Se não definido, passe `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale` < `1`). | |
| height (`int`, padrão `512`) : A altura em pixels do vídeo gerado. | |
| width (`int`, padrão `768`) : A largura em pixels do vídeo gerado. | |
| num_frames (`int`, padrão `25`) : O número de quadros no vídeo gerado. | |
| num_inference_steps (`int`, padrão `50`) : O número de etapas de desruido. | |
| guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida na orientação livre de classificador. | |
| num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de vídeos a serem gerados por prompt. | |
| generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um gerador do torch para tornar a geração determinística. | |
| latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados. | |
| prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas pelo codificador de texto do Qwen. | |
| prompt_embeds_clip (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas pelo codificador de texto do CLIP. | |
| negative_prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embebimentos de texto negativos pré-gerados pelo codificador de texto do Qwen. | |
| negative_prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados pelo codificador de texto do CLIP. | |
| prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Comprimentos cumulativos das sequências para os embeddings de prompt do Qwen, usados para atenção de comprimento variável. | |
| negative_prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Comprimentos cumulativos das sequências para os embeddings do prompt negativo do Qwen, usados para atenção de comprimento variável. | |
| output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída do vídeo gerado. | |
| return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `KandinskyPipelineOutput`. | |
| callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função que é chamada no final de cada etapa de remoção de ruído. | |
| callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. | |
| max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência para a codificação de texto. | |
| **Retorna:** `~KandinskyPipelineOutput` ou `tuple` | |
| Se `return_dict` for `True`, `KandinskyPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas. | |
| A função de chamada do pipeline para geração. | |
| Exemplos: | |
| ```python | |
| >>> import torch | |
| >>> from diffusers import Kandinsky5T2VPipeline | |
| >>> from diffusers.utils import export_to_video | |
| >>> # Available models: | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-5s-Diffusers | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-5s-Diffusers | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-10s-Diffusers | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-10s-Diffusers | |
| >>> # kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-10s-Diffusers | |
| >>> model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers" | |
| >>> pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16) | |
| >>> pipe = pipe.to("cuda") | |
| >>> prompt = "A cat and a dog baking a cake together in a kitchen." | |
| >>> negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards" | |
| >>> output = pipe( | |
| ... prompt=prompt, | |
| ... negative_prompt=negative_prompt, | |
| ... height=512, | |
| ... width=768, | |
| ... num_frames=121, | |
| ... num_inference_steps=50, | |
| ... guidance_scale=5.0, | |
| ... ).frames[0] | |
| >>> export_to_video(output, "output.mp4", fps=24, quality=9) | |
| ``` | |
| #### check_inputs[[diffusers.Kandinsky5T2VPipeline.check_inputs]] | |
| ```python | |
| check_inputs(prompt, negative_prompt, height, width, prompt_embeds_qwen = None, prompt_embeds_clip = None, negative_prompt_embeds_qwen = None, negative_prompt_embeds_clip = None, prompt_cu_seqlens = None, negative_prompt_cu_seqlens = None, callback_on_step_end_tensor_inputs = None, max_sequence_length = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L511) | |
| **Parâmetros:** | |
| prompt : Prompt de entrada | |
| negative_prompt : Prompt negativo para orientação | |
| height : Altura do vídeo | |
| width : Largura do vídeo | |
| prompt_embeds_qwen : Embeddings de prompt do Qwen pré-computados | |
| prompt_embeds_clip : Embeddings de prompt CLIP pré-computados | |
| negative_prompt_embeds_qwen : Embeddings de prompt negativo pré-computados do Qwen | |
| negative_prompt_embeds_clip : Embeddings de prompt negativo pré-computados do CLIP | |
| prompt_cu_seqlens : Comprimentos cumulativos pré-computados da sequência para o prompt positivo do Qwen | |
| negative_prompt_cu_seqlens : Comprimentos cumulativos pré-computados da sequência para o prompt negativo do Qwen | |
| callback_on_step_end_tensor_inputs : Entradas de tensor de callback | |
| **Exceções:** ``ValueError`` | |
| - ``ValueError`` -- Se as entradas forem inválidas | |
| Valide os parâmetros de entrada do pipeline. | |
| #### encode_prompt[[diffusers.Kandinsky5T2VPipeline.encode_prompt]] | |
| ```python | |
| encode_prompt(prompt: str | list[str], num_videos_per_prompt: int = 1, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L418) | |
| **Parâmetros:** | |
| prompt (`str` ou `list[str]`) : Prompt a ser codificado. | |
| num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos a serem gerados por prompt. | |
| max_sequence_length (`int`, *opcional*, padrão 512) : Comprimento máximo da sequência para codificação de texto. | |
| device (`torch.device`, *opcional*) : Dispositivo Torch. | |
| dtype (`torch.dtype`, *opcional*) : dtype do Torch. | |
| **Retorna:** tuple[torch.Tensor, torch.Tensor, torch.Tensor] | |
| - Incorporações de texto Qwen de forma (batch_size * num_videos_per_prompt, sequence_length, embedding_dim) | |
| - CLIP pooled embeddings de forma (batch_size * num_videos_per_prompt, clip_embedding_dim) | |
| - Comprimentos de sequência cumulativos (`cu_seqlens`) para embeddings do Qwen, com forma (batch_size * num_videos_per_prompt + 1,) | |
| Codifica um único prompt (positivo ou negativo) em estados ocultos do codificador de texto. | |
| Este método combina embeddings dos codificadores de texto Qwen2.5-VL e CLIP para criar representações de texto abrangentes para a geração de vídeo. | |
| #### fast_sta_nabla[[diffusers.Kandinsky5T2VPipeline.fast_sta_nabla]] | |
| ```python | |
| fast_sta_nabla(T: int, H: int, W: int, wT: int = 3, wH: int = 3, wW: int = 3, device = 'cuda') | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L229) | |
| **Parâmetros:** | |
| T (int) : Número de quadros temporais | |
| H (int) : Altura no espaço latente | |
| W (int) : Largura no espaço latente | |
| wT (int) : Tamanho da janela de atenção temporal | |
| wH (int) : Tamanho da janela de atenção de altura | |
| wW (int) : Tamanho da janela de atenção | |
| device (str) : Dispositivo em que criar o tensor | |
| **Retorna:** `torch.Tensor` | |
| Máscara de atenção esparsa de forma (T*H*W, T*H*W) | |
| Crie uma máscara de atenção temporal esparsa (STA) para geração de vídeo eficiente. | |
| Este método gera uma máscara que limita a atenção a quadros e posições espaciais próximos, reduzindo a complexidade computacional para a geração de vídeo. | |
| #### get_sparse_params[[diffusers.Kandinsky5T2VPipeline.get_sparse_params]] | |
| ```python | |
| get_sparse_params(sample, device) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L264) | |
| **Parâmetros:** | |
| sample (torch.Tensor) : tensor de amostra de entrada | |
| device (torch.device) : Dispositivo para colocar os tensores | |
| **Retorna:** `Dict` | |
| Dicionário contendo parâmetros de atenção esparsa | |
| Gere os parâmetros de atenção esparsa para o transformer com base nas dimensões da amostra. | |
| Este método calcula a configuração de atenção esparsa necessária para o processamento eficiente de vídeos no modelo transformer. | |
| #### prepare_latents[[diffusers.Kandinsky5T2VPipeline.prepare_latents]] | |
| ```python | |
| prepare_latents(batch_size: int, num_channels_latents: int = 16, height: int = 480, width: int = 832, num_frames: int = 81, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L597) | |
| **Parâmetros:** | |
| batch_size (int) : Número de vídeos a serem gerados | |
| num_channels_latents (int) : Número de canais no espaço latente | |
| height (int) : Altura do vídeo gerado | |
| width (int) : Largura do vídeo gerado | |
| num_frames (int) : Número de quadros no vídeo | |
| dtype (torch.dtype) : Tipo de dados para latentes | |
| device (torch.device) : Dispositivo em que os latentes serão criados | |
| generator (torch.Generator) : Gerador de números aleatórios | |
| latents (torch.Tensor) : Latentes preexistentes para usar | |
| **Retorna:** `torch.Tensor` | |
| Tensor latente preparado | |
| Prepare variáveis latentes iniciais para a geração de vídeo. | |
| Este método cria latentes de ruído aleatório ou usa os latentes fornecidos como ponto de partida para o processo de remoção de ruído. | |
| ## Kandinsky5I2VPipeline[[diffusers.Kandinsky5I2VPipeline]] | |
| #### diffusers.Kandinsky5I2VPipeline[[diffusers.Kandinsky5I2VPipeline]] | |
| ```python | |
| diffusers.Kandinsky5I2VPipeline(transformer: Kandinsky5Transformer3DModel, vae: AutoencoderKLHunyuanVideo, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: FlowMatchEulerDiscreteScheduler) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L128) | |
| **Parâmetros:** | |
| transformer (`Kandinsky5Transformer3DModel`) : Transformer condicional para desruidar os latentes de vídeo codificados. | |
| vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/main/pt/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : Modelo de Autoencoder Variacional [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) para codificar e decodificar vídeos para e a partir de representações latentes. | |
| text_encoder (`Qwen2_5_VLForConditionalGeneration`) : codificador de texto congelado [Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). | |
| tokenizer (`AutoProcessor`) : Tokenizador para Qwen2.5-VL. | |
| text_encoder_2 (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) congelado, especificamente a variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). | |
| tokenizer_2 (`CLIPTokenizer`) : Tokenizador para CLIP. | |
| scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes de vídeo codificados. | |
| Pipeline para geração de vídeo a partir de imagem usando Kandinsky 5.0. | |
| 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.Kandinsky5I2VPipeline.__call__]] | |
| ```python | |
| __call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, num_inference_steps: int = 50, guidance_scale: float = 5.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, prompt_embeds_clip: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_clip: typing.Optional[torch.Tensor] = None, prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, negative_prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int, NoneType], diffusers.callbacks.PipelineCallback | diffusers.callbacks.MultiPipelineCallbacks]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L748) | |
| **Parâmetros:** | |
| image (`PipelineImageInput`) : A imagem de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou um `torch.Tensor`. | |
| prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração do vídeo. Se não definido, passe `prompt_embeds` em vez disso. | |
| negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts a evitar durante a geração de vídeo. Se não definido, passe `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale` < `1`). | |
| height (`int`, padrão `512`) : A altura em pixels do vídeo gerado. | |
| width (`int`, padrão `768`) : A largura em pixels do vídeo gerado. | |
| num_frames (`int`, padrão `121`) : O número de quadros no vídeo gerado. | |
| num_inference_steps (`int`, padrão `50`) : O número de etapas de desruido. | |
| guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida na orientação livre de classificador. | |
| num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de vídeos a serem gerados por prompt. | |
| generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um gerador do torch para tornar a geração determinística. | |
| latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados. | |
| prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto Qwen pré-gerados. | |
| prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pré-gerados. | |
| negative_prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto negativo do Qwen pré-gerados. | |
| negative_prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto negativos do CLIP pré-gerados. | |
| prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Comprimentos cumulativos de sequência pré-gerados para o prompt positivo do Qwen. | |
| negative_prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Comprimentos cumulativos de sequência pré-gerados para o prompt negativo do Qwen. | |
| output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída do vídeo gerado. | |
| return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `KandinskyPipelineOutput`. | |
| callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função que é chamada no final de cada etapa de remoção de ruído. | |
| callback_on_step_end_tensor_inputs (`List`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. | |
| max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência para a codificação de texto. | |
| **Retorna:** `~KandinskyPipelineOutput` ou `tuple` | |
| Se `return_dict` for `True`, `KandinskyPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com os vídeos gerados. | |
| A função de chamada do pipeline para geração de vídeo a partir de imagem. | |
| Exemplos: | |
| ```python | |
| >>> import torch | |
| >>> from diffusers import Kandinsky5I2VPipeline | |
| >>> from diffusers.utils import export_to_video, load_image | |
| >>> # Available models: | |
| >>> # kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers | |
| >>> model_id = "kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers" | |
| >>> pipe = Kandinsky5I2VPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16) | |
| >>> pipe = pipe.to("cuda") | |
| >>> image = load_image( | |
| ... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg" | |
| ... ) | |
| >>> prompt = "An astronaut floating in space with Earth in the background, cinematic shot" | |
| >>> negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards" | |
| >>> output = pipe( | |
| ... image=image, | |
| ... prompt=prompt, | |
| ... negative_prompt=negative_prompt, | |
| ... height=512, | |
| ... width=768, | |
| ... num_frames=121, | |
| ... num_inference_steps=50, | |
| ... guidance_scale=5.0, | |
| ... ).frames[0] | |
| >>> export_to_video(output, "output.mp4", fps=24, quality=9) | |
| ``` | |
| #### check_inputs[[diffusers.Kandinsky5I2VPipeline.check_inputs]] | |
| ```python | |
| check_inputs(prompt, negative_prompt, image, height, width, prompt_embeds_qwen = None, prompt_embeds_clip = None, negative_prompt_embeds_qwen = None, negative_prompt_embeds_clip = None, prompt_cu_seqlens = None, negative_prompt_cu_seqlens = None, callback_on_step_end_tensor_inputs = None, max_sequence_length = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L545) | |
| **Parâmetros:** | |
| prompt : Prompt de entrada | |
| negative_prompt : Prompt negativo para orientação | |
| image : Imagem de entrada para condicionamento | |
| height : Altura do vídeo | |
| width : Largura do vídeo | |
| prompt_embeds_qwen : Embeddings de prompt do Qwen pré-computados | |
| prompt_embeds_clip : Embeddings de prompt CLIP pré-computados | |
| negative_prompt_embeds_qwen : Embeddings de prompt negativo pré-computados do Qwen | |
| negative_prompt_embeds_clip : Embeddings de prompt negativo pré-computados do CLIP | |
| prompt_cu_seqlens : Comprimentos cumulativos pré-computados da sequência para o prompt positivo do Qwen | |
| negative_prompt_cu_seqlens : Comprimentos cumulativos pré-computados da sequência para o prompt negativo do Qwen | |
| callback_on_step_end_tensor_inputs : Entradas de tensor de callback | |
| **Exceções:** ``ValueError`` | |
| - ``ValueError`` -- Se as entradas forem inválidas | |
| Valide os parâmetros de entrada do pipeline. | |
| #### encode_prompt[[diffusers.Kandinsky5I2VPipeline.encode_prompt]] | |
| ```python | |
| encode_prompt(prompt: str | list[str], num_videos_per_prompt: int = 1, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L454) | |
| **Parâmetros:** | |
| prompt (`str` ou `list[str]`) : Prompt a ser codificado. | |
| num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos a serem gerados por prompt. | |
| max_sequence_length (`int`, *opcional*, padrão 512) : Comprimento máximo da sequência para codificação de texto. | |
| device (`torch.device`, *opcional*) : Dispositivo Torch. | |
| dtype (`torch.dtype`, *opcional*) : dtype do Torch. | |
| **Retorna:** tuple[torch.Tensor, torch.Tensor, torch.Tensor] | |
| - Incorporações de texto Qwen de forma (batch_size * num_videos_per_prompt, sequence_length, embedding_dim) | |
| - CLIP pooled embeddings de forma (batch_size * num_videos_per_prompt, clip_embedding_dim) | |
| - Comprimentos de sequência cumulativos (`cu_seqlens`) para embeddings do Qwen, com forma (batch_size * num_videos_per_prompt + 1,) | |
| Codifica um único prompt (positivo ou negativo) em estados ocultos do codificador de texto. | |
| Este método combina embeddings dos codificadores de texto Qwen2.5-VL e CLIP para criar representações de texto abrangentes para a geração de vídeo. | |
| #### fast_sta_nabla[[diffusers.Kandinsky5I2VPipeline.fast_sta_nabla]] | |
| ```python | |
| fast_sta_nabla(T: int, H: int, W: int, wT: int = 3, wH: int = 3, wW: int = 3, device = 'cuda') | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L226) | |
| **Parâmetros:** | |
| T (int) : Número de quadros temporais | |
| H (int) : Altura no espaço latente | |
| W (int) : Largura no espaço latente | |
| wT (int) : Tamanho da janela de atenção temporal | |
| wH (int) : Tamanho da janela de atenção de altura | |
| wW (int) : Tamanho da janela de atenção | |
| device (str) : Dispositivo em que criar o tensor | |
| **Retorna:** `torch.Tensor` | |
| Máscara de atenção esparsa de forma (T*H*W, T*H*W) | |
| Crie uma máscara de atenção temporal esparsa (STA) para geração de vídeo eficiente. | |
| Este método gera uma máscara que limita a atenção a quadros e posições espaciais próximos, reduzindo a complexidade computacional para a geração de vídeo. | |
| #### get_sparse_params[[diffusers.Kandinsky5I2VPipeline.get_sparse_params]] | |
| ```python | |
| get_sparse_params(sample, device) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L261) | |
| **Parâmetros:** | |
| sample (torch.Tensor) : tensor de amostra de entrada | |
| device (torch.device) : Dispositivo para colocar os tensores | |
| **Retorna:** `Dict` | |
| Dicionário contendo parâmetros de atenção esparsa | |
| Gere os parâmetros de atenção esparsa para o transformer com base nas dimensões da amostra. | |
| Este método calcula a configuração de atenção esparsa necessária para o processamento eficiente de vídeos no modelo transformer. | |
| #### prepare_latents[[diffusers.Kandinsky5I2VPipeline.prepare_latents]] | |
| ```python | |
| prepare_latents(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], batch_size: int, num_channels_latents: int = 16, height: int = 480, width: int = 832, num_frames: int = 81, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L636) | |
| **Parâmetros:** | |
| image (PipelineImageInput) : Imagem de entrada para condicionar a geração | |
| batch_size (int) : Número de vídeos a serem gerados | |
| num_channels_latents (int) : Número de canais no espaço latente | |
| height (int) : Altura do vídeo gerado | |
| width (int) : Largura do vídeo gerado | |
| num_frames (int) : Número de quadros no vídeo | |
| dtype (torch.dtype) : Tipo de dados para latentes | |
| device (torch.device) : Dispositivo em que os latentes serão criados | |
| generator (torch.Generator) : Gerador de números aleatórios | |
| latents (torch.Tensor) : Latentes preexistentes para usar | |
| **Retorna:** `torch.Tensor` | |
| Tensor latente preparado com o primeiro quadro como imagem codificada | |
| Prepare variáveis latentes iniciais para a geração de vídeo a partir de imagem. | |
| Este método cria latentes de ruído aleatório para todos os quadros, exceto o primeiro, que é substituído pela imagem de entrada codificada. | |
| ## Citação | |
| ```bibtex | |
| @misc{kandinsky2025, | |
| author = {Alexander Belykh and Alexander Varlamov and Alexey Letunovskiy and Anastasia Aliaskina and Anastasia Maltseva and Anastasiia Kargapoltseva and Andrey Shutkin and Anna Averchenkova and Anna Dmitrienko and Bulat Akhmatov and Denis Dimitrov and Denis Koposov and Denis Parkhomenko and Dmitrii and Ilya Vasiliev and Ivan Kirillov and Julia Agafonova and Kirill Chernyshev and Kormilitsyn Semen and Lev Novitskiy and Maria Kovaleva and Mikhail Mamaev and Mikhailov and Nikita Kiselev and Nikita Osterov and Nikolai Gerasimenko and Nikolai Vaulin and Olga Kim and Olga Vdovchenko and Polina Gavrilova and Polina Mikhailova and Tatiana Nikulina and Viacheslav Vasilev and Vladimir Arkhipkin and Vladimir Korviakov and Vladimir Polovnikov and Yury Kolabushin}, | |
| title = {Kandinsky 5.0: A family of diffusion models for Video & Image generation}, | |
| howpublished = {\url{https://github.com/kandinskylab/Kandinsky-5}}, | |
| year = 2025 | |
| } | |
| ``` | |
Xet Storage Details
- Size:
- 38.2 kB
- Xet hash:
- f5fba5b75b273a7bd75e91eb81d2ac1575bb572422b793c399d0a6ebf547cfbf
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.