# 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, (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: is the woman in . summary: [reference generation] 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).