# Pika H3 Flex [Pika H3 Flex](https://huggingface.co/Pika-Labs/Pika-H3-Flex) es el post-entrenamiento de [MiniMax-H3](./minimax_h3) realizado por Pika, que lo convierte en un generador de video y audio de seis pasos. Mantiene la secuencia empaquetada de MiniMax-H3, su condicionador Qwen3-VL y sus dos VAE, y modifica dos aspectos: el muestreador, un programa fijo de seis pasos que re-ruidifica la predicción limpia en cada paso en lugar de la actualización de Euler, y los pesos, un par de adaptadores LoRA de rango 128 sobre las dos particiones del transformer de MiniMax-H3. El video y su banda sonora estéreo sincronizada se generan a partir de las mismas seis pasadas hacia adelante. La liberación son los adaptadores: el adaptador FL2VA (`fl2va/adapter.safetensors`) controla la partición `transformer/` para el condicionamiento de texto y de fotogramas de extremo, y el adaptador Ref2VA (`ref2va/adapter.safetensors`) controla `transformer_ref/` para referencias multimodales. Los componentes base son de [MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3), sin cambios, y el repositorio incluye una copia de ellos para que pueda cargarse de forma independiente. Pika H3 Flex se integra únicamente como bloques de [Modular Diffusers](../../modular_diffusers/overview), al igual que MiniMax-H3: los bloques y su [PikaH3FlexModularPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline) constituyen toda la integración, y no existe una mitad de `DiffusionPipeline`. ## Cargando Un pipeline se ensambla en dos pasos: los componentes se cargan a través de un `modular_model_index.json` que nombra los componentes base de MiniMax-H3 y las dos configuraciones de programador, y luego se carga encima el adaptador del flujo de trabajo seleccionado con [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights). Los adaptadores son volcados PEFT planos de los nombres de módulos de diffusers y se cargan en su escala de entrenamiento (`alpha == rank`, 1.0). | Flujo de trabajo | Entradas | Partición de Transformer | Adapter | |---|---|---|---| | `t2va` | `prompt` | `transformer/` | `fl2va/adapter.safetensors` | | `fl2va` | `prompt` y `image` y/o `last_image` | `transformer/` | `fl2va/adapter.safetensors` | | `ref2va` | `prompt` y `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") ``` Al pasar el workflow, se recortan los bloques a esa tarea, de modo que solo se recupera su propia partición del transformer, el adaptador enruta a la única partición presente y el pipeline acepta únicamente las solicitudes de esa tarea: un pipeline `fl2va` necesita un fotograma clave, mientras que uno `t2va` no toma ninguno. Un pipeline que mantiene ambas particiones (cargado sin `workflow=`) debe indicarse dónde va el adaptador Ref2VA: `pipe.load_lora_weights(..., weight_name="ref2va/adapter.safetensors", load_into_transformer_ref=True)`. Los dos VAE se liberan en float32 y decodifican en float32, tal como lo hace el paquete liberado; todo lo demás se ejecuta en bfloat16. > [!TIP] > `pipe.doc` muestra lo que toma y devuelve el pipeline que tienes delante: cada entrada con su valor predeterminado, los componentes que espera y las salidas que produce. ### Reutilizar un MiniMax-H3 cargado Los componentes base son los de MiniMax-H3, por lo que un pipeline de MiniMax-H3 que ya esté cargado contiene todo excepto los dos programadores y los adaptadores. Esta sección ensambla un pipeline de Pika H3 Flex a partir de esos componentes cargados y mantiene ambos pipelines listos en paralelo: un [ComponentsManager](/docs/diffusers/v0.43.0/es/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) mantiene cada componente una sola vez y lo descarga para ambos, el pipeline de Pika H3 Flex solo añade sus dos programadores, y los adaptadores deciden sobre cuál de los dos modelos se ejecutan los transformers compartidos. ```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)` muestra el resultado: cada componente compartido se lista una vez y pertenece a ambas colecciones, la colección Pika H3 Flex añade sus dos programadores y los dos transformers llevan un adaptador. ```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'] ``` Los adaptadores deciden qué modelo son los transformers compartidos. Para volver a MiniMax-H3, llama a `pika.disable_lora()`, y eso es todo: la siguiente solicitud de `minimax(...)` ejecuta el modelo base. `pika.enable_lora()` vuelve a activar Pika H3 Flex. No se recarga nada en el proceso; el gestor mueve cada componente sobre y fuera del acelerador a medida que cada pipeline lo alcanza. ## En qué se diferencia de MiniMax-H3 - **Seis pasos, sin `num_inference_steps`.** Ambas instancias de [MiniMaxH3Scheduler](/docs/diffusers/v0.43.0/es/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) (`shift=12.0` para video, `shift=3.0` para audio) se ejecutan con `stochastic_sampling` sobre la configuración `denoising_step_list` del pipeline, el programa publicado `[1000, 750, 500, 250, 100, 40, 0]`: cada paso predice la muestra limpia y todos, excepto el último, la ruidifican de nuevo con ruido fresco hasta el siguiente sigma. El número de pasos es el contrato del adaptador y no es una entrada. - **Ruido nuevo en cada paso.** Una solicitud extrae de su `generator` en un orden fijo: una extracción por fotograma clave o referencia visual para el ruido de condicionamiento, el ruido del video, el ruido del audio y, a continuación, las extracciones de re-ruido del video y del audio de cada uno de los primeros cinco pasos. Pasar `latents` o `audio_latents` reemplaza las dos extracciones iniciales y deja el resto en su lugar. - **Los fotogramas clave se recortan, no se estiran.** Un fotograma clave de `fl2va` se recorta desde el centro a la relación de aspecto del lienzo en su propia resolución y se redimensiona sobre el lienzo. - **Las referencias siguen el nivel de resolución del lienzo.** Pika H3 Flex genera en una tabla de cubos: un nivel de 480p y un nivel de 768p, con once relaciones de aspecto cada uno — y una solicitud `ref2va` se condiciona según el nivel de su lienzo: una referencia de imagen se codifica con un lado corto de 1024 píxeles por debajo del nivel 768 y de 2048 a partir de ese nivel, y una referencia de video se ajusta a la regla de lienzo propia del nivel. Cada referencia de video o de audio independiente dura de 2 a 15 segundos, y la suma de las duraciones de video y la suma de las duraciones de audio independiente no superan los 15 segundos cada una. ## Generación Los buckets publicados son los lienzos en los que se validó Pika H3 Flex. Pasa uno como `height` y `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"], ) ``` El flujo de trabajo `ref2va` toma una lista ordenada de referencias — hasta 9 imágenes, 3 videos y 3 clips de audio, 12 en total — de la misma manera que lo hace MiniMax-H3, con una clase de referencia por modalidad. También es la solicitud que requiere más memoria: las referencias añaden sus propias filas a la secuencia, y a 768p el solo transformador llena una tarjeta de 80 GB. Por lo tanto, el ejemplo de abajo transmite los bloques del transformador desde la memoria de CPU uno a la vez, mientras que el gestor mueve los demás componentes sobre y fuera del dispositivo como antes. Ejecuta una solicitud de referencia a 768p en una tarjeta de 80 GB; sin el streaming, manténgase en 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/modular_pipeline.py#L211) Un ModularPipeline para la generación conjunta de video + audio con Pika H3 Flex, el MiniMax-H3 de seis pasos entrenado a posteriori: los flujos de trabajo `t2va` (solo texto) y `fl2va` (primer y/o último fotograma clave) frente a la partición del punto de control `transformer/` con el adaptador `fl2va`, y el flujo de trabajo `ref2va` (referencia omni) frente a `transformer_ref/` con el adaptador `ref2va`. Los componentes base son los de MiniMax-H3, y la versión Pika H3 Flex es un par de adaptadores LoRA de rango 128 sobre las dos particiones del transformer, por lo que un pipeline se ensambla en dos pasos: los componentes se cargan a través de un `modular_model_index.json` que nombra los componentes base y los dos schedulers, y el adaptador del workflow seleccionado se carga con [load_lora_weights()](/docs/diffusers/v0.43.0/es/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") ``` Al igual que MiniMax-H3, Pika H3 Flex desruidifica **una secuencia empaquetada** que contiene a la vez la condición de texto, los latentes de condición de fotograma clave o de referencia, los latentes de audio y los latentes de video, por lo que los bloques pasan un diseño de filas en lugar de tensores por modalidad, y por lo que el pipeline lleva dos programadores (`shift = 12.0` para video, `shift = 3.0` para audio) que se ejecutan dentro de una única llamada al transformer. A diferencia de MiniMax-H3, los dos programadores son instancias de [MiniMaxH3Scheduler](/docs/diffusers/v0.43.0/es/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) con `stochastic_sampling` sobre la lista fija de seis pasos `denoising_step_list`: no hay `num_inference_steps`, y cada paso extrae ruido nuevo del generador de la solicitud. Los adaptadores se destilan con guía, al igual que su base: no hay un guionista, no hay `negative_prompt` ni `guidance_scale`, y cada paso ejecuta exactamente una pasada hacia adelante. Este módulo contiene los datos del modelo en los que se basa cada bloque: la geometría derivada de la configuración como propiedades y la aritmética del lienzo, el nivel y el número de fotogramas como funciones. Los contratos de condicionamiento, codificación y ruido residen en los propios bloques. ## PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]] #### diffusers.PikaH3FlexBlocks[[diffusers.PikaH3FlexBlocks]] ```python diffusers.PikaH3FlexBlocks() ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/modular_blocks_pika_h3_flex.py#L668) Bloques de pipeline Auto Modular para la generación conjunta de video y audio con Pika H3 Flex: los flujos de trabajo `t2va` (solo texto), `fl2va` (primer y/o último fotograma clave) y `ref2va` (referencia omni), seleccionados mediante las entradas de `references` y fotogramas clave. Los flujos de trabajo `t2va` y `fl2va` ejecutan la partición `transformer` con el adaptador `fl2va` y `ref2va` la partición `transformer_ref` con el adaptador `ref2va`, por lo que debe cargar el adaptador del flujo de trabajo que siga la solicitud. Sin un `workflow=`, la carga de los componentes extrae **ambas** particiones de transformer de 61,7 GB; pase uno para cargar solo lo que la tarea necesita. Flujos de trabajo admitidos: - `t2va`: requiere `prompt` - `fl2va`: requiere `prompt`, `image` o `prompt`, `last_image` - `ref2va`: requiere `prompt`, `references` Componentes: image_processor (`VaeImageProcessor`) text_encoder (`Qwen3VLForConditionalGeneration`) tokenizer (`Qwen2Tokenizer`) processor (`Qwen3VLProcessor`) vae (`AutoencoderKLMiniMaxH3`) audio_vae (`AutoencoderKLMiniMaxH3Audio`) scheduler (`MiniMaxH3Scheduler`) audio_scheduler (`MiniMaxH3Scheduler`) transformer_ref (`MiniMaxH3Transformer3DModel`) transformer (`MiniMaxH3Transformer3DModel`) video_processor (`VideoProcessor`) Configuraciones: canvas_short_edge (predeterminado: 768) canvas_max_pixels (predeterminado: 1032192) denoising_step_list (predeterminado: [1000, 750, 500, 250, 100, 40, 0]) Entradas: references (`list`, *opcional*): Las referencias sobre las que condicionar, **en el orden en que el modelo debe leerlas**: el orden las etiqueta en la presentación del prompt y las dispone en el reloj rotatorio compartido, por lo que un orden diferente es una solicitud diferente. Un dataclass por modalidad, todos conteniendo medios en memoria: un `PikaH3FlexImageReference` (máximo 9), un `PikaH3FlexVideoReference` en su propio `fps` (máximo 3, cuya banda sonora `audio` también se usa como condición), o un `PikaH3FlexAudioReference` en su propia `sample_rate` (máximo 3) — para un máximo de 12 referencias en total, y las referencias de audio no pueden ser las únicas. Cada referencia de video o de audio independiente dura de 2 a 15 segundos, y las duraciones de video y las duraciones de audio independiente suman cada una un máximo de 15 segundos. Estos bloques nunca abren un archivo de medios: decodifica con el classmethod `from_file` de cada clase, que trae las tasas junto. height (`int`, *opcional*): Altura del video generado en píxeles, un múltiplo de 32. width (`int`, *opcional*): Ancho del video generado en píxeles, un múltiplo de 32. num_frames (`int`, *opcional*): Número de fotogramas a generar, a 24 fps fijos: de 120 a 360, es decir, de 5 a 15 segundos, redondeado hacia arriba al siguiente `17 * n + 5` que el VAE de video puede decodificar. Para generar un video tan largo como una banda sonora de referencia, pasa `round(samples / sample_rate * 24)`. image (`Image`, *opcional*): Fotograma clave desde el que comienza el video. Se recorta por el centro a la relación de aspecto del lienzo y se redimensiona sobre él; el lienzo por defecto se deriva de su propia relación de aspecto. last_image (`Image`, *opcional*): Fotograma clave en el que termina el video. Se puede pasar por sí solo para generar *hasta* un fotograma. Se recorta por el centro a la relación de aspecto del lienzo y se redimensiona sobre él, como `image`. prompt (`str`): El prompt para guiar la generación, una sola cadena. normalized_references (`list`, *opcional*): Las referencias normalizadas por el paso de configuración, en orden empaquetado. keyframes (`list`, *opcional*): Los fotogramas clave colocados sobre el lienzo objetivo, en orden empaquetado. condition_latents (`list`, *opcional*): Los latentes de condicionamiento de video codificados, uno por cada referencia de imagen y video en orden empaquetado. Su forma es de donde proviene la geometría de cada bloque de referencia. audio_condition_latents (`list`, *opcional*): Las filas de condicionamiento de audio codificadas, una por cada referencia con audio en orden empaquetado. generator (`Generator`, *opcional*): El generador de la solicitud. El ruido de condicionamiento se extrae de él primero, una extracción por condición, antes del ruido de las filas generadas. latents (`Tensor`): Ruido de video pregenerado de forma `(1, 24, num_latent_frames, latent_height, latent_width)`, usado en lugar de la extracción. audio_latents (`Tensor`): Ruido de audio pregenerado de forma `(2, 32, num_audio_latents)`. **denoiser_input_fields (`None`, *opcional*): La descripción estructural de la secuencia empaquetada que el transformer lee por nombre: `token_tags`, `position_ids` y los tres tensores de índice de fila. attention_kwargs (`dict`, *opcional*): Kwargs adicionales para los procesadores de atención. keyframe_anchors (`tuple`, *opcional*, predeterminado a ()): A qué extremo del video está anclado cada fotograma clave, en orden empaquetado. output_type (`str`, *opcional*, predeterminado a pil): Formato de salida: 'pil', 'np' o 'pt'. Salidas: videos (`list`): El video generado. audio (`Tensor`): La banda sonora generada, de forma `(1, 2, num_samples)`. sampling_rate (`int`): Tasa de muestreo de la banda sonora generada en 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]) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L83) **Parámetros:** image (`PIL.Image.Image`, `np.ndarray` o `torch.Tensor`) : La imagen de referencia: una imagen, un array de `(height, width, 3)` o un tensor de `(3, height, width)`, `uint8` o de punto flotante en `[0, 1]`. Nunca vincula la geometría generada: se codifica en un lado corto propio, 2048 para el checkpoint publicado, independientemente del lienzo que genere la solicitud. Una referencia de sujeto, estilo o escena: como máximo 9 por solicitud. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexImageReference.from_file]] ```python from_file(media) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L99) **Parámetros:** media (`str` o `os.PathLike`) : Ruta o URL de la imagen. Cargue un archivo de imagen en un `PikaH3FlexImageReference`, a través de [load_image()](/docs/diffusers/v0.43.0/es/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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L111) **Parámetros:** frames (`list[PIL.Image.Image]`, `np.ndarray` o `torch.Tensor`) : Los fotogramas de referencia: una lista de imágenes, un array de `(num_frames, height, width, 3)` o un tensor de `(num_frames, 3, height, width)`, `uint8` o de punto flotante en `[0, 1]`. fps (`float`, *opcional*, valor predeterminado 24.0) : La tasa de fotogramas que lleva `frames`, que es lo que sitúa los bloques de visión de la referencia en la cuadrícula de 2 fps del condicionador. El propio reloj de MiniMax-H3 es de 24 fps, por lo que cualquier otra tasa se remuestrea sobre él descartando y duplicando fotogramas completos, lo que convierte este campo en el que debe ajustarse correctamente cuando los fotogramas provienen de un archivo. audio (`torch.Tensor` de forma `(channels, num_samples)`, *opcional*) : La banda sonora de este vídeo, mono o estéreo, condicionada como la propia de la referencia en lugar de como una referencia de sí misma. Si se omite, la referencia se condiciona únicamente en el movimiento. sample_rate (`int`, *opcional*) : La velocidad a la que `audio` transporta sus muestras. Si se omite, se utiliza la propia del VAE de audio, lo que deja las muestras sin cambios; cualquier otra velocidad se re-muestrea sobre ella. Referencia de movimiento y cámara: como máximo 3 por solicitud, condicionada conjuntamente con su propia banda sonora. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexVideoReference.from_file]] ```python from_file(media) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L147) **Parámetros:** media (`str` o `os.PathLike`) : Ruta o URL del video. **Devuelve:** `PikaH3FlexVideoReference` los fotogramas `(num_frames, height, width, 3)` `uint8` a la tasa de fotogramas que informa el contenedor, incluyendo su banda sonora y la propia tasa de muestreo de esa banda sonora cuando tiene un flujo de audio. Decodifica un archivo de video en un `PikaH3FlexVideoReference`, con la resolución, la tasa de fotogramas y la banda sonora que contiene. Las tasas se fijan en la referencia, que es el punto de decodificar de esta manera en lugar de con [load_video()](/docs/diffusers/v0.43.0/es/api/utilities#diffusers.utils.load_video): MiniMax-H3 re-muestrea una referencia a sus propios 24 fps, por lo que una tasa de fotogramas perdida en la entrada es una solicitud condicionada a la velocidad incorrecta, sin nada que lo señale. Un contenedor cuya metadatos son incorrectos se corrige sobrescribiendo `fps` o `sample_rate` en la referencia devuelta. Requiere [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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L174) **Parámetros:** audio (`torch.Tensor` de forma `(channels, num_samples)`) : La forma de onda de referencia, mono o estéreo. sample_rate (`int`, *opcional*) : La velocidad a la que `audio` transporta sus muestras. Si se omite, se utiliza la propia del VAE de audio, lo que deja las muestras sin cambios; cualquier otra velocidad se re-muestrea sobre ella. Referencia de voz o música: como máximo 3 por solicitud y nunca de forma aislada: una referencia de audio debe acompañarse de al menos una referencia de imagen o video. Nunca llega al conditioner y se codifica únicamente mediante el VAE de audio. #### from_file[[diffusers.modular_pipelines.pika_h3_flex.PikaH3FlexAudioReference.from_file]] ```python from_file(media) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pika_h3_flex/references.py#L193) **Parámetros:** media (`str` o `os.PathLike`) : Ruta o URL del audio, o de un video del que se toma la banda sonora. **Devuelve:** `PikaH3FlexAudioReference` la forma de onda float32 de `(channels, num_samples)` a la tasa de muestreo que informa el contenedor. Decodifica un archivo de audio en un `PikaH3FlexAudioReference`, a la tasa de muestreo que lleva. Requiere [PyAV](https://github.com/PyAV-Org/PyAV).