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 é o pós-treino da Pika do 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, 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, assim como o MiniMax-H3: os blocos e seu 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(). 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
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.

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 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.

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.

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 (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
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.

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]]

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

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().

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 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]]

diffusers.PikaH3FlexBlocks()

Fonte

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]]

diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor])

Fonte

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]]

from_file(media)

Fonte

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().

PikaH3FlexVideoReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference]]

diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference]]

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

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]]

from_file(media)

Fonte

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(): 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.

PikaH3FlexAudioReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference]]

diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference]]

diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference(audio: Tensor, sample_rate: int | None = None)

Fonte

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]]

from_file(media)

Fonte

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.

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.