# MiniMax-H3

  
    
  

MiniMax-H3, videoyu ve ses kaydını birlikte üretir. Tek bir transformer, metin koşullandırmasını, koşullandırma ortamlarını ve hedef video ile ses latentlerini içeren tek bir paketlenmiş diziyi gürültüden arındırır. Ayrı bir vokoder veya ses için sonradan işleme adımı yoktur: video ve ses, aynı gürültüden arındırma döngüsünden çıkar.

Orijinal MiniMax-H3 checkpoint'lerini [MiniMaxAI](https://huggingface.co/MiniMaxAI) kuruluşu altında bulabilirsiniz.

MiniMax-H3 yalnızca [Modular Diffusers](../../modular_diffusers/overview) blokları olarak entegre edilmiştir, tıpkı [Anima](./anima)'nın entegre edildiği gibi: bloklar ve [MiniMaxH3ModularPipeline](/docs/diffusers/main/tr/api/pipelines/minimax_h3#diffusers.MiniMaxH3ModularPipeline) tüm entegrasyonu oluşturur ve `DiffusionPipeline` tarafı yoktur.

## Kontrol noktası düzeni

MiniMax-H3, transformer dışında tüm bileşenleri paylaşan iki checkpoint bölümü olarak yayınlandığından, diffusers dönüşümü ikisini de **tek bir repoda** birleştirir:

| Alt klasör | İş Akışları |
|---|---|
| `transformer/` | `t2va` (yalnızca metin), `fl2va` (ilk ve/veya son ana kare) |
| `transformer_ref/` | `ref2va` (görsel, video ve ses referanslarının sıralı karışımı) |

Transformer hariç her şey, yani video VAE, ses VAE, Qwen3-VL conditioner, onun tokenizer ve processor'ı ile iki scheduler, paylaşımlıdır ve bir kez saklanır.

Koşullandırıcı bir `Qwen3VLForConditionalGeneration`'dir ve MiniMax-H3, son katman yerine 50. decoder katmanından sonraki *normalize edilmemiş* gizli durumu okuduğu için, dil modeli başlığı kullanılmadan tam olarak yayınlanan checkpoint kullanılır.

Üç görevin tamamı [MiniMaxH3Blocks](/docs/diffusers/main/tr/api/pipelines/minimax_h3#diffusers.MiniMaxH3Blocks) tek birinin iş akışlarıdır ve depo, her bileşeni kendi yükleme özelliğiyle adlandıran tek bir `modular_model_index.json` içerir. Tek bir görevi sunmak için iş akışını `from_pretrained` parametresi olarak iletin: yalnızca o iş akışının bloklarını korur, bu nedenle hattın imzası (`pipe.doc`) tam olarak o görevin girdilerini belgelemekte, yalnızca o görevin bileşenleri tanımlanmakta ve `load_components` tam olarak alt klasörlerini getirmektedir — bir `t2va` / `fl2va` hattı asla `transformer_ref/` ile etkileşime girmez, bir `ref2va` hattı ise asla `transformer/` ile etkileşime girmez.

```py
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", workflow="ref2va")
pipe.load_components(dtype=torch.bfloat16)
```

> [!TIP]
> `pipe.doc`, önünüzdeki hattın neyi aldığını ve neyi döndürdüğünü gösterir: varsayılanlarıyla birlikte her girdi, beklediği bileşenler ve ürettiği çıktılar. Tek bir iş akışına indirgenmiş haliyle tam olarak o görevi açıklar; bu da bir istek yapmadan önce o isteğin ne gerektirdiğini görmenin en hızlı yoludur.

Tüm iş akışlarının tek bir pipeline üzerinde kullanılabilir kalmasını sağlamak için `workflow` argümanını dışarıda bırakın: pipeline, bu durumda her çağrıda kendisine iletilen girdilerden iş akışını seçer.

```py
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
```

*Yükleme* işlemi yine tek tek iş akışı olarak gerçekleştirilebilir. Bu çağrı, hem `t2va` hem de `fl2va` için kullanılan `transformer/` bileşenini ve tüm paylaşılan bileşenleri getirir:

```py
pipe.load_components(workflow="t2va", dtype=torch.bfloat16)
```

A plain `load_components()` with no `workflow=` pulls **both** 61.7GB transformer partitions, which is what lets one pipeline serve all three workflows without another loading call. Pair it with a [ComponentsManager](/docs/diffusers/main/tr/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) and auto offloading: the weights live in host RAM and the manager moves onto the accelerator just what each step needs, so when the `ref2va` denoiser wants the device the strategy offloads whatever frees enough room. See [Memory](#memory) for the recipes.

## İki zamanlayıcı

Video ve ses latentleri, her adımda tek bir transformer çağrısı içinde iki farklı zaman çizelgesi üzerinden ilerler; bu nedenle bloklar iki [MiniMaxH3Scheduler](/docs/diffusers/main/tr/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) örneği bekler: video latentleri için `scheduler` (yayınlanan checkpoint'lerde `shift=12.0`) ve ses latentleri için `audio_scheduler` (`shift=3.0`).

Her iki transformer bölümü de rehberlik damıtması (guidance-distilled) yapılmıştır, bu nedenle bu durum her iş akışı için geçerlidir: rehberlik ağırlıklara gömülüdür, bir rehber (guider) yoktur, `negative_prompt` ve `guidance_scale` yoktur ve her adım tam olarak bir ileri geçiş (forward pass) çalıştırır.

## Üretim kısıtlamaları

- **24 fps, 5 ila 15 saniye.** `num_frames`, video VAE'nin çözebileceği bir sonraki `17 * n + 5` değerine yuvarlanır ve elde edilen süre bu aralıkta kalmalıdır.
- **768 piksel kısa kenar.** `height` ve `width` varsayılan olarak MiniMax-H3'ün kendi tuvalini kullanır; bu, ilk anahtar karein en-boy oranına (veya anahtar kare yoksa 16:9'a) göre belirlenir ve 32'nin katları olmalıdır.
- **Bir üreteç, üç çekim.** Bir istek, önce anahtar kare veya referans koşullandırma gürültüsünü, ardından video gürültüsünü, ardından da ses gürültüsünü, kendisine geçirilen `generator` üzerinden çeker; böylece aynı üreteç durumundan yapılan iki çalıştırma aynı videoyu ve ses kaydını döndürür. `latents` veya `audio_latents` geçirildiğinde, ilgili çekim değiştirilir.
- **`num_inference_steps` counts sigma grid points**, the terminal `0` included, so it drives one model evaluation less.

## Bellek

Dönüştürücü tek başına bfloat16'da 61,7 GB, Qwen3-VL koşullandırıcısı ise 62,1 GB olduğundan, yükleme yöntemi donanıma bağlıdır. Her yapılandırmada en büyük hız kaldıracı daha küçük tuval boyutlarıdır: `height` ve `width` değerlerinin yalnızca 32'nin katları olması yeterlidir ve 960x544, eğitimde kullanılan 1344x768'e kıyasla adım başına yaklaşık 2,3 kat daha hızlı çalışır.

Tek bir 80 GB kart üzerinde, bileşenleri [ComponentsManager](/docs/diffusers/main/tr/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) içinde kaydedin ve onları hızlandırıcıya taşımasını sağlayın:

```py
import torch
from diffusers import ComponentsManager, ModularPipeline

manager = ComponentsManager()
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
pipe.load_components(workflow="t2va", dtype=torch.bfloat16)
manager.enable_auto_cpu_offload(device="cuda", memory_reserve_margin="12GB")  # or "mps", "xpu", "cpu"
pipe.transformer.set_attention_backend("_flash_3_hub")  # Hopper, roughly 3x faster; kernels fetched from the Hub
```

Bir tüketici kartında (24 ila 32 GB), iki büyük bileşeni yükleme sırasında int8 olarak kuantize edin ve transformer bloklarını CPU RAM'den akış olarak işleyin. Aşağıdaki her şey yalnızca desteklenen yükleyicileri kullanır, yama gerektirmez ve bfloat16 checkpoint'ten doğrudan çalışır:

```py
import torch
from diffusers import MiniMaxH3Transformer3DModel, ModularPipeline, TorchAoConfig
from diffusers.hooks import apply_group_offloading
from transformers import Qwen3VLForConditionalGeneration
from transformers import TorchAoConfig as TransformersTorchAoConfig
from torchao.quantization import Int8WeightOnlyConfig

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
pipe.update_components(
    transformer=MiniMaxH3Transformer3DModel.from_pretrained(
        "MiniMaxAI/MiniMax-H3", subfolder="transformer", dtype=torch.bfloat16,
        quantization_config=TorchAoConfig(
            Int8WeightOnlyConfig(version=2),
            modules_to_not_convert=[
                "proj_in", "audio_proj_in", "context_embedder", "time_embedder", "time_proj",
                "token_refiner", "norm_out", "proj_out", "audio_proj_out",
            ],
        ),
        low_cpu_mem_usage=False,
    ),
    text_encoder=Qwen3VLForConditionalGeneration.from_pretrained(
        "MiniMaxAI/MiniMax-H3", subfolder="text_encoder", dtype=torch.bfloat16,
        quantization_config=TransformersTorchAoConfig(
            Int8WeightOnlyConfig(version=2),
            modules_to_not_convert=["model.visual", "model.language_model.embed_tokens", "model.language_model.norm", "lm_head"],
        ),
    ),
)
pipe.load_components(workflow="t2va", dtype=torch.bfloat16)

# version=2 int8 tensors are pinnable, which streamed offload needs, and freezing removes the one autograd
# path the quantized tensors cannot serve.
pipe.transformer.requires_grad_(False)
pipe.text_encoder.requires_grad_(False)

offload = dict(onload_device=torch.device("cuda"), offload_device=torch.device("cpu"), use_stream=True)
pipe.transformer.enable_group_offload(offload_type="block_level", num_blocks_per_group=1, **offload)
apply_group_offloading(pipe.text_encoder.model, offload_type="leaf_level", **offload)
pipe.vae.to("cuda")  # or "mps", "xpu", "cpu"
pipe.audio_vae.to("cuda")
```

12 ila 16 GB aralığında, video VAE grubunun da offload edilmiş olduğu (`offload_type="leaf_level"`, stream yok) ve 960x544 gibi küçük bir tuval kullanıldığında aynı yöntem işe yarar. Ağırlıkların host RAM’de barındırılmasını bekleyin: int8’de bunun yaklaşık 75 GB’ı tutar.

İki kartla hiçbir şeyin dışa aktarılmasına gerek yoktur: hattı ikiye bölün ve her yarısını kendi cihazına yerleştirin.

```py
import torch
from diffusers import ComponentsManager, ModularPipeline

workflow = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3").blocks.get_workflow("t2va")

text_manager = ComponentsManager()
text_manager.enable_auto_cpu_offload(device="cuda:1")
conditioner = workflow.sub_blocks.pop("text_encoder").init_pipeline(
    "MiniMaxAI/MiniMax-H3", components_manager=text_manager
)
conditioner.load_components(dtype=torch.bfloat16)

manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda:0")
rest = workflow.init_pipeline("MiniMaxAI/MiniMax-H3", components_manager=manager)
rest.load_components(dtype=torch.bfloat16)

prompt = "A red fox trotting through a snowy pine forest, snow crunching underfoot"
state = conditioner(prompt=prompt)
results = rest(
    state=state,
    num_frames=124,
    generator=torch.Generator().manual_seed(42),
    output=["videos", "audio", "sampling_rate"],
)
```

İki 80 GB kart bu şekilde tam bfloat16 çalıştırır: her yarısı kendi kartına sığdığı için, bir kez yerleştiğinde hiçbir şey host belleğine geri atılmaz. İki 48 GB kart, yukarıdaki int8 yükleme yöntemini her iki bileşende de uygulayarak aynı şeyi yapar.

## Metin ve anahtar kareler

[MiniMaxH3Blocks](/docs/diffusers/main/tr/api/pipelines/minimax_h3#diffusers.MiniMaxH3Blocks), metinden video ve ses üretimi ile anahtar kare koşullandırmasını kapsar. Bir anahtar kare, videonun başladığı kare (`image`), bittiği kare (`last_image`) veya her ikisi olabilir.

```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. See [Memory](#memory).
manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda")  # or "mps", "xpu", "cpu"

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
pipe.load_components(workflow="fl2va", dtype=torch.bfloat16)

prompt = "A red fox trotting through a snowy pine forest, snow crunching underfoot"
# `output=` returns exactly the named outputs instead of the whole pipeline state.
outputs = ["videos", "audio", "sampling_rate"]

# Text to video + audio.
results = pipe(prompt=prompt, num_frames=124, generator=torch.Generator().manual_seed(42), output=outputs)

# First frame (and optionally last frame) to video + audio. The canvas follows the first keyframe.
image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
)
results = pipe(prompt=prompt, image=image, num_frames=124, generator=torch.Generator().manual_seed(42), output=outputs)

encode_video(
    results["videos"][0],
    fps=24,
    output_path="minimax_h3_fl2va.mp4",
    audio=results["audio"][0],
    audio_sample_rate=results["sampling_rate"],
)
```

Video ve ses birlikte üretilir ve çağrıdan ayrı çıktılar olarak, `sampling_rate` ile birlikte ses kaydının taşıdığı `videos` ve `audio` olarak çıkar; bunların tek bir dosyada birleştirilmesi (muxing) çağrıya bırakılır, örneğin [encode_video()](/docs/diffusers/main/tr/api/utilities#diffusers.utils.encode_video) ile.

## Omni-references

`ref2va` iş akışı, sıralı bir referans listesine göre koşullanır: en fazla 9 görüntü, 3 video ve 3 ses kliği, toplamda 12 öğe. Sıra semantik niteliktedir. İfadelerdeki referansları etiketler (`"<Picture 1>"`, `"<Audio 1>"`, `"<Video 1>"`) ve paylaşılan ses/video döner saatini ilerletir; bu nedenle aynı referansların yeniden sıralanması farklı bir istek oluşturur.

Yukarıdaki anahtar karelerin aksine, referanslar üretilen geometriyi bağlamaz: kendi çözünürlüklerinde kodlanırlar ve hedef tuval varsayılan olarak MiniMax-H3'ün 16:9 oranına ayarlanır.

Her modalite için bir referans sınıfı vardır ve her biri, bellek içi medyayı ve medyanın taşıdığı hızı tutar:

| referans | medya | oranı bildirir |
| --- | --- | --- |
| [MiniMaxH3ImageReference](/docs/diffusers/main/tr/api/pipelines/minimax_h3#diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference) | `image` | — |
| [MiniMaxH3VideoReference](/docs/diffusers/main/tr/api/pipelines/minimax_h3#diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference) | `frames` ve kendi ses bandı için `audio` | `fps`, varsayılan olarak MiniMax-H3'ün 24.0 değeri, ve `sample_rate` |
| [MiniMaxH3AudioReference](/docs/diffusers/main/tr/api/pipelines/minimax_h3#diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference) | `audio` | `sample_rate`, varsayılan olarak ses VAE'sinin kendi |

Oranlar, her şeyin yeniden örneklenmesinin yapıldığı kaynaktır: kareler, tüm kareleri atarak ve çoğaltarak MiniMax-H3'ün kendi 24 fps'ine; bir dalga formu ise ses VAE'sinin örneklem oranına. MiniMax-H3'ün kendi oranlarındaki medya olduğu gibi akar, bu nedenle yalnızca başka bir oranda üretilen verinin bunu belirtmesi gerekir.

Referans iki yoldan biriyle oluşturulur: sınıfın `from_file` sınıf metodu ile bir medya dosyasından çözümlenerek ya da isteğin bellekte zaten tuttuğu medyadan doğrudan inşa edilerek — önceki bir neslin geri beslenmesi de bu şekilde gerçekleşir (bkz. [Bir nesil olarak referans](#a-generation-as-a-reference)).

Bloklar asla bir medya dosyası açmaz — bir yolu çözümlemek, kütüphanenin her yerinde olduğu gibi, çağıranın görevidir. Her referans sınıfı bunu `from_file` sınıf metodu aracılığıyla yapar; bu metot bir yol veya URL alır (video ve ses için [PyAV](https://github.com/PyAV-Org/PyAV) üzerinden) ve konteynerin bildirdiği oranları taşıyan bir referans döndürür — bir video, kare hızını ve ses kaydını da beraberinde getirir. Kare hızını düşüren [load_video()](/docs/diffusers/main/tr/api/utilities#diffusers.utils.load_video) yerine `from_file` tercih edin: gerçek hızı kaybolmuş karelere dayalı olarak oluşturulan bir referans, yanlış hızda koşullandırılır ve hiçbir hata yükseltilmez.

```py
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.modular_pipelines.minimax_h3 import (
    MiniMaxH3AudioReference,
    MiniMaxH3ImageReference,
    MiniMaxH3VideoReference,
)
from diffusers.utils import load_video
from diffusers.utils.export_utils import encode_video

# `ref2va` is a workflow of the one MiniMax-H3 pipeline; selecting it loads only the `transformer_ref/`
# checkpoint partition, and the manager moves each component on and off the accelerator in turn.
manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda")  # or "mps", "xpu", "cpu"

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", workflow="ref2va", components_manager=manager)
pipe.load_components(dtype=torch.bfloat16)

subject = MiniMaxH3ImageReference.from_file(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
)

# Decoding a file brings its rates along: the video its own frame rate and its soundtrack, the clip its sample rate.
results = pipe(
    prompt="The character speaks in time with the reference recording, natural lip movement",
    references=[
        subject,
        MiniMaxH3VideoReference.from_file(
            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4"
        ),
        MiniMaxH3AudioReference.from_file("voice.wav"),
    ],
    num_frames=124,
    output=["videos", "audio", "sampling_rate"],
)

# Frames a request already holds declare the rate they carry — `load_video` does not preserve it.
motion = load_video("motion_ref.mp4")
results = pipe(
    prompt="The subject walks toward camera, matching the reference video's shot rhythm",
    references=[subject, MiniMaxH3VideoReference(frames=motion, fps=30.0)],
    num_frames=124,
    output=["videos", "audio", "sampling_rate"],
)

encode_video(
    results["videos"][0],
    fps=24,
    output_path="minimax_h3_ref2va.mp4",
    audio=results["audio"][0],
    audio_sample_rate=results["sampling_rate"],
)
```

`num_frames`, `ref2va` için zorunludur. Referans ses kaydının tam olarak uzunluğunda bir video oluşturmak için bu değeri klipten hesaplayın — `round(samples / sample_rate * 24)` — ve video VAE'nin çözebileceği bir sonraki `17 * n + 5` değerine yuvarlanır; sonuçta elde edilen süre, MiniMax-H3'ün ürettiği 5 ile 15 saniye aralığında kalmalıdır.

### Referans olarak bir nesil

İş akışları tek bir boru hattını paylaştığı için, `t2va` üretimi doğrudan bir `ref2va` referansı olarak geri beslenebilir — ve bellek içi oluşturucu tam da bu devir için tasarlanmıştır. Üretilen medya zaten MiniMax-H3'ün kendi hızlarında olduğundan (kareler 24 fps, ses bandı ses VAE'sinin örneklem hızında), referans için hız argümanlarına gerek yoktur ve yolda kayıplı bir kapsayıcı üzerinden yeniden kodlama yapılmaz:

```py
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3VideoReference

manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda")  # or "mps", "xpu", "cpu"

# The full pipeline holds every workflow and picks one per call from the inputs. Loading without a
# `workflow=` brings both transformer partitions in one call, so the `ref2va` request that follows the
# `t2va` generation needs no further loading.
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
pipe.load_components(dtype=torch.bfloat16)

results = pipe(
    prompt="An astronaut hiking through the mountains, humming a tune",
    num_frames=124,
    output=["videos", "audio", "sampling_rate"],
)

reference = MiniMaxH3VideoReference(
    frames=results["videos"][0],
    audio=results["audio"][0],
    sample_rate=results["sampling_rate"],
)
results = pipe(
    prompt="The same astronaut now walks along a beach at sunset, humming the same tune",
    references=[reference],
    num_frames=124,
    output=["videos", "audio", "sampling_rate"],
)
```

## MiniMaxH3ModularPipeline[[diffusers.MiniMaxH3ModularPipeline]]

#### diffusers.MiniMaxH3ModularPipeline[[diffusers.MiniMaxH3ModularPipeline]]

```python
diffusers.MiniMaxH3ModularPipeline(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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_h3/modular_pipeline.py#L150)

MiniMax-H3 ile ortak video + ses üretimi için modüler bir ModularPipeline: `transformer/` kontrol noktası bölümüne karşı `t2va` (yalnızca metin) ve `fl2va` (ilk ve/veya son ana kare) iş akışları ile `transformer_ref/` bölümüne karşı `ref2va` (omni-referans) iş akışı. Tek bir depo her iki bölümü de barındırır ve bir iş akışı seçildiğinde yalnızca onun

kendi:

```py
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", workflow="ref2va")
```

MiniMax-H3, metin koşullandırma, anahtar kare koşullandırma latentleri, ses latentleri ve video latentlerini aynı anda barındıran **tek bir paketlenmiş diziyi** gürültüden arındırır; bu nedenle bloklar modalite başına tensörler yerine bir satır düzenini taşır ve pipeline, tek bir transformer çağrısı içinde adım atılan iki zamanlayıcıyı (`shift = 12.0` video için, `shift = 3.0` ses için) taşır.

Kontrol noktası rehberlik damıtmasıyla (guidance-distilled) oluşturulmuştur: rehberlik ağırlıklara gömülmüştür, bu nedenle bir rehber, `negative_prompt` veya `guidance_scale` yoktur ve her adım tam olarak bir ileri geçiş (forward pass) çalıştırır.

MiniMax-H3 yalnızca modülerdir: bu pipeline ve blokları entegrasyonun tamamını oluşturur, `DiffusionPipeline` tarafı yoktur. Bu modül, her bloğun dayandığı model bilgilerini taşır — config'den türetilen geometri özellikler olarak, tuval ve kare sayısı aritmetiği fonksiyonlar olarak — ve koşullandırma, kodlama ve gürültü sözleşmeleri blokların kendisinde yer alır.

```py
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
pipe.load_components(dtype=torch.bfloat16)
```

## MiniMaxH3Blocks[[diffusers.MiniMaxH3Blocks]]

#### diffusers.MiniMaxH3Blocks[[diffusers.MiniMaxH3Blocks]]

```python
diffusers.MiniMaxH3Blocks()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_h3/modular_blocks_minimax_h3.py#L659)

MiniMax-H3 ile ortak video + ses üretimi için Auto Modular pipeline blokları: `references` ve ana kare girdilerine göre seçilen `t2va` (yalnızca metin), `fl2va` (ilk ve/veya son ana kare) ve `ref2va` (omni-referans) iş akışları. `workflow=` verilmediğinde, bileşenlerin yüklenmesi **her iki** 61,7 GB'lık dönüştürücü bölümünü de çeker — görevin gerektirdiği kadarını yüklemek için birini belirtin.

Desteklenen iş akışları:
- `t2va`: `prompt` gerektirir
- `fl2va`: `prompt`, `image` veya `prompt`, `last_image` gerektirir
- `ref2va`: `prompt` ve `references` gerektirir

Bileşenler: 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`)

Yapılandırmalar: canvas_short_edge (varsayılan: 768) canvas_max_pixels (varsayılan: 1032192) reference_image_short_edge (varsayılan: 2048)

Inputs: references (`list`, *isteğe bağlı*): Koşullandırılacak referanslar, **modelin onları okuması gereken sırayla**: sıralama, prompt sunumunda onları etiketler ve paylaşımlı döner saat üzerinde yerleştirir, bu nedenle farklı bir sıra farklı bir istemektir. Her modallite için bir dataclass, hepsi bellek içi medya tutar — en fazla 9 adet `MiniMaxH3ImageReference`, kendi `fps` değerinde en fazla 3 adet `MiniMaxH3VideoReference` (kendi `audio` ses bandı da koşullandırılır) veya kendi `sample_rate` değerinde en fazla 3 adet `MiniMaxH3AudioReference` — toplamda en fazla 12 referans ve ses referansları tek başına olamaz. Bu bloklar asla bir medya dosyası açmaz: hızları da getiren her sınıfın `from_file` sınıf metoduyla çözümlenir. height (`int`, *isteğe bağlı*): Üretilen videonun piksel cinsinden yüksekliği, 32'nin katı. width (`int`, *isteğe bağlı*): Üretilen videonun piksel cinsinden genişliği, 32'nin katı. num_frames (`int`, *isteğe bağlı*): Sabit 24 fps'de üretilecek kare sayısı. Video VAE'nin çözebileceği bir sonraki `17 * n + 5` değerine yukarı yuvarlanır; sonuçta oluşan süre 5 ile 15 saniye arasında kalmalıdır. Referans ses bandı kadar uzun bir video üretmek için `round(samples / sample_rate * 24)` geçirin. image (`Image`, *isteğe bağlı*): Videonun başladığı anahtar kare. Hedef tuvale *uzatılır*, bu tuval varsayılan olarak kendi en-boy oranından türetilir. last_image (`Image`, *isteğe bağlı*): Videonun bittiği anahtar kare. Tek başına geçirilerek bir kareye *kadar* üretim yapılabilir. `image` ile birleştirildiğinde ikisinin takipçisidir ve tuvale kapak kırpma (cover-crop) uygulanır. prompt (`str`): Üretimi yönlendirmek için prompt, tek bir dize. normalized_references (`list`, *isteğe bağlı*): Kurulum adımı tarafından normalize edilen referanslar, paketlenmiş sırayla. keyframes (`list`, *isteğe bağlı*): Hedef tuvale yerleştirilen anahtar kareler, paketlenmiş sırayla. condition_latents (`list`, *isteğe bağlı*): Kodlanmış video koşullandırma latentleri, paketlenmiş sırayla her görüntü ve video referansı için bir adet. Şekilleri, her referans bloğunun geometrisinin geldiği yerdir. audio_condition_latents (`list`, *isteğe bağlı*): Kodlanmış ses koşullandırma satırları, paketlenmiş sırayla ses içeren her referans için bir adet. generator (`Generator`, *isteğe bağlı*): İstemin üreteci. Koşullandırma gürültüsü, üretilen satırların gürültüsünden önce, her koşul için bir çekimle ondan çekilir. latents (`Tensor`): `(1, 24, num_latent_frames, latent_height, latent_width)` şeklinde önceden üretilmiş video gürültüsü, çekim yerine kullanılır. audio_latents (`Tensor`): `(2, 32, num_audio_latents)` şeklinde önceden üretilmiş ses gürültüsü. num_inference_steps (`int`, *isteğe bağlı*, varsayılan 50): Gürültü azaltma adım sayısı. **denoiser_input_fields (`None`, *isteğe bağlı*): Transformer'ın adla okuduğu paketlenmiş dizinin yapısal tanımı: `token_tags`, `position_ids` ve üç satır-dizin tensörü. attention_kwargs (`dict`, *isteğe bağlı*): Dikkat işleyicileri için ek kwargs. keyframe_anchors (`tuple`, *isteğe bağlı*, varsayılan ()): Her anahtar karenin videonun hangi ucuna sabitlendiği, paketlenmiş sırayla. output_type (`str`, *isteğe bağlı*, varsayılan pil): Çıktı biçimi: 'pil', 'np' veya 'pt'.

Çıktılar: videos (`list`): Oluşturulan video. audio (`Tensor`): `(1, 2, num_samples)` biçiminde oluşturulan ses bandı. sampling_rate (`int`): Oluşturulan ses bandının Hz cinsinden örneklem hızı.

## MiniMaxH3ImageReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference]]

#### diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference]]

```python
diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor])
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_h3/references.py#L82)

**Parametreler:**

image (`PIL.Image.Image`, `np.ndarray` veya `torch.Tensor`) : Referans görüntü: bir görüntü, `(height, width, 3)` boyutunda bir dizi veya `(3, height, width)` boyutunda bir tensör, `uint8` veya `[0, 1]` aralığında kayan noktalı. Üretilen geometriye asla bağlanmaz; kendi kısa kenarında kodlanır, yayınlanan checkpoint için 2048, istek hangi tuvali üretirse üretsin.

Bir konu, stil veya sahne referansı: istek başına en fazla 9.

#### from_file[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference.from_file]]

```python
from_file(media)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_h3/references.py#L98)

**Parametreler:**

media (`str` veya `os.PathLike`) : Görselin yolu veya URL'si.

Bir görüntü dosyasını [load_image()](/docs/diffusers/main/tr/api/utilities#diffusers.utils.load_image) üzerinden `MiniMaxH3ImageReference` içine yükleyin.

## MiniMaxH3VideoReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference]]

#### diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference]]

```python
diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference(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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_h3/references.py#L110)

**Parametreler:**

frames (`list[PIL.Image.Image]`, `np.ndarray` veya `torch.Tensor`) : Referans kareleri: bir görüntü listesi, `(num_frames, height, width, 3)` boyutunda bir dizi veya `(num_frames, 3, height, width)` boyutunda bir tensör, `uint8` veya `[0, 1]` aralığında kayan noktalı sayı.

fps (`float`, *opsiyonel*, varsayılan 24.0) : `frames`'in taşıdığı kare hızı; referansın görme bloklarını conditioner'ın 2 fps ızgarasına yerleştiren değer budur. MiniMax-H3'ün kendi saati 24 fps olduğundan, başka herhangi bir hız, tüm kareleri atlayarak ve çoğaltarak bu hıza yeniden örneklenir — bu da kareler bir dosyadan geldiğinde doğru ayarlanacak alanı oluşturur.

audio (`torch.Tensor`, şekli `(channels, num_samples)`, *isteğe bağlı*) : Bu videonun ses bandı, mono veya stereo; kendi referansı olarak değil, referansın kendi ses bandı olarak koşullandırılır. Bu parametre verilmezse, referans yalnızca harekete göre koşullandırılır.

sample_rate (`int`, *isteğe bağlı*) : `audio`'nun örneklerini taşıdığı hız. Belirtilmezse, ses VAE'sinin kendi hızı kullanılır ve örnekler olduğu gibi bırakılır; başka bir hız belirtilirse örnekler bu hıza yeniden örneklenir.

Bir hareket ve kamera referansı: istek başına en fazla 3 adet, kendi ses efektleriyle birlikte koşullandırılır.

#### from_file[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference.from_file]]

```python
from_file(media)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_h3/references.py#L146)

**Parametreler:**

media (`str` veya `os.PathLike`) : Videoyun yolu veya URL'si.

**Dönüş:** `MiniMaxH3VideoReference`

Kapsayıcının bildirdiği kare hızında, ses akışı varsa kendi ses kaydını ve o ses kaydının örnek hızını taşıyan `(num_frames, height, width, 3)` `uint8` kareler.

Bir video dosyasını, çözünürlüğünde, kare hızında ve taşıdığı ses kaydında `MiniMaxH3VideoReference` olarak çözümlen.

Oranlar referansa yerleşir; bu, [load_video()](/docs/diffusers/main/tr/api/utilities#diffusers.utils.load_video) yerine bu şekilde çözümleme yapmanın amacıdır: MiniMax-H3, referansı kendi 24 fps'ine yeniden örnekler, bu yüzden giriş sırasında kaybedilen bir kare hızı, yanlış hızda koşullandırılmış bir istek anlamına gelir ve bunu bildirecek hiçbir şey yoktur. Meta verileri hatalı olan bir kapsayıcı, döndürülen referans üzerinde `fps` veya `sample_rate` değerlerini geçersiz kılarak düzeltilir.

[PyAV](https://github.com/PyAV-Org/PyAV) gerektirir.

## MiniMaxH3AudioReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference]]

#### diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference]]

```python
diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference(audio: Tensor, sample_rate: int | None = None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_h3/references.py#L172)

**Parametreler:**

audio (`torch.Tensor`, şekli `(channels, num_samples)`) : Referans dalga formu, mono veya stereo.

sample_rate (`int`, *isteğe bağlı*) : `audio`'nun örneklerini taşıdığı hız. Belirtilmezse, ses VAE'sinin kendi hızı kullanılır ve örnekler olduğu gibi bırakılır; başka bir hız belirtilirse örnekler bu hıza yeniden örneklenir.

Ses veya müzik referansı: istek başına en fazla 3 adet ve asla yalnız başına değil — bir ses referansı, en az bir görsel veya video referansı ile eşleştirilmelidir. Hiçbir zaman conditioner'a ulaşmaz ve yalnızca ses VAE tarafından kodlanır.

#### from_file[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference.from_file]]

```python
from_file(media)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_h3/references.py#L191)

**Parametreler:**

media (`str` veya `os.PathLike`) : Sesin veya ses bandı alınacak videonun yolu veya URL'si.

**Dönüş:** `MiniMaxH3AudioReference`

kap konteynerinin bildirdiği örnek hızında `(channels, num_samples)` boyutlu float32 dalga formu.

Bir ses dosyasını, taşıdığı örneklem hızında `MiniMaxH3AudioReference` olarak çözümlen.

[PyAV](https://github.com/PyAV-Org/PyAV) gerektirir.