# Pika H3 Flex [Pika H3 Flex](https://huggingface.co/Pika-Labs/Pika-H3-Flex) là phiên bản huấn luyện sau (post-training) của Pika dựa trên [MiniMax-H3](./minimax_h3), biến nó thành bộ tạo video và âm thanh chỉ trong sáu bước. Mô hình này giữ nguyên chuỗi đóng gói (packed sequence) của MiniMax-H3, bộ điều kiện Qwen3-VL và hai VAE, đồng thời thay đổi hai điểm: bộ lấy mẫu (sampler) là lịch trình sáu bước cố định, trong đó nhiễu lại (re-noise) dự đoán sạch tại mỗi bước thay vì cập nhật Euler, và trọng số là một cặp adapter LoRA rank-128 trên hai phân vùng transformer của MiniMax-H3. Video cùng bản nhạc nền stereo đồng bộ được tạo ra từ cùng sáu lần truyền thẳng (forward pass). Bản phát hành chính là các adapter: adapter FL2VA (`fl2va/adapter.safetensors`) điều khiển phân vùng `transformer/` cho điều kiện văn bản và khung đầu cuối, adapter Ref2VA (`ref2va/adapter.safetensors`) điều khiển `transformer_ref/` cho các tham chiếu đa phương thức. Các thành phần cơ sở là của [MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3), không thay đổi, và kho lưu trữ có chứa một bản sao của chúng để có thể tải độc lập. Pika H3 Flex được tích hợp dưới dạng các khối [Modular Diffusers](../../modular_diffusers/overview) duy nhất, giống như MiniMax-H3: các khối và [PikaH3FlexModularPipeline](/docs/diffusers/main/vi/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline) của chúng là toàn bộ phần tích hợp, và không có nửa `DiffusionPipeline`. ## Đang tải Một pipeline được lắp ráp qua hai bước: các thành phần được nạp thông qua `modular_model_index.json` trong đó liệt kê các thành phần cơ sở của MiniMax-H3 và hai cấu hình scheduler, sau đó adapter của workflow được chọn sẽ được nạp đè lên bằng [load_lora_weights()](/docs/diffusers/main/vi/api/loaders/lora#diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights). Các adapter là các bản dump PEFT thuần túy của tên module diffusers và được nạp ở tỷ lệ đã huấn luyện (`alpha == rank`, 1.0). | Quy trình làm việc | Đầu vào | Chia nhỏ Transformer | Adapter | |---|---|---|---| | `t2va` | `prompt` | `transformer/` | `fl2va/adapter.safetensors` | | `fl2va` | `prompt` và `image` và/hoặc `last_image` | `transformer/` | `fl2va/adapter.safetensors` | | `ref2va` | `prompt` và `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") ``` Việc truyền workflow sẽ cắt bỏ các khối không liên quan đến tác vụ đó, nên chỉ phân vùng transformer của chính tác vụ được tải về, adapter sẽ định tuyến đến phân vùng duy nhất hiện có, và pipeline chỉ chấp nhận các yêu cầu của tác vụ đó — pipeline `fl2va` cần một keyframe, còn pipeline `t2va` thì không. Một pipeline giữ cả hai phân vùng (được tải mà không có `workflow=`) cần được chỉ định vị trí đặt adapter Ref2VA: `pipe.load_lora_weights(..., weight_name="ref2va/adapter.safetensors", load_into_transformer_ref=True)`. Hai VAE được phát hành ở float32 và giải mã ở float32, giống như gói đã phát hành; mọi thứ khác chạy ở bfloat16. > [!TIP] > `pipe.doc` in ra những gì pipeline trước mặt bạn nhận vào và trả về — mọi đầu vào cùng giá trị mặc định, các thành phần mà nó kỳ vọng và các đầu ra mà nó tạo ra. ### Tái sử dụng MiniMax-H3 đã được tải Các thành phần cơ bản là của MiniMax-H3, do đó một pipeline MiniMax-H3 đã được nạp sẵn sẽ chứa mọi thứ ngoại trừ hai bộ lập lịch và các bộ thích ứng. Phần này lắp ráp một pipeline Pika H3 Flex từ các thành phần đã nạp đó và giữ cả hai pipeline sẵn sàng song song: một [ComponentsManager](/docs/diffusers/main/vi/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) giữ mỗi thành phần một lần và chuyển chúng xuống bộ nhớ cho cả hai, pipeline Pika H3 Flex chỉ thêm hai bộ lập lịch của nó, và các bộ thích ứng quyết định xem các transformer dùng chung sẽ chạy mô hình nào trong hai mô hình. ```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)` hiển thị kết quả: mỗi thành phần dùng chung được liệt kê một lần và thuộc về cả hai bộ sưu tập, bộ sưu tập Pika H3 Flex thêm hai trình lập lịch, và hai bộ chuyển đổi mang một bộ thích ứng. ```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'] ``` Các adapter quyết định xem các transformers dùng chung là mô hình nào. Để quay lại MiniMax-H3, hãy gọi `pika.disable_lora()`, và đó là tất cả: yêu cầu `minimax(...)` tiếp theo sẽ chạy mô hình gốc. `pika.enable_lora()` sẽ bật lại Pika H3 Flex. Không có gì được nạp lại trong khoảng thời gian đó; trình quản lý sẽ di chuyển từng thành phần lên và xuống bộ tăng tốc khi bất kỳ pipeline nào đến lượt nó. ## Điểm khác biệt so với MiniMax-H3 - **Sáu bước, không có `num_inference_steps`.** Cả hai instance [MiniMaxH3Scheduler](/docs/diffusers/main/vi/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) (`shift=12.0` cho video, `shift=3.0` cho audio) đều chạy với `stochastic_sampling` trên cấu hình `denoising_step_list` của pipeline, theo lịch đã phát hành `[1000, 750, 500, 250, 100, 40, 0]`: mỗi bước dự đoán mẫu sạch, và tất cả các bước trừ bước cuối cùng sẽ thêm nhiễu mới vào mẫu đó để đưa về sigma tiếp theo. Số lượng bước là thỏa thuận của adapter và không phải là một đầu vào. - **Nhầm mới ở mỗi bước.** Một yêu cầu lấy mẫu từ `generator` của nó theo một thứ tự cố định: một lần lấy mẫu cho mỗi keyframe hoặc tham chiếu hình ảnh cho nhiễu điều kiện, nhiễu video, nhiễu âm thanh, và sau đó là các lần lấy mẫu tái nhiễu video và âm thanh của mỗi bước trong năm bước đầu tiên. Truyền `latents` hoặc `audio_latents` sẽ thay thế hai lần lấy mẫu ban đầu và giữ nguyên các lần còn lại. - **Keyframe được cắt, không bị kéo giãn.** Một keyframe `fl2va` sẽ được cắt theo tâm để khớp với tỷ lệ khung hình của canvas ở độ phân giải của chính nó, sau đó được thay đổi kích thước để vừa với canvas. - **Tham chiếu tuân theo cấp độ độ phân giải của canvas.** Pika H3 Flex tạo ra trên một bảng bucket — một cấp 480p và một cấp 768p, mỗi cấp có mười một tỷ lệ khung hình — và một yêu cầu `ref2va` được điều kiện hóa theo cấp của canvas của nó: một hình ảnh tham chiếu được mã hóa ở cạnh ngắn 1024 pixel dưới cấp 768 và 2048 từ cấp đó trở lên, và một video tham chiếu được đặt theo quy tắc canvas của chính cấp đó. Mọi video hoặc âm thanh độc lập tham chiếu đều có độ dài từ 2 đến 15 giây, và tổng độ dài của các video và tổng độ dài của các âm thanh độc lập mỗi loại đều không vượt quá 15 giây. ## Sinh Các bucket đã phát hành là những canvas mà Pika H3 Flex được xác thực trên đó. Truyền một bucket làm `height` và `width`: | | 21:9 | 16:9 | 3:2 | 4:3 | 5:4 | 1:1 | 4:5 | 3:4 | 2:3 | 9:16 | 9:21 | |---|---|---|---|---|---|---|---|---|---|---|---| | 480p | 960x416 | 832x480 | 704x480 | 640x480 | 608x480 | 480x480 | 480x608 | 480x640 | 480x704 | 480x832 | 416x960 | | 768p | 1536x672 | 1344x768 | 1152x768 | 1024x768 | 960x768 | 768x768 | 768x960 | 768x1024 | 768x1152 | 768x1344 | 672x1536 | ```py import torch from diffusers import ComponentsManager, ModularPipeline from diffusers.utils import load_image from diffusers.utils.export_utils import encode_video # 61.7GB of transformer and 62.1GB of conditioner do not sit on one accelerator, so the components are # registered in a manager that moves each one on and off as the blocks reach it. manager = ComponentsManager() manager.enable_auto_cpu_offload(device="cuda") # or "mps", "xpu", "cpu" # Create one pipeline for all supported workflows, then load the `fl2va` workflow's components, which is # enough to run both the fl2va and t2va requests below. pipe = ModularPipeline.from_pretrained("Pika-Labs/Pika-H3-Flex", components_manager=manager) pipe.load_components( workflow="fl2va", dtype={"vae": torch.float32, "audio_vae": torch.float32, "default": torch.bfloat16} ) pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="fl2va/adapter.safetensors") prompt = ( "integrated_multimodal_description: A cinematic close shot of a red ceramic cup on a wooden table beside an " "open window. A soft breeze moves a linen curtain. The camera slowly pushes toward the cup as warm morning " "light crosses the table.\n" "overall_soundscape: Gentle wind through the window and faint birdsong outside. No speech.\n" "non_diegetic_music: None.\n" ) outputs = ["videos", "audio", "sampling_rate"] # Text to video + audio on the 480p 16:9 bucket, 5 seconds. results = pipe( prompt=prompt, height=480, width=832, num_frames=124, generator=torch.Generator("cuda").manual_seed(42), output=outputs ) # First frame (and optionally `last_image`) to video + audio. The keyframe is center-cropped onto the canvas and # held as the first frame, so the prompt describes the keyframe and what happens from it. image = load_image( "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg" ) i2va_prompt = ( "For the target video, at 0.00 seconds into the target video, (from [Shot 1]) is fully referenced.\n\n" "integrated_multimodal_description: [Shot 1] Begin with the supplied image of a small toy astronaut figurine " "standing on a grey rocky moon surface, holding a white egg-shaped object. Preserve the figurine, its orange " "visor and the rocks. The astronaut slowly turns its helmet toward the camera and lifts the egg a little; fine " "dust drifts up around its boots. The camera slowly pushes in in one continuous shot. By the end the astronaut " "stands still, egg held up.\n\n" "overall_soundscape: Soft low wind and faint crunch of dust under the boots. No speech.\n\n" "non_diegetic_music: N/A\n" ) results = pipe( prompt=i2va_prompt, image=image, height=480, width=832, num_frames=124, generator=torch.Generator("cuda").manual_seed(42), output=outputs, ) encode_video( results["videos"][0], fps=24, output_path="pika_h3_flex_fl2va.mp4", audio=results["audio"][0], audio_sample_rate=results["sampling_rate"], ) ``` Workflow `ref2va` nhận một danh sách các tham chiếu có thứ tự — tối đa 9 hình ảnh, 3 video và 3 đoạn âm thanh, tổng cộng 12 — theo cách mà MiniMax-H3 thực hiện, với một lớp tham chiếu cho mỗi loại dữ liệu. Đây cũng là yêu cầu cần nhiều bộ nhớ nhất: các tham chiếu thêm hàng của chúng vào chuỗi, và ở độ phân giải 768p, riêng transformer đã lấp đầy một card 80 GB. Do đó, ví dụ bên dưới sẽ stream các khối của transformer từ bộ nhớ CPU một lần một, trong khi manager di chuyển các thành phần khác vào và ra khỏi thiết bị như trước. Nó chạy một yêu cầu tham chiếu 768p trên một card 80 GB; nếu không dùng streaming, hãy giữ ở 480p. ```py import torch from diffusers import ComponentsManager, ModularPipeline from diffusers.modular_pipelines.pika_h3_flex import ( PikaH3FlexAudioReference, PikaH3FlexImageReference, PikaH3FlexVideoReference, ) manager = ComponentsManager() manager.enable_auto_cpu_offload(device="cuda") # or "mps", "xpu", "cpu" pipe = ModularPipeline.from_pretrained( "Pika-Labs/Pika-H3-Flex", workflow="ref2va", components_manager=manager ) pipe.load_components(dtype={"vae": torch.float32, "audio_vae": torch.float32, "default": torch.bfloat16}) pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="ref2va/adapter.safetensors") # Keep the transformer in CPU memory and bring in one block at a time while it runs. pipe.transformer_ref.enable_group_offload( onload_device=torch.device("cuda"), offload_device=torch.device("cpu"), offload_type="block_level", num_blocks_per_group=1, use_stream=True, ) results = pipe( prompt="subject_definitions: is the woman in . summary: [reference generation] waves at the camera.", references=[ PikaH3FlexImageReference.from_file("subject.png"), PikaH3FlexVideoReference.from_file("motion_ref.mp4"), # frames, their `fps` and the soundtrack PikaH3FlexAudioReference.from_file("voice.wav"), # waveform and its `sample_rate` ], height=768, width=1344, num_frames=124, generator=torch.Generator("cuda").manual_seed(42), output=["videos", "audio", "sampling_rate"], ) ``` ## PikaH3FlexModularPipeline[[diffusers.PikaH3FlexModularPipeline]] #### diffusers.PikaH3FlexModularPipeline[[diffusers.PikaH3FlexModularPipeline]] ```python diffusers.PikaH3FlexModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/modular_pipeline.py#L211) Một ModularPipeline để tạo video + âm thanh đồng thời với Pika H3 Flex, phiên bản MiniMax-H3 sáu bước đã huấn luyện hậu: các luồng công việc `t2va` (chỉ văn bản) và `fl2va` (khung hình chính đầu và/hoặc cuối) đối với phân vùng checkpoint `transformer/` kèm adapter `fl2va`, và luồng công việc `ref2va` (tham chiếu toàn diện) đối với `transformer_ref/` kèm adapter `ref2va`. Các thành phần cơ bản là của MiniMax-H3, và bản phát hành Pika H3 Flex là một cặp adapter LoRA rank-128 nằm trên hai phân vùng transformer, do đó một pipeline được lắp ráp theo hai bước: các thành phần được nạp thông qua `modular_model_index.json` có tên các thành phần cơ bản và hai scheduler, và adapter của workflow được chọn được nạp bằng [load_lora_weights()](/docs/diffusers/main/vi/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") ``` Giống như MiniMax-H3, Pika H3 Flex khử nhiễu **một chuỗi đã đóng gói** chứa đồng thời điều kiện văn bản, các latent điều kiện từ khung hình chính hoặc tham chiếu, các latent âm thanh và các latent video. Đó là lý do tại sao các khối truyền một bố cục hàng thay vì các tensor theo từng phương thức, và lý do tại sao pipeline mang theo hai trình lập lịch (`shift = 12.0` cho video, `shift = 3.0` cho âm thanh) được thực hiện trong một lần gọi transformer duy nhất. Khác với MiniMax-H3, hai trình lập lịch là các instance của [MiniMaxH3Scheduler](/docs/diffusers/main/vi/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) với `stochastic_sampling` trên danh sách sáu bước khử nhiễu cố định `denoising_step_list`: không có `num_inference_steps`, và mỗi bước đều lấy nhiễu mới từ trình tạo của yêu cầu. Các adapter được chưng cất theo hướng dẫn giống như mô hình gốc của chúng: không có guider, không có `negative_prompt` và không có `guidance_scale`, và mỗi bước chỉ chạy đúng một lần truyền thẳng. Module này chứa các thông tin mô hình mà mọi khối đều dựa vào — hình học suy ra từ cấu hình dưới dạng các thuộc tính, các phép tính canvas, tier và số khung dưới dạng các hàm — trong khi các hợp đồng điều kiện, mã hóa và nhiễu được đặt trực tiếp trên chính các khối. ## PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]] #### diffusers.PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]] ```python diffusers.PikaH3FlexBlocks() ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/modular_blocks_pika_h3_flex.py#L668) Các khối pipeline Auto Modular cho việc tạo video + âm thanh đồng thời với Pika H3 Flex: các luồng công việc `t2va` (chỉ văn bản), `fl2va` (khung hình chính đầu và/hoặc cuối) và `ref2va` (tham chiếu toàn diện), được chọn dựa trên các đầu vào `references` và khung hình chính. Các luồng công việc `t2va` và `fl2va` chạy phân vùng `transformer` với adapter `fl2va`, còn `ref2va` chạy phân vùng `transformer_ref` với adapter `ref2va`, do đó hãy nạp adapter của luồng công việc mà yêu cầu sử dụng. Nếu không có `workflow=`, việc nạp các thành phần sẽ kéo **cả hai** phân vùng transformer 61.7GB — hãy truyền một trong số chúng để chỉ nạp những gì nhiệm vụ cần. Các quy trình làm việc được hỗ trợ: - `t2va`: yêu cầu `prompt` - `fl2va`: yêu cầu `prompt`, `image` hoặc `prompt`, `last_image` - `ref2va`: yêu cầu `prompt`, `references` Các thành phần: 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 (mặc định: 768) canvas_max_pixels (mặc định: 1032192) denoising_step_list (mặc định: [1000, 750, 500, 250, 100, 40, 0]) Inputs: references (`list`, *tùy chọn*): Các tham chiếu để điều kiện hóa, **theo thứ tự mà mô hình nên đọc chúng**: thứ tự này gắn nhãn cho chúng trong cách trình bày prompt và sắp xếp chúng trên đồng hồ rotary chung, do đó một thứ tự khác sẽ là một yêu cầu khác. Mỗi dataclass cho một chế độ, tất cả đều giữ phương tiện trong bộ nhớ — một `PikaH3FlexImageReference` (tối đa 9), một `PikaH3FlexVideoReference` với `fps` riêng của nó (tối đa 3, trong đó bản `audio` được điều kiện hóa như nhau), hoặc một `PikaH3FlexAudioReference` với `sample_rate` riêng của nó (tối đa 3) — tổng cộng tối đa 12 tham chiếu, và các tham chiếu audio không thể là duy nhất. Mỗi tham chiếu video hoặc audio độc lập có độ dài từ 2 đến 15 giây, và tổng độ dài của các video và tổng độ dài của các audio độc lập mỗi loại đều tối đa 15 giây. Các khối này không bao giờ mở tệp phương tiện: hãy giải mã bằng classmethod `from_file` của từng lớp, điều này sẽ mang theo các tần số. height (`int`, *tùy chọn*): Chiều cao của video được tạo ra tính bằng pixel, là bội số của 32. width (`int`, *tùy chọn*): Chiều rộng của video được tạo ra tính bằng pixel, là bội số của 32. num_frames (`int`, *tùy chọn*): Số khung hình cần tạo ra, ở 24 fps cố định: từ 120 đến 360, tức là từ 5 đến 15 giây, được làm tròn lên đến `17 * n + 5` gần nhất mà VAE video có thể giải mã. Để tạo ra một video có độ dài bằng với bản nhạc nền tham chiếu, hãy truyền `round(samples / sample_rate * 24)`. image (`Image`, *tùy chọn*): Khung hình chính mà video bắt đầu từ đó. Nó sẽ được cắt giữa theo tỷ lệ khung hình của canvas và được thay đổi kích thước lên canvas; canvas mặc định được suy ra từ tỷ lệ khung hình của chính nó. last_image (`Image`, *tùy chọn*): Khung hình chính mà video kết thúc ở đó. Có thể truyền riêng để tạo ra *đến* một khung hình. Nó được cắt giữa theo tỷ lệ khung hình của canvas và được thay đổi kích thước lên canvas, giống như `image`. prompt (`str`): Prompt để hướng dẫn quá trình tạo ra, là một chuỗi duy nhất. normalized_references (`list`, *tùy chọn*): Các tham chiếu đã được chuẩn hóa bởi bước thiết lập, theo thứ tự đóng gói. keyframes (`list`, *tùy chọn*): Các khung hình chính được đặt lên canvas đích, theo thứ tự đóng gói. condition_latents (`list`, *tùy chọn*): Các latents điều kiện hóa video đã được mã hóa, một cho mỗi tham chiếu hình ảnh và video theo thứ tự đóng gói. Hình dạng của chúng là nơi mà hình học của mỗi khối tham chiếu bắt nguồn. audio_condition_latents (`list`, *tùy chọn*): Các hàng điều kiện hóa audio đã được mã hóa, một cho mỗi tham chiếu chứa audio theo thứ tự đóng gói. generator (`Generator`, *tùy chọn*): Bộ tạo của yêu cầu. Nhiễu điều kiện hóa được lấy từ nó trước tiên, một lần lấy cho mỗi điều kiện, trước khi lấy nhiễu của các hàng được tạo ra. latents (`Tensor`): Nhiễu video được tạo trước có hình dạng `(1, 24, num_latent_frames, latent_height, latent_width)`, được sử dụng thay cho lần lấy. audio_latents (`Tensor`): Nhiễu audio được tạo trước có hình dạng `(2, 32, num_audio_latents)`. **denoiser_input_fields (`None`, *tùy chọn*): Mô tả cấu trúc của chuỗi đóng gói mà transformer đọc theo tên: `token_tags`, `position_ids` và ba tensor chỉ số hàng. attention_kwargs (`dict`, *tùy chọn*): Các kwargs bổ sung cho các bộ xử lý attention. keyframe_anchors (`tuple`, *tùy chọn*, mặc định là ()): Đầu nào của video mà mỗi khung hình chính được neo vào, theo thứ tự đóng gói. output_type (`str`, *tùy chọn*, mặc định là pil): Định dạng đầu ra: 'pil', 'np' hoặc 'pt'. Outputs: videos (`list`): Video được tạo. audio (`Tensor`): Bản nhạc nền được tạo, có hình dạng `(1, 2, num_samples)`. sampling_rate (`int`): Tốc độ lấy mẫu của bản nhạc nền được tạo, tính bằng 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]) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L83) **Tham số:** image (`PIL.Image.Image`, `np.ndarray` hoặc `torch.Tensor`) : Ảnh tham chiếu: một ảnh, một mảng `(height, width, 3)` hoặc một tensor `(3, height, width)`, `uint8` hoặc số thực trong khoảng `[0, 1]`. Nó không bao giờ ràng buộc hình học được tạo ra — nó được mã hóa ở cạnh ngắn của chính nó, 2048 đối với checkpoint đã phát hành, bất kể canvas mà yêu cầu tạo ra là gì. Tham chiếu chủ thể, phong cách hoặc cảnh: tối đa 9 tham chiếu mỗi yêu cầu. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference.from_file]] ```python from_file(media) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L99) **Tham số:** media (`str` hoặc `os.PathLike`) : Đường dẫn hoặc URL của hình ảnh. Tải tệp ảnh vào `PikaH3FlexImageReference`, thông qua [load_image()](/docs/diffusers/main/vi/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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L111) **Tham số:** frames (`list[PIL.Image.Image]`, `np.ndarray` hoặc `torch.Tensor`) : Các khung tham chiếu: một danh sách các hình ảnh, một mảng `(num_frames, height, width, 3)` hoặc một tensor `(num_frames, 3, height, width)`, `uint8` hoặc số dấu phẩy động trong khoảng `[0, 1]`. fps (`float`, *optional*, mặc định là 24.0) : Tốc độ khung hình mà `frames` mang theo, đây là yếu tố quyết định việc đặt các khối thị giác của tham chiếu lên lưới 2 fps của bộ điều kiện. Đồng hồ riêng của MiniMax-H3 là 24 fps, do đó bất kỳ tốc độ nào khác đều được lấy mẫu lại lên tốc độ này bằng cách loại bỏ và nhân bản toàn bộ các khung hình — điều này khiến trường này trở thành nơi cần thiết lập chính xác khi các khung hình được lấy từ một tệp. audio (`torch.Tensor` có shape `(channels, num_samples)`, *optional*) : Bản nhạc nền của video này, mono hoặc stereo, được điều kiện như chính âm thanh của tham chiếu chứ không phải như một tham chiếu của chính nó. Nếu bỏ qua, tham chiếu sẽ chỉ điều kiện dựa trên chuyển động. sample_rate (`int`, *optional*) : Tốc độ mà `audio` mang các mẫu của nó. Nếu bỏ trống, tốc độ sẽ là tốc độ riêng của VAE âm thanh, giữ nguyên các mẫu; bất kỳ tốc độ nào khác sẽ được lấy mẫu lại lên tốc độ đó. Tham chiếu chuyển động và máy quay: tối đa 3 mỗi yêu cầu, được điều kiện cùng với bản nhạc nền riêng của nó. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference.from_file]] ```python from_file(media) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L147) **Tham số:** media (`str` hoặc `os.PathLike`) : Đường dẫn hoặc URL của video. **Trả về:** `PikaH3FlexVideoReference` các khung hình `(num_frames, height, width, 3)` `uint8` với tốc độ khung hình mà container báo cáo, kèm theo âm thanh của nó và tốc độ lấy mẫu của âm thanh đó khi có luồng âm thanh. Giải mã tệp video thành `PikaH3FlexVideoReference`, với độ phân giải, tốc độ khung hình và âm thanh đi kèm. Các tỷ lệ được đặt lên reference, đây chính là mục đích của việc giải mã theo cách này thay vì dùng [load_video()](/docs/diffusers/main/vi/api/utilities#diffusers.utils.load_video): MiniMax-H3 sẽ lấy lại mẫu reference lên 24 fps của chính nó, do đó tỷ lệ khung hình bị mất trong quá trình đưa vào sẽ là một yêu cầu được điều kiện ở tốc độ sai, và không có gì để cảnh báo về điều đó. Một container có metadata sai sẽ được sửa bằng cách ghi đè `fps` hoặc `sample_rate` trên reference được trả về. Cần [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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L174) **Tham số:** audio (`torch.Tensor` có hình dạng `(channels, num_samples)`) : Dạng sóng tham chiếu, đơn âm hoặc stereo. sample_rate (`int`, *optional*) : Tốc độ mà `audio` mang các mẫu của nó. Nếu bỏ trống, tốc độ sẽ là tốc độ riêng của VAE âm thanh, giữ nguyên các mẫu; bất kỳ tốc độ nào khác sẽ được lấy mẫu lại lên tốc độ đó. Tham chiếu giọng nói hoặc nhạc: tối đa 3 tham chiếu mỗi yêu cầu, và không bao giờ đứng một mình — một tham chiếu âm thanh phải được ghép với ít nhất một tham chiếu hình ảnh hoặc video. Tham chiếu này không bao giờ đến bộ điều kiện (conditioner) và chỉ được mã hóa bởi VAE âm thanh. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference.from_file]] ```python from_file(media) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L193) **Tham số:** media (`str` hoặc `os.PathLike`) : Đường dẫn hoặc URL của tệp âm thanh, hoặc của tệp video mà bản nhạc nền sẽ được lấy từ đó. **Trả về:** `PikaH3FlexAudioReference` waveform float32 có kích thước `(channels, num_samples)` ở tốc độ lấy mẫu mà container báo cáo. Giải mã tệp âm thanh thành `PikaH3FlexAudioReference`, ở tốc độ lấy mẫu mà tệp mang theo. Cần [PyAV](https://github.com/PyAV-Org/PyAV).