# Pika H3 Flex

  
    
  

[Pika H3 Flex](https://huggingface.co/Pika-Labs/Pika-H3-Flex) は、[MiniMax-H3](./minimax_h3) をポストトレーニングして 6 ステップの動画・音声生成器に仕上げたものです。MiniMax-H3 のパックシーケンス、Qwen3-VL によるコンディショナー、および 2 つの VAE はそのまま維持しつつ、2 つの変更を加えています。1 つ目はサンプラーで、Euler 更新の代わりに、各ステップでクリーンな予測をその場で再ノイズ化する固定の 6 ステップスケジュールを採用しています。2 つ目は重みで、MiniMax-H3 の 2 つのトランスフォーマー分割に対して、それぞれ rank-128 の LoRA アダプターをペアで適用しています。動画と、それに同期したステレオサウンドトラックは、同じ 6 回のフォワードパスから出力されます。

リリースされるのはアダプターです。`fl2va/adapter.safetensors` の FL2VA アダプターは、テキストおよびエンドポイントフレームの条件付けのために `transformer/` パーティションを駆動し、`ref2va/adapter.safetensors` の Ref2VA アダプターは、マルチモーダルな参照のために `transformer_ref/` を駆動します。ベースコンポーネントは [MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) のものであり、変更されていません。リポジトリにはそれらのコピーが含まれており、単体で読み込むことができます。

Pika H3 Flex は、MiniMax-H3 と同様に、[Modular Diffusers](../../modular_diffusers/overview) ブロックのみとして統合されています。つまり、ブロック群とその [PikaH3FlexModularPipeline](/docs/diffusers/v0.43.0/ja/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline) が統合の全体を構成しており、`DiffusionPipeline` 側の半分は存在しません。

## 読み込み中

パイプラインは2つのステップで組み立てられます。まず、`modular_model_index.json` を通じて、MiniMax-H3 のベースコンポーネントと2つのスケジューラ設定を読み込みます。次に、選択したワークフローのアダプタを [load_lora_weights()](/docs/diffusers/v0.43.0/ja/api/loaders/lora#diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights) で上に読み込みます。これらのアダプタは、diffusers のモジュール名をそのまま使った通常の PEFT ダンプであり、学習時のスケール（`alpha == rank`、1.0）で読み込まれます。

| ワークフロー | 入力 | Transformerのパーティション | アダプター |
|---|---|---|---|
| `t2va` | `prompt` | `transformer/` | `fl2va/adapter.safetensors` |
| `fl2va` | `prompt` および `image` と/または `last_image` | `transformer/` | `fl2va/adapter.safetensors` |
| `ref2va` | `prompt` と `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")
```

workflow を渡すとブロックがそのタスク用に剪定されるため、該当する transformer パーティションのみが取得され、アダプターは存在する 1 つのパーティションにルーティングされ、パイプラインはそのタスクのリクエストのみを受け付けます。`fl2va` パイプラインにはキーフレームが必要ですが、`t2va` パイプラインには不要です。両方のパーティションを保持するパイプライン（`workflow=` なしで読み込まれたもの）では、Ref2VA アダプターをどこに配置するかを指定する必要があります：`pipe.load_lora_weights(..., weight_name="ref2va/adapter.safetensors", load_into_transformer_ref=True)`。2 つの VAE は float32 でリリースされ、float32 でデコードされます（リリースされたパッケージと同様）。それ以外はすべて bfloat16 で実行されます。

> [!TIP]
> `pipe.doc` は、対象の pipeline が受け取る入力と返す出力を表示します。各入力のデフォルト値、期待されるコンポーネント、および生成される出力がすべて含まれます。

### 読み込んだMiniMax-H3の再利用

ベースとなるコンポーネントは MiniMax-H3 のものなので、すでに読み込まれた MiniMax-H3 パイプラインには、2 つのスケジューラとアダプタを除くすべてのコンポーネントが含まれています。このセクションでは、読み込まれたこれらのコンポーネントから Pika H3 Flex パイプラインを組み立て、両方のパイプラインを並行して利用可能な状態に保ちます。1 つの [ComponentsManager](/docs/diffusers/v0.43.0/ja/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) が各コンポーネントを一度だけ保持し、両方のパイプラインのためにオフロードを行い、Pika H3 Flex パイプラインは 2 つのスケジューラのみを追加し、アダプタが共有トランスフォーマーで実行される 2 つのモデルのどちらかを決定します。

```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)` を実行すると、結果が表示されます。共有コンポーネントはそれぞれ1回ずつリストに示され、両方のコレクションに属しています。Pika H3 Flex コレクションは2つのスケジューラーを追加し、2つのtransformersにはアダプターが保持されています。

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

アダプターが、共有されている transformers がどのモデルであるかを決定します。MiniMax-H3 に戻すには、`pika.disable_lora()` を呼び出すだけです。次の `minimax(...)` リクエストではベースモデルが実行されます。`pika.enable_lora()` を呼び出すと、Pika H3 Flex が再度有効になります。その間に何も再読み込みされることはなく、いずれかのパイプラインが各コンポーネントに到達するたびに、マネージャーがそれらをアクセラレーターにオン/オフします。

## MiniMax-H3との違い

- **ステップ数は6、`num_inference_steps`は不要です。** [MiniMaxH3Scheduler](/docs/diffusers/v0.43.0/ja/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) の両インスタンス（動画用は `shift=12.0`、音声用は `shift=3.0`）は、パイプラインの `denoising_step_list` 設定、すなわち公開されているスケジュール `[1000, 750, 500, 250, 100, 40, 0]` に対して `stochastic_sampling` を実行します。各ステップでクリーンなサンプルを予測し、最終ステップを除くすべてのステップでは、次の sigma まで新しいノイズで再ノイズ化します。ステップ数はアダプター側の契約事項であり、入力パラメータではありません。
- **各ステップで新しいノイズを生成します。** リクエストは`generator`から固定の順序でサンプリングします。条件付けノイズにはキーフレームまたは視覚参照ごとに1回、次に動画ノイズ、音声ノイズ、そして最初の5ステップそれぞれの動画および音声の再ノイズ化用サンプリングが行われます。`latents`または`audio_latents`を渡すと、最初の2回のサンプリングが置き換えられ、残りはそのまま維持されます。
- **キーフレームは引き伸ばされず、クロップされます。** `fl2va`のキーフレームは、自身の解像度でキャンバスのアスペクト比に合わせて中央クロップされ、キャンバスにリサイズされます。
- **参照はキャンバスの解像度ティアに従います。** Pika H3 Flex はバケットテーブル上で生成を行います。480pティアと768pティアがあり、それぞれ11種類のアスペクト比が用意されています。`ref2va` リクエストは、そのキャンバスのティアに基づいて条件付けを行います。画像参照は、768ティア未満では短辺1024ピクセル、それ以上では2048ピクセルでエンコードされ、動画参照は該当ティアのキャンバールールに従います。すべての動画参照および単体オーディオ参照は2秒から15秒の長さを持ち、動画の総再生時間と単体オーディオの総再生時間は、それぞれ最大15秒までです。

## 生成

リリースされたバケットは、Pika H3 Flex が検証されたキャンバスです。`height` と `width` として1つを指定してください。

| | 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"],
)
```

`ref2va` ワークフローは、MiniMax-H3 と同様に、最大 9 枚の画像、3 本の動画、3 本の音声クリップ（合計 12 件）からなる順序付きの参照リストを受け取ります。モダリティごとに 1 つの参照クラスが割り当てられます。また、このリクエストは最も多くのメモリを必要とします。参照はシーケンスに独自の行を追加するため、768p では Transformer 単体で 80 GB の GPU を埋め尽くします。そのため、以下の例では、Transformer のブロックを CPU メモリから 1 つずつストリーミングし、マネージャーは従来どおり他のコンポーネントをデバイスに移動・退避します。この設定では、1 枚の 80 GB GPU で 768p の参照リクエストを実行できます。ストリーミングを行わない場合は、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)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/modular_pipeline.py#L211)

Pika H3 Flex と、ポストトレーニング済みの6ステップ MiniMax-H3 を用いた、動画と音声の同時生成を行う ModularPipeline です。`t2va`（テキストのみ）および `fl2va`（先頭および/または末尾キーフレーム）ワークフローは `transformer/` チェックポイントパーティションに対して、`fl2va` アダプターを使用します。また、`ref2va`（オムニリファレンス）ワークフローは `transformer_ref/` に対して、`ref2va` アダプターを使用します。

ベースコンポーネントは MiniMax-H3 のものを使用し、Pika H3 Flex のリリースは、2 つの transformer パーティション上に構築された rank-128 の LoRA アダプターの一対です。そのため、パイプラインは 2 つのステップで組み立てられます。まず、ベースコンポーネントと 2 つのスケジューラを指定する `modular_model_index.json` を通じてコンポーネントを読み込み、次に、選択したワークフローのアダプターを [load_lora_weights()](/docs/diffusers/v0.43.0/ja/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")
```

MiniMax-H3と同様に、Pika H3 Flexは、テキストの条件付け、キーフレームまたは参照条件付けの潜在変数、音声の潜在変数、動画の潜在変数を一度に保持する**1つのパックされたシーケンス**をノイズ除去します。そのため、ブロックはモダリティごとのテンソルではなく行レイアウトを渡し、パイプラインは単一のtransformer呼び出し内でステップされる2つのスケジューラ（動画用は`shift = 12.0`、音声用は`shift = 3.0`）を保持します。MiniMax-H3と異なり、この2つのスケジューラは、固定の6ステップの`denoising_step_list`に対して`stochastic_sampling`を行う[MiniMaxH3Scheduler](/docs/diffusers/v0.43.0/ja/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler)のインスタンスです。`num_inference_steps`は存在せず、各ステップでリクエストのジェネレーターから新しいノイズがサンプリングされます。

アダプターはベースモデルと同様にガイダンス蒸留されており、`negative_prompt`も`guidance_scale`も存在せず、各ステップでフォワードパスが正確に1回だけ実行されます。

このモジュールは、各ブロックが参照するモデルの事実を保持します。config から導出される幾何学的情報はプロパティとして、キャンバス、ティア、およびフレーム数の計算は関数として定義されています。また、条件付け、エンコーディング、ノイズの契約は、ブロック自体に実装されています。

## PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]]

#### diffusers.PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]]

```python
diffusers.PikaH3FlexBlocks()
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/modular_blocks_pika_h3_flex.py#L668)

Pika H3 Flex による動画と音声の同時生成に対応した Auto Modular パイプラインブロックです。`t2va`（テキストのみ）、`fl2va`（先頭および/または末尾キーフレーム）、`ref2va`（オムニリファレンス）のワークフローがあり、`references` とキーフレームの入力によって選択されます。`t2va` と `fl2va` のワークフローは `transformer` パーティションを `fl2va` アダプターで実行し、`ref2va` は `transformer_ref` パーティションを `ref2va` アダプターで実行します。そのため、リクエストが採用するワークフローのアダプターを読み込む必要があります。`workflow=` を指定しない場合、コンポーネントの読み込み時に 61.7GB の **両方の** transformer パーティションが読み込まれてしまいます。タスクに必要なもののみを読み込むには、`workflow=` を指定してください。

サポートされているワークフロー:
- `t2va`: `prompt`が必要です
- `fl2va`: `prompt`、`image`、または `prompt`、`last_image` が必要です
- `ref2va`: `prompt`、`references` が必要です

コンポーネント: 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`)

設定: canvas_short_edge (デフォルト: 768) canvas_max_pixels (デフォルト: 1032192) denoising_step_list (デフォルト: [1000, 750, 500, 250, 100, 40, 0])

Inputs: references (`list`, *任意*): 条件付けに使用する参照です。**モデルがそれらを参照する順序**、すなわちプロンプト内でラベルを付与する順序と、共有ロータリークロック上に配置する順序を指定します。順序が異なれば、異なるリクエストとなります。モダリティごとに1つのデータクラスを持ち、すべてはメモリ内のメディアを保持します。`PikaH3FlexImageReference`（最大9個）、独自の`fps`を持つ`PikaH3FlexVideoReference`（最大3個。その`audio`サウンドトラックも条件付けの対象となります）、または独自の`sample_rate`を持つ`PikaH3FlexAudioReference`（最大3個）です。参照の合計は最大12個までで、オーディオ参照のみを指定することはできません。すべての動画または単独のオーディオ参照は2秒から15秒の長さです。動画の再生時間と単独のオーディオの再生時間は、それぞれ合計15秒以下である必要があります。これらのブロックはメディアファイルを開きません。各クラスの`from_file`クラスメソッドでデコードし、レートも一緒に読み込みます。height (`int`, *任意*): 生成される動画のピクセル単位の縦幅です。32の倍数である必要があります。width (`int`, *任意*): 生成される動画のピクセル単位の横幅です。32の倍数である必要があります。num_frames (`int`, *任意*): 固定の24 fpsで生成するフレーム数です。120から360、つまり5秒から15秒の範囲で、動画VAEがデコードできる次の`17 * n + 5`に切り上げられます。参照サウンドトラックと同じ長さの動画を生成するには、`round(samples / sample_rate * 24)`を渡します。image (`Image`, *任意*): 動画の開始となるキーフレームです。キャンバスのアスペクト比に合わせて中央クロップされ、キャンバスにリサイズされます。キャンバスはデフォルトでは、そのキーフレーム自身のアスペクト比から導出されます。last_image (`Image`, *任意*): 動画の終了となるキーフレームです。`image`と同様に、キャンバスのアスペクト比に合わせて中央クロップされ、キャンバスにリサイズされます。単独で渡すことで、フレームを*最大*まで生成できます。prompt (`str`): 生成をガイドするプロンプトです。単一の文字列です。normalized_references (`list`, *任意*): セットアップステップで正規化された参照です。パックされた順序で保持されます。keyframes (`list`, *任意*): ターゲットキャンバス上に配置されたキーフレームです。パックされた順序で保持されます。condition_latents (`list`, *任意*): エンコードされた動画の条件付けレイテンツです。パックされた順序で、画像参照と動画参照ごとに1つです。その形状は、すべての参照ブロックのジオメトリの来源となります。audio_condition_latents (`list`, *任意*): エンコードされたオーディオの条件付け行です。パックされた順序で、オーディオを持つ参照ごとに1つです。generator (`Generator`, *任意*): リクエストのジェネレーターです。条件付けノイズは、生成される行のノイズよりも先に、条件ごとに1回ずつ、このジェネレーターから抽出されます。latents (`Tensor`): 形状`(1, 24, num_latent_frames, latent_height, latent_width)`の事前生成された動画ノイズです。抽出の代わりに使用されます。audio_latents (`Tensor`): 形状`(2, 32, num_audio_latents)`の事前生成されたオーディオノイズです。**denoiser_input_fields (`None`, *任意*): トランスフォーマーが名前によって読み取るパックされたシーケンスの構造記述です。`token_tags`、`position_ids`、および3つの行インデックステンソルです。attention_kwargs (`dict`, *任意*): アテンションプロセッサ用の追加のkwargsです。keyframe_anchors (`tuple`, *任意*, デフォルトは ()): パックされた順序で、各キーフレームが動画のどの端にアンカーされるかを指定します。output_type (`str`, *任意*, デフォルトは pil): 出力形式です。'pil'、'np'、または'pt'を指定します。

出力: videos (`list`): 生成された動画。 audio (`Tensor`): 生成されたサウンドトラック。形状は `(1, 2, num_samples)` です。 sampling_rate (`int`): 生成されたサウンドトラックのサンプリングレート (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])
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L83)

**パラメータ:**

image (`PIL.Image.Image`、`np.ndarray` または `torch.Tensor`) : 参照画像: 画像、`(height, width, 3)` の配列、または `(3, height, width)` のテンソルで、`uint8` または `[0, 1]` 範囲の浮動小数点数です。生成されるジオメトリには決してバインドされません。リリースされたチェックポイントでは、リクエストが生成するキャンバスサイズに関わらず、自身の短辺を 2048 にしてエンコードされます。

被写体、スタイル、またはシーン参照: 1リクエストあたり最大9件。

#### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference.from_file]]

```python
from_file(media)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L99)

**パラメータ:**

media (`str` または `os.PathLike`) : 画像のパスまたはURL。

`PikaH3FlexImageReference`に、[load_image()](/docs/diffusers/v0.43.0/ja/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)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L111)

**パラメータ:**

frames (`list[PIL.Image.Image]`、`np.ndarray` または `torch.Tensor`) : 参照フレーム: 画像のリスト、`(num_frames, height, width, 3)` の配列、または `(num_frames, 3, height, width)` のテンソルで、`uint8` または `[0, 1]` 上の浮動小数点数です。

fps (`float`、*optional*、デフォルト値は 24.0) : `frames` が持つフレームレートです。この値により、参照のビジョンブロックがコンディショナーの 2 fps グリッド上に配置されます。MiniMax-H3 自体のクロックは 24 fps であるため、それ以外のレートは、フレーム全体を削除・複製することで 24 fps にリサンプリングされます。そのため、フレームがファイルから取得された場合は、このフィールドを正しく設定することが重要です。

audio (`torch.Tensor`、形状 `(channels, num_samples)`、*任意*) : この動画のサウンドトラック（モノラルまたはステレオ）。これは、参照そのものとしてではなく、参照のそれとして条件付けられます。省略した場合、参照はモーションのみを条件とします。

sample_rate (`int`, *optional*) : `audio` がサンプルを保持するレートです。省略した場合、オーディオ VAE 自身のレートが使用され、サンプルはそのまま保持されます。それ以外のレートが指定された場合は、そのレートにリサンプリングされます。

モーションとカメラのリファレンス: リクエストごとに最大3つまで、自身のサウンドトラックと合わせて条件付けられます。

#### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference.from_file]]

```python
from_file(media)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L147)

**パラメータ:**

media (`str` または `os.PathLike`) : 動画のパスまたは URL。

**戻り値:** `PikaH3FlexVideoReference`

コンテナが報告するフレームレートで、音声ストリームがある場合はそのサウンドトラックおよびそのサウンドトラック自体のサンプルレートも保持する、`(num_frames, height, width, 3)` の `uint8` フレーム。

`PikaH3FlexVideoReference` に、元の解像度、フレームレート、および音声トラックを保持したまま、動画ファイルをデコードします。

レートは参照に反映されます。これが [load_video()](/docs/diffusers/v0.43.0/ja/api/utilities#diffusers.utils.load_video) を使わずにこの方法でデコードする理由です。MiniMax-H3 は参照を独自の 24 fps にリサンプリングするため、入力時に失われたフレームレートは、誤った速度で条件付けされたリクエストとなり、何の警告も出されません。メタデータが誤っているコンテナは、返された参照の `fps` または `sample_rate` を上書きすることで修正できます。

[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)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L174)

**パラメータ:**

audio (`torch.Tensor`、形状 `(channels, num_samples)`) : 参照用の波形（モノラルまたはステレオ）。

sample_rate (`int`, *optional*) : `audio` がサンプルを保持するレートです。省略した場合、オーディオ VAE 自身のレートが使用され、サンプルはそのまま保持されます。それ以外のレートが指定された場合は、そのレートにリサンプリングされます。

音声または音楽のリファレンス: 1リクエストあたり最大3つまで。単独では使用できず、オーディオリファレンスには少なくとも1つの画像または動画リファレンスとペアで指定する必要があります。コンディショナーには渡されず、オーディオVAEのみによってエンコードされます。

#### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference.from_file]]

```python
from_file(media)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L193)

**パラメータ:**

media (`str` または `os.PathLike`) : 音声のパスまたは URL、またはサウンドトラックを抽出する動画のパスまたは URL。

**戻り値:** `PikaH3FlexAudioReference`

コンテナが報告するサンプルレートでの、`(channels, num_samples)` の float32 波形。

オーディオファイルを、そのファイルが持つサンプルレートで`PikaH3FlexAudioReference`にデコードします。

[PyAV](https://github.com/PyAV-Org/PyAV)が必要です。