Buckets:
| # Pika H3 Flex | |
| [Pika H3 Flex](https://huggingface.co/Pika-Labs/Pika-H3-Flex) é o pós-treino da Pika do [MiniMax-H3](./minimax_h3) para um gerador de vídeo e áudio em seis etapas. Ele mantém a sequência empacotada do MiniMax-H3, seu condicionador Qwen3-VL e seus dois VAEs, e altera duas coisas: o amostrador, um cronograma fixo de seis etapas que re-ruidifica a predição limpa a cada etapa no lugar da atualização Euler, e os pesos, um par de adaptadores LoRA de rank-128 sobre as duas partições do transformador MiniMax-H3. O vídeo e sua trilha sonora estéreo sincronizada saem das mesmas seis passadas de frente. | |
| O lançamento são os adaptadores: o adaptador FL2VA (`fl2va/adapter.safetensors`) controla a partição `transformer/` para condicionamento de texto e de quadro de extremidade, e o adaptador Ref2VA (`ref2va/adapter.safetensors`) controla o `transformer_ref/` para referências multimodais. Os componentes base são os do [MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3), inalterados, e o repositório inclui uma cópia deles para que ele seja carregado de forma independente. | |
| Pika H3 Flex é integrado apenas como blocos de [Modular Diffusers](../../modular_diffusers/overview), assim como o MiniMax-H3: os blocos e seu [PikaH3FlexModularPipeline](/docs/diffusers/main/pt/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline) constituem toda a integração, e não há uma metade `DiffusionPipeline`. | |
| ## Carregando | |
| Um pipeline é montado em duas etapas: os componentes são carregados por meio de um `modular_model_index.json` que nomeia os componentes base do MiniMax-H3 e as duas configurações de agendador, em seguida, o adaptador do workflow selecionado é carregado por cima com [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights). Os adaptadores são dumps PEFT simples dos nomes dos módulos do diffusers e são carregados na escala em que foram treinados (`alpha == rank`, 1.0). | |
| | Fluxo de trabalho | Entradas | Particionamento do Transformer | Adapter | | |
| |---|---|---|---| | |
| | `t2va` | `prompt` | `transformer/` | `fl2va/adapter.safetensors` | | |
| | `fl2va` | `prompt` e `image` e/ou `last_image` | `transformer/` | `fl2va/adapter.safetensors` | | |
| | `ref2va` | `prompt` e `references` | `transformer_ref/` | `ref2va/adapter.safetensors` | | |
| ```py | |
| import torch | |
| from diffusers import ModularPipeline | |
| pipe = ModularPipeline.from_pretrained("Pika-Labs/Pika-H3-Flex", workflow="fl2va") | |
| pipe.load_components(dtype={"vae": torch.float32, "audio_vae": torch.float32, "default": torch.bfloat16}) | |
| pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="fl2va/adapter.safetensors") | |
| ``` | |
| Ao passar o workflow, os blocos são podados para aquela tarefa, de modo que apenas a partição do transformer correspondente é obtida, o roteador do adapter direciona para a única partição presente e o pipeline aceita apenas as solicitações daquela tarefa — um pipeline `fl2va` requer uma keyframe, enquanto um `t2va` não recebe nenhuma. Um pipeline que mantém ambas as partições (carregado sem `workflow=`) precisa ser informado para onde o adapter Ref2VA deve ir: `pipe.load_lora_weights(..., weight_name="ref2va/adapter.safetensors", load_into_transformer_ref=True)`. Os dois VAEs são liberados em float32 e decodificam em float32, assim como o pacote liberado faz; todo o resto é executado em bfloat16. | |
| > [!TIP] | |
| > `pipe.doc` exibe o que o pipeline à sua frente recebe e retorna — cada entrada com seu valor padrão, os componentes que ele espera e as saídas que ele produz. | |
| ### Reutilizando um MiniMax-H3 carregado | |
| Os componentes base são os do MiniMax-H3, portanto, um pipeline do MiniMax-H3 que já está carregado contém tudo, exceto os dois agendadores e os adaptadores. Esta seção monta um pipeline Pika H3 Flex a partir desses componentes carregados e mantém ambos os pipelines prontos lado a lado: um [ComponentsManager](/docs/diffusers/main/pt/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) mantém cada componente uma única vez e o descarrega para ambos, o pipeline Pika H3 Flex adiciona apenas seus dois agendadores, e os adaptadores decidem qual dos dois modelos os transformers compartilhados executam. | |
| ```py | |
| import torch | |
| from diffusers import ComponentsManager, ModularPipeline | |
| dtype = {"vae": torch.float32, "audio_vae": torch.float32, "default": torch.bfloat16} | |
| manager = ComponentsManager() | |
| manager.enable_auto_cpu_offload(device="cuda") | |
| # The MiniMax-H3 pipeline already in use, with every workflow loaded. `collection` registers its components in the | |
| # manager under that name, so they can be fetched by it later. | |
| minimax = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager, collection="minimax-h3") | |
| minimax.load_components(dtype=dtype) | |
| # The Pika H3 Flex pipeline, in its own collection. Only its own components are loaded: the two schedulers. | |
| pika = ModularPipeline.from_pretrained("Pika-Labs/Pika-H3-Flex", components_manager=manager, collection="pika-h3-flex") | |
| pika.load_components(names=["scheduler", "audio_scheduler"]) | |
| # The rest comes from the MiniMax-H3 collection, and `update_components` puts it in the Pika H3 Flex pipeline. | |
| shared = ["text_encoder", "tokenizer", "processor", "vae", "audio_vae", "transformer", "transformer_ref"] | |
| pika.update_components(**{name: manager.get_one(name=name, collection="minimax-h3") for name in shared}) | |
| # The adapters go into the shared transformers. | |
| pika.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="fl2va/adapter.safetensors") | |
| pika.load_lora_weights( | |
| "Pika-Labs/Pika-H3-Flex", weight_name="ref2va/adapter.safetensors", load_into_transformer_ref=True | |
| ) | |
| ``` | |
| `print(manager)` exibe o resultado: cada componente compartilhado é listado uma vez e pertence a ambas as coleções, a coleção Pika H3 Flex adiciona seus dois agendadores e os dois transformers carregam um adaptador. | |
| ```text | |
| Models: | |
| Name_ID | Class | Size (GB) | Collection | |
| transformer_1397... | MiniMaxH3Transformer3DModel | 63.02 | minimax-h3 | |
| | | | pika-h3-flex | |
| transformer_ref_13... | MiniMaxH3Transformer3DModel | 63.02 | minimax-h3 | |
| | | | pika-h3-flex | |
| text_encoder_1397... | Qwen3VLForConditionalGeneration | 62.13 | minimax-h3 | |
| | | | pika-h3-flex | |
| vae_1397... | AutoencoderKLMiniMaxH3 | 9.70 | minimax-h3 | |
| | | | pika-h3-flex | |
| audio_vae_1397... | AutoencoderKLMiniMaxH3Audio | 0.56 | minimax-h3 | |
| | | | pika-h3-flex | |
| Other Components: | |
| ID | Class | Collection | |
| scheduler_1397... | MiniMaxH3Scheduler | minimax-h3 | |
| audio_scheduler_1397... | MiniMaxH3Scheduler | minimax-h3 | |
| scheduler_1397... | MiniMaxH3Scheduler | pika-h3-flex | |
| audio_scheduler_1397... | MiniMaxH3Scheduler | pika-h3-flex | |
| tokenizer_1397... | Qwen2Tokenizer | minimax-h3 | |
| | | pika-h3-flex | |
| processor_1397... | Qwen3VLProcessor | minimax-h3 | |
| | | pika-h3-flex | |
| Additional Component Info: | |
| transformer_1397...: | |
| Adapters: ['default_0'] | |
| transformer_ref_13...: | |
| Adapters: ['default_0'] | |
| ``` | |
| Os adaptadores decidem qual modelo os transformers compartilhados representam. Para voltar ao MiniMax-H3, chame `pika.disable_lora()`, e é isso: a próxima requisição `minimax(...)` executa o modelo base. `pika.enable_lora()` reativa o Pika H3 Flex. Nada é recarregado no intervalo; o gerenciador move cada componente para dentro e para fora do acelerador conforme cada pipeline o alcança. | |
| ## O que difere do MiniMax-H3 | |
| - **Seis etapas, sem `num_inference_steps`.** Ambas as instâncias de [MiniMaxH3Scheduler](/docs/diffusers/main/pt/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) (`shift=12.0` para vídeo, `shift=3.0` para áudio) executam com `stochastic_sampling` sobre a configuração `denoising_step_list` do pipeline, a agenda liberada `[1000, 750, 500, 250, 100, 40, 0]`: cada etapa prevê a amostra limpa, e todas, exceto a última, a renormalizam com ruído novo para o próximo sigma. O número de etapas é o contrato do adaptador e não é uma entrada. | |
| - **Ruído novo a cada etapa.** Uma solicitação extrai de seu `generator` em uma ordem fixa: uma extração por keyframe ou referência visual para o ruído de condicionamento, o ruído do vídeo, o ruído do áudio e, em seguida, as extrações de re-ruído do vídeo e do áudio de cada uma das cinco primeiras etapas. Passar `latents` ou `audio_latents` substitui as duas extrações iniciais e mantém as demais no lugar. | |
| - **Os keyframes são recortados, não esticados.** Um keyframe `fl2va` é recortado centralmente para a proporção do canvas na sua própria resolução e redimensionado para o canvas. | |
| - **As referências seguem o nível de resolução do canvas.** O Pika H3 Flex gera em uma tabela de buckets — um nível de 480p e um nível de 768p, cada um com onze proporções de aspecto — e uma solicitação `ref2va` é condicionada pelo nível do canvas dela: uma referência de imagem é codificada com um lado curto de 1024 pixels abaixo do nível 768 e 2048 a partir dele, e uma referência de vídeo é submetida à regra de canvas do próprio nível. Cada referência de vídeo ou de áudio independente tem duração de 2 a 15 segundos, e as durações de vídeo e as durações de áudio independente somam no máximo 15 segundos cada. | |
| ## Geração | |
| Os buckets liberados são os canvases nos quais o Pika H3 Flex foi validado. Passe um deles como `height` e `width`: | |
| | | 21:9 | 16:9 | 3:2 | 4:3 | 5:4 | 1:1 | 4:5 | 3:4 | 2:3 | 9:16 | 9:21 | | |
| |---|---|---|---|---|---|---|---|---|---|---|---| | |
| | 480p | 960x416 | 832x480 | 704x480 | 640x480 | 608x480 | 480x480 | 480x608 | 480x640 | 480x704 | 480x832 | 416x960 | | |
| | 768p | 1536x672 | 1344x768 | 1152x768 | 1024x768 | 960x768 | 768x768 | 768x960 | 768x1024 | 768x1152 | 768x1344 | 672x1536 | | |
| ```py | |
| import torch | |
| from diffusers import ComponentsManager, ModularPipeline | |
| from diffusers.utils import load_image | |
| from diffusers.utils.export_utils import encode_video | |
| # 61.7GB of transformer and 62.1GB of conditioner do not sit on one accelerator, so the components are | |
| # registered in a manager that moves each one on and off as the blocks reach it. | |
| manager = ComponentsManager() | |
| manager.enable_auto_cpu_offload(device="cuda") # or "mps", "xpu", "cpu" | |
| # Create one pipeline for all supported workflows, then load the `fl2va` workflow's components, which is | |
| # enough to run both the fl2va and t2va requests below. | |
| pipe = ModularPipeline.from_pretrained("Pika-Labs/Pika-H3-Flex", components_manager=manager) | |
| pipe.load_components( | |
| workflow="fl2va", dtype={"vae": torch.float32, "audio_vae": torch.float32, "default": torch.bfloat16} | |
| ) | |
| pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="fl2va/adapter.safetensors") | |
| prompt = ( | |
| "integrated_multimodal_description: A cinematic close shot of a red ceramic cup on a wooden table beside an " | |
| "open window. A soft breeze moves a linen curtain. The camera slowly pushes toward the cup as warm morning " | |
| "light crosses the table.\n" | |
| "overall_soundscape: Gentle wind through the window and faint birdsong outside. No speech.\n" | |
| "non_diegetic_music: None.\n" | |
| ) | |
| outputs = ["videos", "audio", "sampling_rate"] | |
| # Text to video + audio on the 480p 16:9 bucket, 5 seconds. | |
| results = pipe( | |
| prompt=prompt, | |
| height=480, | |
| width=832, | |
| num_frames=124, | |
| generator=torch.Generator("cuda").manual_seed(42), | |
| output=outputs | |
| ) | |
| # First frame (and optionally `last_image`) to video + audio. The keyframe is center-cropped onto the canvas and | |
| # held as the first frame, so the prompt describes the keyframe and what happens from it. | |
| image = load_image( | |
| "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg" | |
| ) | |
| i2va_prompt = ( | |
| "For the target video, at 0.00 seconds into the target video, <Picture 1> (from [Shot 1]) is fully referenced.\n\n" | |
| "integrated_multimodal_description: [Shot 1] Begin with the supplied image of a small toy astronaut figurine " | |
| "standing on a grey rocky moon surface, holding a white egg-shaped object. Preserve the figurine, its orange " | |
| "visor and the rocks. The astronaut slowly turns its helmet toward the camera and lifts the egg a little; fine " | |
| "dust drifts up around its boots. The camera slowly pushes in in one continuous shot. By the end the astronaut " | |
| "stands still, egg held up.\n\n" | |
| "overall_soundscape: Soft low wind and faint crunch of dust under the boots. No speech.\n\n" | |
| "non_diegetic_music: N/A\n" | |
| ) | |
| results = pipe( | |
| prompt=i2va_prompt, | |
| image=image, | |
| height=480, | |
| width=832, | |
| num_frames=124, | |
| generator=torch.Generator("cuda").manual_seed(42), | |
| output=outputs, | |
| ) | |
| encode_video( | |
| results["videos"][0], | |
| fps=24, | |
| output_path="pika_h3_flex_fl2va.mp4", | |
| audio=results["audio"][0], | |
| audio_sample_rate=results["sampling_rate"], | |
| ) | |
| ``` | |
| O workflow `ref2va` aceita uma lista ordenada de referências — até 9 imagens, 3 vídeos e 3 clipes de áudio, 12 no total — da mesma forma que o MiniMax-H3, com uma classe de referência por modalidade. É também a solicitação que exige mais memória: as referências adicionam suas próprias linhas à sequência, e em 768p o transformer sozinho ocupa uma GPU de 80 GB. O exemplo abaixo, portanto, faz o streaming dos blocos do transformer da memória do CPU um por vez, enquanto o manager move os outros componentes para dentro e para fora do dispositivo como antes. Ele executa uma solicitação de referência em 768p em uma GPU de 80 GB; sem o streaming, mantenha-se em 480p. | |
| ```py | |
| import torch | |
| from diffusers import ComponentsManager, ModularPipeline | |
| from diffusers.modular_pipelines.pika_h3_flex import ( | |
| PikaH3FlexAudioReference, | |
| PikaH3FlexImageReference, | |
| PikaH3FlexVideoReference, | |
| ) | |
| manager = ComponentsManager() | |
| manager.enable_auto_cpu_offload(device="cuda") # or "mps", "xpu", "cpu" | |
| pipe = ModularPipeline.from_pretrained( | |
| "Pika-Labs/Pika-H3-Flex", workflow="ref2va", components_manager=manager | |
| ) | |
| pipe.load_components(dtype={"vae": torch.float32, "audio_vae": torch.float32, "default": torch.bfloat16}) | |
| pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="ref2va/adapter.safetensors") | |
| # Keep the transformer in CPU memory and bring in one block at a time while it runs. | |
| pipe.transformer_ref.enable_group_offload( | |
| onload_device=torch.device("cuda"), | |
| offload_device=torch.device("cpu"), | |
| offload_type="block_level", | |
| num_blocks_per_group=1, | |
| use_stream=True, | |
| ) | |
| results = pipe( | |
| prompt="subject_definitions: <Subject 1> is the woman in <Picture 1>. summary: [reference generation] <Subject 1> waves at the camera.", | |
| references=[ | |
| PikaH3FlexImageReference.from_file("subject.png"), | |
| PikaH3FlexVideoReference.from_file("motion_ref.mp4"), # frames, their `fps` and the soundtrack | |
| PikaH3FlexAudioReference.from_file("voice.wav"), # waveform and its `sample_rate` | |
| ], | |
| height=768, | |
| width=1344, | |
| num_frames=124, | |
| generator=torch.Generator("cuda").manual_seed(42), | |
| output=["videos", "audio", "sampling_rate"], | |
| ) | |
| ``` | |
| ## PikaH3FlexModularPipeline[[diffusers.PikaH3FlexModularPipeline]] | |
| #### diffusers.PikaH3FlexModularPipeline[[diffusers.PikaH3FlexModularPipeline]] | |
| ```python | |
| diffusers.PikaH3FlexModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/modular_pipeline.py#L211) | |
| Uma ModularPipeline para geração conjunta de vídeo + áudio com Pika H3 Flex, o MiniMax-H3 pós-treinado de seis etapas: os fluxos de trabalho `t2va` (apenas texto) e `fl2va` (primeiro e/ou último keyframe) contra a partição de checkpoint `transformer/` com o adaptador `fl2va`, e o fluxo de trabalho `ref2va` (referência omni) contra `transformer_ref/` com o adaptador `ref2va`. | |
| Os componentes base são os do MiniMax-H3, e a liberação Pika H3 Flex é um par de adaptadores LoRA de rank-128 sobre as duas partições do transformer, de modo que um pipeline é montado em duas etapas: os componentes são carregados por meio de um `modular_model_index.json` que nomeia os componentes base e os dois schedulers, e o adaptador do workflow selecionado é carregado com [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights). | |
| ```py | |
| import torch | |
| from diffusers import ModularPipeline | |
| pipe = ModularPipeline.from_pretrained("Pika-Labs/Pika-H3-Flex", workflow="fl2va") | |
| pipe.load_components(dtype={"vae": torch.float32, "audio_vae": torch.float32, "default": torch.bfloat16}) | |
| pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="fl2va/adapter.safetensors") | |
| ``` | |
| Assim como o MiniMax-H3, o Pika H3 Flex remove o ruído de **uma sequência empacotada** que contém, de uma só vez, a condição de texto, os latentes de condição de quadro-chave ou de referência, os latentes de áudio e os latentes de vídeo. É por isso que os blocos passam um layout de linha em vez de tensores por modalidade, e por isso o pipeline carrega dois agendadores (`shift = 12.0` para vídeo, `shift = 3.0` para áudio) que são executados dentro de uma única chamada do transformer. Diferentemente do MiniMax-H3, os dois agendadores são instâncias de [MiniMaxH3Scheduler](/docs/diffusers/main/pt/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) com `stochastic_sampling` sobre a lista fixa de seis etapas `denoising_step_list`: não há `num_inference_steps`, e cada etapa extrai novo ruído do gerador da solicitação. | |
| Os adaptadores são destilados por orientação, assim como sua base: não há um guia, nem `negative_prompt` e nem `guidance_scale`, e cada etapa executa exatamente uma passagem de frente. | |
| Este módulo carrega os fatos do modelo em que cada bloco se baseia — a geometria derivada da configuração como propriedades, a aritmética de canvas, tier e contagem de quadros como funções — e os contratos de condicionamento, codificação e ruído estão nos próprios blocos. | |
| ## PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]] | |
| #### diffusers.PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]] | |
| ```python | |
| diffusers.PikaH3FlexBlocks() | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/modular_blocks_pika_h3_flex.py#L668) | |
| Blocos de pipeline Auto Modular para geração conjunta de vídeo + áudio com Pika H3 Flex: os fluxos de trabalho `t2va` (apenas texto), `fl2va` (primeiro e/ou último keyframe) e `ref2va` (omni-reference), selecionados pelas entradas de `references` e keyframe. Os fluxos de trabalho `t2va` e `fl2va` executam a partição `transformer` com o adaptador `fl2va` e o `ref2va` executa a partição `transformer_ref` com o adaptador `ref2va`, portanto, carregue o adaptador do fluxo de trabalho que a solicitação utiliza. Sem um `workflow=`, o carregamento dos componentes traz **ambas** as partições de transformer de 61,7GB — passe um para carregar apenas o que a tarefa precisa. | |
| Fluxos de trabalho suportados: | |
| - `t2va`: requer `prompt` | |
| - `fl2va`: requer `prompt`, `image` ou `prompt`, `last_image` | |
| - `ref2va`: requer `prompt`, `references` | |
| Componentes: image_processor (`VaeImageProcessor`) text_encoder (`Qwen3VLForConditionalGeneration`) tokenizer (`Qwen2Tokenizer`) processor (`Qwen3VLProcessor`) vae (`AutoencoderKLMiniMaxH3`) audio_vae (`AutoencoderKLMiniMaxH3Audio`) scheduler (`MiniMaxH3Scheduler`) audio_scheduler (`MiniMaxH3Scheduler`) transformer_ref (`MiniMaxH3Transformer3DModel`) transformer (`MiniMaxH3Transformer3DModel`) video_processor (`VideoProcessor`) | |
| Configs: canvas_short_edge (padrão: 768) canvas_max_pixels (padrão: 1032192) denoising_step_list (padrão: [1000, 750, 500, 250, 100, 40, 0]) | |
| Inputs: references (`list`, *opcional*): As referências para as quais condicionar, **na ordem em que o modelo deve lê-las**: a ordem as rotula na apresentação do prompt e as organiza no relógio rotativo compartilhado, de modo que uma ordem diferente é uma solicitação diferente. Uma dataclass por modalidade, todas contendo mídia em memória — um `PikaH3FlexImageReference` (no máximo 9), um `PikaH3FlexVideoReference` em seu próprio `fps` (no máximo 3, cuja trilha sonora `audio` também é condicionada) ou um `PikaH3FlexAudioReference` em sua própria `sample_rate` (no máximo 3) — para um total de no máximo 12 referências, e referências de áudio não podem ser as únicas. Cada referência de vídeo ou de áudio isolada tem de 2 a 15 segundos, e as durações de vídeo e as durações de áudio isolado somam, cada uma, no máximo 15 segundos. Esses blocos nunca abrem um arquivo de mídia: decodifique com o classmethod `from_file` de cada classe, que traz as taxas junto. height (`int`, *opcional*): Altura do vídeo gerado em pixels, um múltiplo de 32. width (`int`, *opcional*): Largura do vídeo gerado em pixels, um múltiplo de 32. num_frames (`int`, *opcional*): Número de quadros a gerar, na taxa fixa de 24 fps: de 120 a 360, ou seja, de 5 a 15 segundos, arredondado para cima para o próximo `17 * n + 5` que o VAE de vídeo pode decodificar. Para gerar um vídeo tão longo quanto uma trilha sonora de referência, passe `round(samples / sample_rate * 24)`. image (`Image`, *opcional*): Keyframe a partir do qual o vídeo começa. Ele é recortado centralmente para a proporção de aspecto do canvas e redimensionado para ele; o canvas, por padrão, é derivado de sua própria proporção de aspecto. last_image (`Image`, *opcional*): Keyframe no qual o vídeo termina. Pode ser passado isoladamente para gerar *até* um quadro. Ele é recortado centralmente para a proporção de aspecto do canvas e redimensionado para ele, como `image`. prompt (`str`): O prompt para guiar a geração, uma única string. normalized_references (`list`, *opcional*): As referências normalizadas pela etapa de configuração, em ordem empacotada. keyframes (`list`, *opcional*): Os keyframes colocados no canvas de destino, em ordem empacotada. condition_latents (`list`, *opcional*): Os latentes de condicionamento de vídeo codificados, um por referência de imagem e vídeo em ordem empacotada. Sua forma é de onde vem a geometria de cada bloco de referência. audio_condition_latents (`list`, *opcional*): As linhas de condicionamento de áudio codificadas, uma por referência com áudio em ordem empacotada. generator (`Generator`, *opcional*): O gerador da solicitação. O ruído de condicionamento é extraído dele primeiro, uma extração por condição, antes do ruído das linhas geradas. latents (`Tensor`): Ruído de vídeo pré-gerado de forma `(1, 24, num_latent_frames, latent_height, latent_width)`, usado no lugar da extração. audio_latents (`Tensor`): Ruído de áudio pré-gerado de forma `(2, 32, num_audio_latents)`. **denoiser_input_fields (`None`, *opcional*): A descrição estrutural da sequência empacotada que o transformer lê por nome: `token_tags`, `position_ids` e os três tensores de índice de linha. attention_kwargs (`dict`, *opcional*): Kwargs adicionais para processadores de atenção. keyframe_anchors (`tuple`, *opcional*, padrão ()): A qual extremidade do vídeo cada keyframe está ancorado, em ordem empacotada. output_type (`str`, *opcional*, padrão pil): Formato de saída: 'pil', 'np' ou 'pt'. | |
| Saídas: videos (`list`): O vídeo gerado. audio (`Tensor`): A trilha sonora gerada, de forma `(1, 2, num_samples)`. sampling_rate (`int`): Taxa de amostragem da trilha sonora gerada em Hz. | |
| ## PikaH3FlexImageReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference]] | |
| #### diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference]] | |
| ```python | |
| diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor]) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L83) | |
| **Parâmetros:** | |
| image (`PIL.Image.Image`, `np.ndarray` ou `torch.Tensor`) : A imagem de referência: uma imagem, um array `(height, width, 3)` ou um tensor `(3, height, width)`, `uint8` ou ponto flutuante em `[0, 1]`. Ela nunca vincula a geometria gerada — é codificada em uma de suas bordas curtas, 2048 para o checkpoint liberado, independentemente da tela que a solicitação gera. | |
| Uma referência de sujeito, estilo ou cena: no máximo 9 por solicitação. | |
| #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference.from_file]] | |
| ```python | |
| from_file(media) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L99) | |
| **Parâmetros:** | |
| media (`str` ou `os.PathLike`) : Caminho ou URL da imagem. | |
| Carregue um arquivo de imagem em um `PikaH3FlexImageReference`, por meio de [load_image()](/docs/diffusers/main/pt/api/utilities#diffusers.utils.load_image). | |
| ## PikaH3FlexVideoReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference]] | |
| #### diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference]] | |
| ```python | |
| diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference(frames: typing.Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor], fps: float | None = None, audio: typing.Optional[torch.Tensor] = None, sample_rate: int | None = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L111) | |
| **Parâmetros:** | |
| frames (`list[PIL.Image.Image]`, `np.ndarray` ou `torch.Tensor`) : Os quadros de referência: uma lista de imagens, um array `(num_frames, height, width, 3)` ou um tensor `(num_frames, 3, height, width)`, `uint8` ou ponto flutuante em `[0, 1]`. | |
| fps (`float`, *opcional*, padrão 24.0) : A taxa de quadros que `frames` carrega, que é o que posiciona os blocos de visão da referência na grade de 2 fps do conditioner. O próprio relógio do MiniMax-H3 é de 24 fps, portanto qualquer outra taxa é reamostrada para ele por meio de exclusão e duplicação de quadros inteiros — o que torna este o campo a ser definido corretamente quando os quadros vieram de um arquivo. | |
| audio (`torch.Tensor` de forma `(channels, num_samples)`, *opcional*) : A trilha sonora deste vídeo, mono ou estéreo, condicionada como a própria da referência, em vez de como uma referência para si mesma. Se omitida, a referência é condicionada apenas pelo movimento. | |
| sample_rate (`int`, *opcional*) : A taxa na qual o `audio` carrega suas amostras. Se omitido, será a taxa própria do VAE de áudio, o que deixa as amostras inalteradas; qualquer outra taxa resultará em reamostragem para ela. | |
| Uma referência de movimento e câmera: no máximo 3 por solicitação, condicionada em conjunto com sua própria trilha sonora. | |
| #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference.from_file]] | |
| ```python | |
| from_file(media) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L147) | |
| **Parâmetros:** | |
| media (`str` ou `os.PathLike`) : Caminho ou URL do vídeo. | |
| **Retorna:** `PikaH3FlexVideoReference` | |
| os quadros `(num_frames, height, width, 3)` `uint8` na taxa de quadros reportada pelo contêiner, incluindo sua trilha sonora e a própria taxa de amostragem dessa trilha quando há um fluxo de áudio. | |
| Decodifique um arquivo de vídeo em um `PikaH3FlexVideoReference`, na resolução, na taxa de quadros e na trilha sonora que ele carrega. | |
| As taxas são definidas na referência, que é o ponto de decodificar dessa forma em vez de usar [load_video()](/docs/diffusers/main/pt/api/utilities#diffusers.utils.load_video): o MiniMax-H3 reamostra uma referência para seus próprios 24 fps, portanto, uma taxa de quadros perdida na entrada é uma solicitação condicionada na velocidade errada, sem nada para alertar sobre isso. Um contêiner cujos metadados estão incorretos é corrigido sobrescrevendo `fps` ou `sample_rate` na referência retornada. | |
| Requer [PyAV](https://github.com/PyAV-Org/PyAV). | |
| ## PikaH3FlexAudioReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference]] | |
| #### diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference]] | |
| ```python | |
| diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference(audio: Tensor, sample_rate: int | None = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L174) | |
| **Parâmetros:** | |
| audio (`torch.Tensor` de forma `(channels, num_samples)`) : A forma de onda de referência, mono ou estéreo. | |
| sample_rate (`int`, *opcional*) : A taxa na qual o `audio` carrega suas amostras. Se omitido, será a taxa própria do VAE de áudio, o que deixa as amostras inalteradas; qualquer outra taxa resultará em reamostragem para ela. | |
| Uma referência de voz ou música: no máximo 3 por solicitação e nunca isolada — uma referência de áudio deve ser pareada com pelo menos uma referência de imagem ou vídeo. Ela nunca chega ao conditioner e é codificada apenas pelo VAE de áudio. | |
| #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference.from_file]] | |
| ```python | |
| from_file(media) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L193) | |
| **Parâmetros:** | |
| media (`str` ou `os.PathLike`) : Caminho ou URL do áudio, ou de um vídeo cuja trilha sonora será extraída. | |
| **Retorna:** `PikaH3FlexAudioReference` | |
| o waveform `(channels, num_samples)` float32 na taxa de amostragem informada pelo contêiner. | |
| Decodifique um arquivo de áudio em um `PikaH3FlexAudioReference`, na taxa de amostragem que ele carrega. | |
| Requer [PyAV](https://github.com/PyAV-Org/PyAV). | |
Xet Storage Details
- Size:
- 31 kB
- Xet hash:
- 9b7de6e719f9ce51f39b3e08c2503803e74878c496c8d02d05d4c00c31bf4a18
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.