# Pika H3 Flex [Pika H3 Flex](https://huggingface.co/Pika-Labs/Pika-H3-Flex) adalah hasil post-training Pika dari [MiniMax-H3](./minimax_h3) menjadi generator video dan audio enam langkah. Model ini mempertahankan packed sequence dari MiniMax-H3, conditioner Qwen3-VL-nya, dan kedua VAE-nya, serta mengubah dua hal: sampler, yaitu jadwal enam langkah tetap yang melakukan re-noising pada prediksi bersih di setiap langkah sebagai pengganti pembaruan Euler, dan bobot, yaitu sepasang adapter LoRA rank-128 di atas dua partisi transformer MiniMax-H3. Video beserta soundtrack stereo yang tersinkronisasi dihasilkan dari enam forward pass yang sama. Rilis ini adalah adapter: adapter FL2VA (`fl2va/adapter.safetensors`) menggerakkan partisi `transformer/` untuk kondisioning teks dan endpoint-frame, sedangkan adapter Ref2VA (`ref2va/adapter.safetensors`) menggerakkan `transformer_ref/` untuk referensi multimodal. Komponen dasarnya berasal dari [MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3), tanpa perubahan, dan repositori ini menyertakan salinannya agar dapat dimuat secara mandiri. Pika H3 Flex terintegrasi hanya sebagai blok [Modular Diffusers](../../modular_diffusers/overview), seperti MiniMax-H3: blok-blok tersebut beserta [PikaH3FlexModularPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline) merupakan keseluruhan integrasi, dan tidak ada bagian `DiffusionPipeline`. ## Memuat Sebuah pipeline dirakit dalam dua langkah: komponen dimuat melalui `modular_model_index.json` yang menyebutkan komponen dasar MiniMax-H3 dan dua konfigurasi scheduler, kemudian adapter dari workflow yang dipilih dimuat di atasnya dengan [load_lora_weights()](/docs/diffusers/v0.43.0/id/api/loaders/lora#diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights). Adapter tersebut adalah dump PEFT polos dari nama modul diffusers dan dimuat pada skala latihannya (`alpha == rank`, 1.0). | Alur Kerja | Input | Partisi Transformer | Adapter | |---|---|---|---| | `t2va` | `prompt` | `transformer/` | `fl2va/adapter.safetensors` | | `fl2va` | `prompt` dan `image` dan/atau `last_image` | `transformer/` | `fl2va/adapter.safetensors` | | `ref2va` | `prompt` dan `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") ``` Menyampaikan workflow memangkas blok ke tugas tersebut, sehingga hanya partisi transformer miliknya yang diambil, adapter mengarahkan ke satu partisi yang ada, dan pipeline menerima permintaan tugas tersebut saja — pipeline `fl2va` membutuhkan keyframe, sedangkan `t2va` tidak mengambil apa pun. Pipeline yang memegang kedua partisi (dimuat tanpa `workflow=`) perlu diberi tahu ke mana adapter Ref2VA harus pergi: `pipe.load_lora_weights(..., weight_name="ref2va/adapter.safetensors", load_into_transformer_ref=True)`. Kedua VAE dirilis dalam float32 dan didekode dalam float32, sebagaimana dilakukan oleh paket yang dirilis; semuanya lainnya berjalan dalam bfloat16. > [!TIP] > `pipe.doc` menampilkan apa yang diterima dan dikembalikan oleh pipeline di depan Anda — setiap input beserta nilai default-nya, komponen yang diharapkan, dan output yang dihasilkan. ### Memanfaatkan kembali MiniMax-H3 yang dimuat Komponen dasarnya adalah milik MiniMax-H3, sehingga pipeline MiniMax-H3 yang sudah dimuat menyimpan semua hal kecuali dua scheduler dan adapter. Bagian ini merangkai pipeline Pika H3 Flex dari komponen-komponen yang sudah dimuat tersebut dan menjaga kedua pipeline tetap siap berdampingan: satu [ComponentsManager](/docs/diffusers/v0.43.0/id/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) menyimpan setiap komponen sekali dan melakukan offload untuk keduanya, pipeline Pika H3 Flex hanya menambahkan dua scheduler-nya, dan adapter menentukan model mana dari dua model tersebut yang dijalankan oleh transformer bersama. ```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)` menampilkan hasilnya: setiap komponen bersama terdaftar sekali dan termasuk dalam kedua koleksi, koleksi Pika H3 Flex menambahkan dua penjadwalnya, dan kedua transformer membawa adapter. ```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'] ``` Adaptor menentukan model mana yang digunakan oleh transformer bersama. Untuk kembali ke MiniMax-H3, panggil `pika.disable_lora()`, dan itu saja: permintaan `minimax(...)` berikutnya akan menjalankan model dasar. `pika.enable_lora()` mengaktifkan kembali Pika H3 Flex. Tidak ada yang dimuat ulang di antaranya; manajer memindahkan setiap komponen ke dan dari akselerator saat salah satu pipeline mencapainya. ## Apa yang berbeda dari MiniMax-H3 - **Enam langkah, tanpa `num_inference_steps`.** Kedua instans [MiniMaxH3Scheduler](/docs/diffusers/v0.43.0/id/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) (`shift=12.0` untuk video, `shift=3.0` untuk audio) dijalankan dengan `stochastic_sampling` di atas konfigurasi `denoising_step_list` pipeline, yaitu jadwal yang dirilis `[1000, 750, 500, 250, 100, 40, 0]`: setiap langkah memprediksi sampel bersih, dan semua langkah kecuali yang terakhir menambahkan kembali noise baru ke sigma berikutnya. Jumlah langkah adalah kontrak adapter dan bukan merupakan input. - **Derah baru di setiap langkah.** Permintaan mengambil dari `generator` dalam urutan tetap: satu pengambilan per keyframe atau referensi visual untuk derah kondisioning, derah video, derah audio, dan kemudian pengambilan re-noising video dan audio dari masing-masing lima langkah pertama. Menyalurkan `latents` atau `audio_latents` menggantikan dua pengambilan awal dan membiarkan sisanya tetap ada. - **Keyframes dipotong (cropped), bukan diregangkan.** Keyframe `fl2va` dipotong di tengah sesuai rasio aspek kanvas pada resolusi aslinya, lalu di-resize ke kanvas. - **Referensi mengikuti tier resolusi kanvas.** Pika H3 Flex menghasilkan pada tabel bucket — tier 480p dan tier 768p, masing-masing dengan sebelas rasio aspek — dan permintaan `ref2va` dikondisikan berdasarkan tier kanvasnya: referensi gambar dikodekan pada sisi pendek 1024 piksel di bawah tier 768 dan 2048 dari tier tersebut ke atas, dan referensi video ditempatkan pada aturan kanvas tier itu sendiri. Setiap referensi video atau audio mandiri berjalan selama 2 hingga 15 detik, dan durasi video serta durasi audio mandiri masing-masing berjumlah maksimal 15 detik. ## Generasi Bucket yang dirilis adalah kanvas tempat Pika H3 Flex divalidasi. Gunakan salah satunya sebagai `height` dan `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` menerima daftar referensi yang terurut — hingga 9 gambar, 3 video, dan 3 klip audio, total 12 — dengan cara yang sama seperti MiniMax-H3, yaitu satu kelas referensi per modalitas. Ini juga merupakan permintaan yang membutuhkan memori paling banyak: referensi menambahkan baris mereka sendiri ke dalam urutan, dan pada resolusi 768p, transformer saja sudah memenuhi kartu 80 GB. Oleh karena itu, contoh di bawah ini melakukan streaming blok transformer dari memori CPU satu per satu, sementara manager memindahkan komponen lainnya ke perangkat dan keluar darinya seperti sebelumnya. Contoh ini menjalankan permintaan referensi 768p pada satu kartu 80 GB; tanpa streaming, batasi pada 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) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/modular_pipeline.py#L211) ModularPipeline untuk generasi video + audio bersama dengan Pika H3 Flex, MiniMax-H3 enam langkah yang telah dilatih ulang: alur kerja `t2va` (hanya teks) dan `fl2va` (keyframe pertama dan/atau terakhir) terhadap partisi checkpoint `transformer/` dengan adapter `fl2va`, serta alur kerja `ref2va` (omni-reference) terhadap `transformer_ref/` dengan adapter `ref2va`. Komponen dasarnya adalah milik MiniMax-H3, dan rilis Pika H3 Flex adalah sepasang adapter LoRA rank-128 di atas dua partisi transformer, sehingga pipeline dirakit dalam dua langkah: komponen dimuat melalui `modular_model_index.json` yang menyebutkan komponen dasar dan dua scheduler, dan adapter dari workflow yang dipilih dimuat dengan [load_lora_weights()](/docs/diffusers/v0.43.0/id/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") ``` Seperti MiniMax-H3, Pika H3 Flex melakukan denoising pada **satu sequence yang dikemas** yang sekaligus menyimpan kondisi teks, latens kondisi keyframe atau referensi, latens audio, dan latens video. Inilah mengapa blok-blok tersebut meneruskan tata letak baris (row layout) alih-alih tensor per-modalitas, dan mengapa pipeline membawa dua scheduler (`shift = 12.0` untuk video, `shift = 3.0` untuk audio) yang dijalankan di dalam satu panggilan transformer. Berbeda dengan MiniMax-H3, kedua scheduler tersebut adalah instance [MiniMaxH3Scheduler](/docs/diffusers/v0.43.0/id/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) dengan `stochastic_sampling` di atas `denoising_step_list` enam langkah yang tetap: tidak ada `num_inference_steps`, dan setiap langkah mengambil noise baru dari generator permintaan. Adaptor-adaptor ini di-distilasi dengan panduan, sama seperti basisnya: tidak ada guider, tidak ada `negative_prompt` dan tidak ada `guidance_scale`, dan setiap langkah menjalankan tepat satu forward pass. Modul ini membawa fakta model yang menjadi acuan setiap blok — geometri yang diturunkan dari config sebagai properti, serta aritmetika kanvas, tier, dan jumlah frame sebagai fungsi — sementara kontrak conditioning, encoding, dan noise berada langsung di blok-blok tersebut. ## PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]] #### diffusers.PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]] ```python diffusers.PikaH3FlexBlocks() ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/modular_blocks_pika_h3_flex.py#L668) Auto Modular pipeline blocks untuk generasi video + audio bersama dengan Pika H3 Flex: alur kerja `t2va` (teks saja), `fl2va` (keyframe pertama dan/atau terakhir), serta `ref2va` (omni-reference), yang dipilih berdasarkan input `references` dan keyframe. Alur kerja `t2va` dan `fl2va` menjalankan partisi `transformer` dengan adapter `fl2va`, sedangkan `ref2va` menjalankan partisi `transformer_ref` dengan adapter `ref2va`, sehingga muatlah adapter dari alur kerja yang diambil oleh permintaan tersebut. Tanpa `workflow=`, pemuatan komponen akan menarik **kedua** partisi transformer berukuran 61,7GB — berikan salah satunya agar hanya komponen yang dibutuhkan tugas yang dimuat. Alur kerja yang didukung: - `t2va`: membutuhkan `prompt` - `fl2va`: membutuhkan `prompt`, `image` atau `prompt`, `last_image` - `ref2va`: membutuhkan `prompt`, `references` Komponen: 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`) Konfigurasi: canvas_short_edge (default: 768) canvas_max_pixels (default: 1032192) denoising_step_list (default: [1000, 750, 500, 250, 100, 40, 0]) Inputs: references (`list`, *optional*): The references to condition on, **in the order the model should read them**: the order labels them in the prompt presentation and lays them out on the shared rotary clock, so a different order is a different request. One dataclass per modality, all holding in-memory media — a `PikaH3FlexImageReference` (at most 9), a `PikaH3FlexVideoReference` at its own `fps` (at most 3, whose `audio` soundtrack is conditioned on as well), or a `PikaH3FlexAudioReference` at its own `sample_rate` (at most 3) — for at most 12 references in total, and audio references cannot be the only ones. Every video or standalone audio reference runs 2 to 15 seconds, and the video durations and the standalone audio durations each sum to at most 15 seconds. These blocks never open a media file: decode with each class's `from_file` classmethod, which brings the rates along. height (`int`, *optional*): Height of the generated video in pixels, a multiple of 32. width (`int`, *optional*): Width of the generated video in pixels, a multiple of 32. num_frames (`int`, *optional*): Number of frames to generate, at the fixed 24 fps: 120 to 360, i.e. 5 to 15 seconds, snapped up to the next `17 * n + 5` the video VAE can decode. To generate a video as long as a reference soundtrack, pass `round(samples / sample_rate * 24)`. image (`Image`, *optional*): Keyframe the video starts from. It is center-cropped to the canvas' aspect ratio and resized onto it; the canvas by default is derived from its own aspect ratio. last_image (`Image`, *optional*): Keyframe the video ends on. Can be passed on its own to generate *up to* a frame. It is center-cropped to the canvas' aspect ratio and resized onto it, like `image`. prompt (`str`): The prompt to guide generation, a single string. normalized_references (`list`, *optional*): The references normalized by the setup step, in packed order. keyframes (`list`, *optional*): The keyframes put onto the target canvas, in packed order. condition_latents (`list`, *optional*): The encoded video conditioning latents, one per image and video reference in packed order. Their shape is where every reference block's geometry comes from. audio_condition_latents (`list`, *optional*): The encoded audio conditioning rows, one per audio-bearing reference in packed order. generator (`Generator`, *optional*): The generator of the request. The conditioning noise is drawn from it first, one draw per condition, before the noise of the generated rows. latents (`Tensor`): Pre-generated video noise of shape `(1, 24, num_latent_frames, latent_height, latent_width)`, used instead of the draw. audio_latents (`Tensor`): Pre-generated audio noise of shape `(2, 32, num_audio_latents)`. **denoiser_input_fields (`None`, *optional*): The structural description of the packed sequence the transformer reads by name: `token_tags`, `position_ids` and the three row-index tensors. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. keyframe_anchors (`tuple`, *optional*, defaults to ()): Which end of the video every keyframe is anchored to, in packed order. output_type (`str`, *optional*, defaults to pil): Output format: 'pil', 'np' or 'pt'. Output: video (`list`): Video yang dihasilkan. audio (`Tensor`): Soundtrack yang dihasilkan, dengan bentuk `(1, 2, num_samples)`. sampling_rate (`int`): Laju sampel soundtrack yang dihasilkan dalam 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]) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L83) **Parameter:** image (`PIL.Image.Image`, `np.ndarray` atau `torch.Tensor`) : Gambar referensi: sebuah gambar, array `(height, width, 3)` atau tensor `(3, height, width)`, `uint8` atau floating point pada `[0, 1]`. Gambar ini tidak pernah mengikat geometri yang dihasilkan — ia di-encode pada sisi pendeknya sendiri, 2048 untuk checkpoint yang dirilis, apa pun kanvas yang dihasilkan oleh permintaan. Referensi subjek, gaya, atau adegan: maksimal 9 per permintaan. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference.from_file]] ```python from_file(media) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L99) **Parameter:** media (`str` atau `os.PathLike`) : Path atau URL dari gambar. Muat file gambar ke dalam `PikaH3FlexImageReference`, melalui [load_image()](/docs/diffusers/v0.43.0/id/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) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L111) **Parameter:** frames (`list[PIL.Image.Image]`, `np.ndarray` atau `torch.Tensor`) : Bingkai referensi: daftar gambar, array `(num_frames, height, width, 3)` atau tensor `(num_frames, 3, height, width)`, `uint8` atau floating point di `[0, 1]`. fps (`float`, *opsional*, default 24.0) : Laju frame yang dibawa oleh `frames`, yang menentukan penempatan blok visual referensi pada grid 2 fps kondisioner. Jam internal MiniMax-H3 sendiri adalah 24 fps, sehingga laju lain akan disampel ulang ke laju tersebut dengan membuang dan menduplikasi frame utuh — hal ini menjadikan parameter ini yang harus diatur dengan benar jika frame berasal dari file. audio (`torch.Tensor` dengan bentuk `(channels, num_samples)`, *opsional*) : Soundtrack video ini, mono atau stereo, yang dikondisikan sebagai milik referensi itu sendiri, bukan sebagai referensi dari miliknya. Jika diabaikan, referensi hanya dikondisikan berdasarkan gerakan. sample_rate (`int`, *opsional*) : Laju di mana `audio` membawa sampelnya. Jika dibiarkan kosong, lajunya adalah laju bawaan VAE audio, yang membuat sampel tetap tidak berubah; laju lain akan di-resample ke laju tersebut. Referensi gerakan dan kamera: maksimal 3 per permintaan, dikondisikan bersama dengan soundtrack-nya sendiri. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference.from_file]] ```python from_file(media) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L147) **Parameter:** media (`str` atau `os.PathLike`) : Path atau URL dari video. **Mengembalikan:** `PikaH3FlexVideoReference` frame `(num_frames, height, width, 3)` `uint8` pada laju frame yang dilaporkan oleh kontainer, membawa soundtrack-nya dan laju sampel soundtrack tersebut ketika memiliki stream audio. Decode file video menjadi `PikaH3FlexVideoReference`, pada resolusi, frame rate, dan soundtrack yang dibawanya. Laju tersebut mendarat pada referensi, yang merupakan inti dari proses decoding dengan cara ini alih-alih menggunakan [load_video()](/docs/diffusers/v0.43.0/id/api/utilities#diffusers.utils.load_video): MiniMax-H3 melakukan resampling referensi ke 24 fps miliknya sendiri, sehingga laju frame yang hilang saat input adalah permintaan yang dikondisikan pada kecepatan yang salah, tanpa ada mekanisme untuk memperingatkannya. Kontainer yang metadatanya salah dikoreksi dengan menimpa `fps` atau `sample_rate` pada referensi yang dikembalikan. Memerlukan [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) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L174) **Parameter:** audio (`torch.Tensor` dengan bentuk `(channels, num_samples)`) : Gelombang referensi, mono atau stereo. sample_rate (`int`, *opsional*) : Laju di mana `audio` membawa sampelnya. Jika dibiarkan kosong, lajunya adalah laju bawaan VAE audio, yang membuat sampel tetap tidak berubah; laju lain akan di-resample ke laju tersebut. Referensi suara atau musik: maksimal 3 per permintaan, dan tidak boleh berdiri sendiri — referensi audio harus dipasangkan dengan setidaknya satu referensi gambar atau video. Referensi ini tidak pernah mencapai conditioner dan hanya dienkod oleh audio VAE. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference.from_file]] ```python from_file(media) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L193) **Parameter:** media (`str` atau `os.PathLike`) : Path atau URL dari audio, atau dari video yang soundtrack-nya diambil. **Mengembalikan:** `PikaH3FlexAudioReference` waveform float32 `(channels, num_samples)` pada laju sampel yang dilaporkan oleh kontainer. Decode file audio menjadi `PikaH3FlexAudioReference`, pada laju sampel yang dibawanya. Memerlukan [PyAV](https://github.com/PyAV-Org/PyAV).