---
base_model:
- MiniMaxAI/MiniMax-H3
---
- Esta es la versión cuantizada del transformer y el text encoder para [MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3).
- La cuantización fue hecha en una GPU A100 con torchao v0.18.0.

## Un momentillo listillo pero cómo se usa este mamotreto.

Primero actualiza torchao
```shell
pip install --upgrade torchao
```

Desde luego el acelerador de descarga también que solo tenemos parte del modelo y falta otras componentes para realizar las inferencias.
```shell
pip install -q hf-transfer
```


Ahora viene un ejemplo para generar videos y comenzamos cargando lo necesario para crear el ducto de generación
```python
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.modular_pipelines.minimax_h3 import (
    MiniMaxH3AudioReference,
    MiniMaxH3ImageReference,
    MiniMaxH3VideoReference,
)
from diffusers import MiniMaxH3Transformer3DModel 
from transformers import Qwen3VLForConditionalGeneration
```

Después creamos el ducto
```python
manager = ComponentsManager()
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
```

Luego cargamos el `transformer`, la primera carga tomará unos 6 minutos a más en una GPU A100
```python
minimax_quant = "herb786/MinimaxH3-achece-int8"
transformer = MiniMaxH3Transformer3DModel.from_pretrained(minimax_quant, subfolder='transformer', dtype=torch.bfloat16, use_safetensors=False)
```

Luego cargamos el `text_encoder`, la primera carga tomará también 6 minutos a más en una GPU A100
```python
minimax_quant = "herb786/MinimaxH3-achece-int8"
text_encoder = Qwen3VLForConditionalGeneration.from_pretrained(minimax_quant, subfolder='text_encoder', dtype=torch.bfloat16)
```

Ahora transferimos estás componentes al ducto MinimaxH3. En este caso usare el modo `fl2va` porque usaré una imagen como referencia.
```python
pipe.update_components(transformer=transformer,text_encoder=text_encoder)
pipe.load_components(workflow="fl2va", dtype=torch.bfloat16)
manager.enable_auto_cpu_offload(device="cuda", memory_reserve_margin="12GB")
```

Pueder usar LoRA para acelerar la inferencia como por ejemplo [Minimax-h3-Turbo](https://huggingface.co/lightx2v/Minimax-h3-Turbo)
```python
lora_path = "/path_to/loras_minimax/"
turbo = "minimax_h3_fl2v_turbo_8step_v1.0_768p_bf16.safetensors"
pipe.load_lora_weights(lora_path,weight_name=turbo,adapter_name="turbo")
pipe.set_adapters("turbo", 1.0)
```

Ahora cargamos la imagen, y en este caso la visualizamos en jupyter
```python
from diffusers.utils import make_image_grid
from diffusers.utils import load_image
ref_image = load_image("wasteland_paradise.png")
display(make_image_grid([ref_image],rows=1,cols=1,resize=300))
```

Para generar el video realizamos la inferencia que tomará algo de 9 minutos a más en una GPU A100
```python
seed = torch.seed()
generator = torch.Generator().manual_seed(seed)
results = pipe(
    prompt="A lone man mounted on his weary donkey and his faithful hound wander in a pretty wasteland paradise. Atonal music plays in the background.",
    image=ref_image,
    #num_frames=124, #5 segundos
    num_frames=345, #15 segundos
    num_inference_steps=8, # con el lora de aceleración
    generator=generator,
    output=["videos", "audio", "sampling_rate"]
)
```

Ahora codificaremos los tensores en un formato general de video como mp4
```python
from diffusers.utils.export_utils import encode_video
encode_video(
    results["videos"][0],
    fps=24,
    output_path="mi-video-favorito.mp4",
    audio=results["audio"][0],
    audio_sample_rate=results["sampling_rate"],
)
```

Si eres un entusiasta del cine mudo
```python
encode_video(
    results["videos"][0],
    fps=24,
    output_path="mi-video-favorito.mp4"
)
```