# Pika H3 Flex

  
    
  

[Pika H3 Flex](https://huggingface.co/Pika-Labs/Pika-H3-Flex) — это модель пост-обучения [MiniMax-H3](./minimax_h3) от Pika, превращающая её в генератор видео и аудио за шесть шагов. Она сохраняет упакованную последовательность MiniMax-H3, её conditioner на базе Qwen3-VL и два VAE, но вносит два изменения: сэмплер — фиксированный шестиступенчатый график, который на каждом шаге заново добавляет шум к чистому предсказанию вместо обновления по Эйлеру, и веса — пара LoRA-адаптеров ранга 128 для двух трансформерных разделов MiniMax-H3. Видео и его синхронизированный стереозвук получаются в результате одних и тех же шести прямых проходов.

Релиз представляет собой адаптеры: адаптер FL2VA (`fl2va/adapter.safetensors`) управляет разделом `transformer/` для условий текста и конечных кадров, а адаптер Ref2VA (`ref2va/adapter.safetensors`) управляет `transformer_ref/` для мультимодальных ссылок. Базовые компоненты принадлежат [MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) и не были изменены; репозиторий содержит их копию, чтобы загружаться самостоятельно.

Pika H3 Flex интегрируется исключительно в виде блоков [Modular Diffusers](../../modular_diffusers/overview), как и MiniMax-H3: сами блоки и их [PikaH3FlexModularPipeline](/docs/diffusers/main/ru/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline) составляют всю интеграцию, а половины `DiffusionPipeline` не существует.

## Загрузка

Пайплайн собирается в два шага: компоненты загружаются через `modular_model_index.json`, который указывает базовые компоненты MiniMax-H3 и два конфигурации планировщика, после чего адаптер выбранного рабочего процесса загружается поверх с помощью [load_lora_weights()](/docs/diffusers/main/ru/api/loaders/lora#diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights). Адаптеры представляют собой обычные дампы PEFT с именами модулей diffusers и загружаются в том масштабе, в котором были обучены (`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 обрезает блоки до нужной задачи, поэтому загружается только соответствующая ей часть трансформера, адаптер направляет запросы в единственную присутствующую часть, а конвейер принимает только запросы этой задачи — конвейер `fl2va` требует ключевой кадр, а `t2va` — нет. Конвейер, содержащий обе части (загруженный без `workflow=`), требует указания, куда разместить адаптер Ref2VA: `pipe.load_lora_weights(..., weight_name="ref2va/adapter.safetensors", load_into_transformer_ref=True)`. Оба VAE выпускаются в float32 и декодируют в float32, как и в опубликованном пакете; всё остальное выполняется в bfloat16.

> [!TIP]
> `pipe.doc` выводит, что принимает и возвращает текущий конвейер: каждый вход с его значением по умолчанию, ожидаемые компоненты и создаваемые выходные данные.

### Повторное использование загруженной MiniMax-H3

Базовые компоненты принадлежат MiniMax-H3, поэтому уже загруженный пайплайн MiniMax-H3 содержит всё, кроме двух планировщиков и адаптеров. В этом разделе из загруженных компонентов собирается пайплайн Pika H3 Flex, при этом оба пайплайна остаются готовыми к работе параллельно: один [ComponentsManager](/docs/diffusers/main/ru/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) хранит каждый компонент один раз и выгружает его для обоих, пайплайн Pika H3 Flex добавляет только свои два планировщика, а адаптеры определяют, какую из двух моделей выполняют общие трансформеры.

```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)` показывает результат: каждый общий компонент перечисляется один раз и принадлежит обеим коллекциям, коллекция Pika H3 Flex добавляет свои два планировщика, а два трансформера содержат адаптер.

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

- **Шесть шагов, без `num_inference_steps`.** Оба экземпляра [MiniMaxH3Scheduler](/docs/diffusers/main/ru/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) (`shift=12.0` для видео, `shift=3.0` для аудио) работают с `stochastic_sampling` по конфигурации `denoising_step_list` пайплайна, опубликованному расписанию `[1000, 750, 500, 250, 100, 40, 0]`: на каждом шаге предсказывается чистый образец, а все, кроме последнего, заново шумятся свежим шумом до следующего сигмы. Количество шагов является контрактом адаптера и не является входным параметром.
- **Свежий шум на каждом шаге.** Запрос извлекает значения из своего `generator` в фиксированном порядке: одно извлечение для каждого ключевого кадра или визуального эталона для шума условий, затем шум видео, шум аудио, а затем извлечения для повторного добавления шума в видео и аудио на каждом из первых пяти шагов. Передача `latents` или `audio_latents` заменяет два начальных извлечения, оставляя остальные без изменений.
- **Ключевые кадры обрезаются, а не растягиваются.** Ключевой кадр `fl2va` центрированно обрезается до соотношения сторон холста в собственном разрешении, а затем масштабируется под холст.
- **Ссылки следуют уровню разрешения холста.** Pika H3 Flex генерирует по таблице бакетов — уровню 480p и уровню 768p, по одиннадцать соотношений сторон для каждого — и запрос `ref2va` задаёт условия в соответствии с уровнем его холста: изображение-ссылка кодируется с короткой стороной 1024 пикселя ниже уровня 768 и 2048 пикселя на нём и выше, а видео-ссылка подчиняется собственному правилу холста для данного уровня. Каждое видео или отдельное аудио-ссылка длится от 2 до 15 секунд, при этом суммарная длительность всех видео и суммарная длительность всех отдельных аудио не превышают 15 секунд каждая.

## Генерация

Опубликованные значения — это размеры, на которых была проверена Pika H3 Flex. Передайте одно из них в качестве `height` и `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"],
)
```

Воркфлоу `ref2va` принимает упорядоченный список референсов — до 9 изображений, 3 видео и 3 аудиоклипов, 12 всего — по тому же принципу, что и MiniMax-H3, с одним классом референсов на каждый модальность. Это также запрос, требующий наибольшего объёма памяти: референсы добавляют собственные строки в последовательность, и при разрешении 768p один только трансформер занимает 80 ГБ видеопамяти. Поэтому в примере ниже блоки трансформера стримятся из оперативной памяти по одному, в то время как менеджер перемещает остальные компоненты на устройство и с него, как и прежде. Пример выполняет запрос с референсами в разрешении 768p на одной карте с 80 ГБ памяти; без стриминга ограничьтесь разрешением 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/main/src/diffusers/modular_pipelines/pika_h3_flex/modular_pipeline.py#L211)

Модульный `t2va` для совместной генерации видео и аудио с Pika H3 Flex, пост-обученной шестиступенчатой MiniMax-H3: рабочие процессы `t2va` (только текст) и `fl2va` (первый и/или последний ключевой кадр) для раздела контрольной точки `transformer/` с адаптером `fl2va`, а также рабочий процесс `ref2va` (omni-reference) для `transformer_ref/` с адаптером `ref2va`.

Базовые компоненты — это компоненты MiniMax-H3, а релиз Pika H3 Flex представляет собой пару LoRA-адаптеров ранга 128, наложенных на два раздела трансформера, поэтому конвейер собирается в два шага: компоненты загружаются через `modular_model_index.json`, в котором указаны базовые компоненты и два планировщика, а адаптер выбранного рабочего процесса загружается с помощью [load_lora_weights()](/docs/diffusers/main/ru/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 выполняет денойзинг **одной упакованной последовательности**, которая одновременно содержит текстовые условия, латенты условий по ключевому кадру или референсу, аудио-латенты и видео-латенты. Именно поэтому блоки передают между собой строковое расположение данных, а не тензоры по отдельным модальностям, и почему пайплайн использует два планировщика (`shift = 12.0` для видео и `shift = 3.0` для аудио), которые выполняются внутри одного вызова трансформера. В отличие от MiniMax-H3, оба планировщика являются экземплярами [MiniMaxH3Scheduler](/docs/diffusers/main/ru/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) с `stochastic_sampling` по фиксированному списку из шести шагов `denoising_step_list`: параметра `num_inference_steps` нет, и на каждом шаге из генератора запроса извлекается новый шум.

Адаптеры дистиллированы по руководству, как и их базовые модели: здесь нет guider, нет `negative_prompt` и нет `guidance_scale`, а на каждом шаге выполняется ровно один прямой проход.

Этот модуль содержит сведения о модели, на которые опираются все блоки: геометрию, выводимую из конфигурации, в виде свойств, а также арифметику холста, уровня и количества кадров в виде функций. Контракты для условного формирования, кодирования и шума реализованы непосредственно в самих блоках.

## PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/modular_blocks_pika_h3_flex.py#L668)

Блоки модульного конвейера Auto для совместной генерации видео и аудио с Pika H3 Flex: рабочие процессы `t2va` (только текст), `fl2va` (первый и/или последний ключевой кадр) и `ref2va` (omni-reference), выбор которых осуществляется на основе входных данных `references` и ключевых кадров. Рабочие процессы `t2va` и `fl2va` используют раздел `transformer` с адаптером `fl2va`, а `ref2va` — раздел `transformer_ref` с адаптером `ref2va`, поэтому загружайте адаптер того рабочего процесса, который соответствует запросу. Без указания `workflow=` загрузка компонентов подтянет **оба** раздела трансформера размером 61,7 ГБ — передайте один из них, чтобы загрузить только то, что требуется для задачи.

Поддерживаемые рабочие процессы:
- `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`, *необязательный*): Ссылки, на которые опирается генерация, **в том порядке, в котором модель должна их читать**: порядок определяет их метки в представлении промпта и расположение на общей вращательной шкале, поэтому другой порядок — это другой запрос. По одному dataclass на модальность, все хранят медиа в памяти: `PikaH3FlexImageReference` (не более 9), `PikaH3FlexVideoReference` со своей частотой `fps` (не более 3, звуковой дорожкой `audio` также можно управлять) или `PikaH3FlexAudioReference` со своей частотой `sample_rate` (не более 3) — всего не более 12 ссылок, при этом ссылки на аудио не могут быть единственными. Длительность каждого видео или отдельного аудио составляет от 2 до 15 секунд, а суммарная длительность видео и суммарная длительность отдельных аудио не превышают 15 секунд. Эти блоки никогда не открывают медиафайл: декодируйте с помощью classmethod `from_file` каждого класса, который также передает частоты. height (`int`, *необязательный*): Высота генерируемого видео в пикселях, кратная 32. width (`int`, *необязательный*): Ширина генерируемого видео в пикселях, кратная 32. num_frames (`int`, *необязательный*): Количество кадров для генерации при фиксированной частоте 24 fps: от 120 до 360, то есть от 5 до 15 секунд, округленное вверх до ближайшего значения `17 * n + 5`, которое может декодировать видео VAE. Чтобы сгенерировать видео той же длины, что и звуковая дорожка-ссылка, передайте `round(samples / sample_rate * 24)`. image (`Image`, *необязательный*): Ключевой кадр, с которого начинается видео. Он обрезается по центру до соотношения сторон холста и масштабируется на него; по умолчанию холст выводится из собственного соотношения сторон. last_image (`Image`, *необязательный*): Ключевой кадр, на котором заканчивается видео. Можно передать отдельно, чтобы сгенерировать *до* кадра. Обрезается по центру до соотношения сторон холста и масштабируется на него, как `image`. prompt (`str`): Промпт для управления генерацией, одна строка. normalized_references (`list`, *необязательный*): Ссылки, нормализованные на этапе настройки, в упакованном порядке. keyframes (`list`, *необязательный*): Ключевые кадры, размещенные на целевом холсте, в упакованном порядке. condition_latents (`list`, *необязательный*): Закодированные латенты для условного видео, по одному на каждую ссылку на изображение и видео в упакованном порядке. Их форма определяет геометрию каждого блока ссылок. audio_condition_latents (`list`, *необязательный*): Закодированные строки для условного аудио, по одной на каждую ссылку с аудио в упакованном порядке. generator (`Generator`, *необязательный*): Генератор запроса. Шум для условий извлекается из него первым, по одному извлечению на каждое условие, до шума для генерируемых строк. 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` и три тензора индексов строк. 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`): частота дискретизации сгенерированной звуковой дорожки в Гц.

## 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/main/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 для выпущенной контрольной точки, независимо от того, какой холст генерирует запрос.

Ссылка на объект, стиль или сцену: не более 9 на запрос.

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

```python
from_file(media)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L99)

**Параметры:**

media (`str` или `os.PathLike`) : Путь или URL изображения.

Загрузите файл изображения в `PikaH3FlexImageReference` с помощью [load_image()](/docs/diffusers/main/ru/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/main/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, поэтому любая другая частота приводится к ней путём удаления и дублирования целых кадров — поэтому это поле важно указать правильно, если кадры получены из файла.

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/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L147)

**Параметры:**

media (`str` или `os.PathLike`) : Путь или URL видео.

**Возвращает:** `PikaH3FlexVideoReference`

кадры `(num_frames, height, width, 3)` типа `uint8` с частотой кадров, указанной в контейнере, с его звуковым сопровождением и собственной частотой дискретизации этого сопровождения, если в контейнере есть аудиопоток.

Декодирование видеofайла в `PikaH3FlexVideoReference` с сохранением разрешения, частоты кадров и звукового сопровождения.

Частоты попадают в reference, что и является целью такого способа декодирования, а не [load_video()](/docs/diffusers/main/ru/api/utilities#diffusers.utils.load_video): MiniMax-H3 пересэмплирует reference под собственные 24 fps, поэтому потерянная по пути частота кадров означает запрос, сформированный с неверной скоростью, и система не выдаст об этом никакого предупреждения. Если метаданные контейнера неверны, это исправляется переопределением `fps` или `sample_rate` в возвращаемом reference.

Требуется [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/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L174)

**Параметры:**

audio (`torch.Tensor` формы `(channels, num_samples)`) : эталонная волна, моно или стерео.

sample_rate (`int`, *optional*) : Частота, с которой `audio` несёт свои сэмплы. Если не указано, используется собственная частота аудио-VAE, и сэмплы остаются без изменений; любая другая частота приводит к ресемплированию на неё.

Ссылка на голос или музыку: не более 3 на запрос, и никогда не используется по отдельности — аудиоссылка должна сопровождаться как минимум одной ссылкой на изображение или видео. Она никогда не поступает в conditioner и кодируется исключительно аудио-VAE.

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

```python
from_file(media)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L193)

**Параметры:**

media (`str` или `os.PathLike`) : путь или URL к аудиофайлу или к видео, из которого извлекается звуковая дорожка.

**Возвращает:** `PikaH3FlexAudioReference`

float32-волну `(channels, num_samples)` с частотой дискретизации, указанной в контейнере.

Декодирование аудиофайла в `PikaH3FlexAudioReference` с частотой дискретизации, указанной в файле.

Требуется [PyAV](https://github.com/PyAV-Org/PyAV).