Buckets:

hf-doc-build/doc / diffusers /main /pt /api /pipelines /pika_h3_flex.md
mishig's picture
|
download
raw
31 kB
# 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.