# MiniMaxH3Scheduler

`MiniMaxH3Scheduler` adalah penjadwal Euler rectified-flow (`eta = 0`) dengan pergeseran sigma eksponensial yang digunakan oleh [MiniMax-H3](https://huggingface.co/MiniMaxAI), `sigma' = s * sigma / (1 + (s - 1) * sigma)`.

Pipeline MiniMax-H3 mendaftarkan **dua** di antaranya, karena latens video dan audio mengikuti dua jadwal yang berbeda di dalam satu panggilan transformer per langkah: `scheduler` membawa jadwal video (`shift=12.0` pada checkpoint yang dirilis) dan `audio_scheduler` membawa jadwal audio (`shift=3.0`).

## MiniMaxH3Scheduler[[diffusers.MiniMaxH3Scheduler]]

#### diffusers.MiniMaxH3Scheduler[[diffusers.MiniMaxH3Scheduler]]

```python
diffusers.MiniMaxH3Scheduler(shift: float = 12.0, stochastic_sampling: bool = False, shift_provided_sigmas: bool | None = None, euler_update_form: str = 'blend')
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_minimax_h3.py#L73)

**Parameter:**

shift (`float`, defaultnya `12.0`) : Pergeseran eksponensial yang diterapkan pada grid sigma, `sigma' = s*sigma / (1 + (s-1)*sigma)`. Checkpoint yang dirilis menggunakan `12.0` untuk latens video dan `3.0` untuk latens audio.

stochastic_sampling (`bool`, defaultnya `False`) : Ganti blend Euler dengan pembaruan re-noising: prediksi sampel bersih, lalu re-noise-kan ke sigma berikutnya dengan noise baru. Adapter Pika H3 Flex few-step dilatih untuk pembaruan ini; checkpoint dasar tidak.

shift_provided_sigmas (`bool`, *opsional*) : Apakah `sigmas` eksplisit yang diteruskan ke [set_timesteps()](/docs/diffusers/v0.43.0/id/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps) merupakan grid dasar yang digeser oleh scheduler, seperti grid `linspace` miliknya, atau jadwal yang sudah selesai dan diambil apa adanya. Jika tidak diset, berarti apa adanya dengan peringatan deprekasi; nilai default menjadi `True` di 0.44.0.

euler_update_form (`str`, defaultnya `"blend"`) : Cara pembaruan Euler dievaluasi. `"blend"` adalah campuran `x_t` / `x0` `x_next = r*x_t + (1 - r)*x0`; `"velocity"` adalah `x_next = x_t + (sigma - sigma_next) * v`, dalam float32. Keduanya merupakan pembaruan yang sama dan hanya berbeda dalam pembulatan float32; MiniMax-H3-Image didistilasi dengan bentuk velocity.

Penjadwal Euler rectified-flow (`eta = 0`) dengan pergeseran sigma eksponensial, seperti yang digunakan oleh MiniMax-H3.

#### index_for_timestep[[diffusers.MiniMaxH3Scheduler.index_for_timestep]]

```python
index_for_timestep(timestep: typing.Union[float, torch.Tensor])
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_minimax_h3.py#L225)

**Parameter:**

timestep (`float` atau `torch.Tensor`) : Nilai yang diambil dari `self.timesteps`. Jadwal ini meningkat secara ketat terhadap `t`, sehingga kecocokannya unik.

**Mengembalikan:** `int`

Indeks dari `timestep`.

Petakan nilai timestep ke indeksnya dalam jadwal.

#### scale_noise[[diffusers.MiniMaxH3Scheduler.scale_noise]]

```python
scale_noise(sample: FloatTensor, timestep: typing.Union[float, torch.FloatTensor], noise: FloatTensor)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_minimax_h3.py#L246)

**Parameter:**

sample (`torch.FloatTensor`) : Sampel bersih `x_0`.

timestep (`float` atau `torch.FloatTensor`) : Waktu target dalam `[0, 1]`; `1` mengembalikan `sample` tanpa perubahan.

noise (`torch.FloatTensor`) : Kebisingan yang akan dicampurkan.

**Mengembalikan:** `torch.FloatTensor`

Sampel yang diberi noise.

Proses maju rectified-flow, dalam konvensi `t` MiniMax-H3: `x_t = t*x_0 + (1 - t)*noise`.

MiniMax-H3 menggunakan ini untuk menambahkan noise pada anchor kondisionalnya, di mana `t` adalah level `noise_aug` dan bukan entri jadwal, sehingga `timestep` diambil apa adanya dan *tidak* dicari di `self.timesteps`.

#### set_begin_index[[diffusers.MiniMaxH3Scheduler.set_begin_index]]

```python
set_begin_index(begin_index: int = 0)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_minimax_h3.py#L138)

**Parameter:**

begin_index (`int`, defaultnya `0`) : Indeks awal untuk scheduler.

Menetapkan indeks awal untuk penjadwal.

#### set_shift[[diffusers.MiniMaxH3Scheduler.set_shift]]

```python
set_shift(shift: float)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_minimax_h3.py#L148)

**Parameter:**

shift (`float`) : Pergesaran eksponensial yang digunakan untuk jadwal berikutnya.

Menimpa pergeseran sigma yang dikonfigurasi; panggil sebelum [set_timesteps()](/docs/diffusers/v0.43.0/id/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps).

MiniMax-H3 mengekspos ini per permintaan sebagai `flow_shift` (video) / `audio_flow_shift` (audio).

#### set_timesteps[[diffusers.MiniMaxH3Scheduler.set_timesteps]]

```python
set_timesteps(num_inference_steps: int | None = None, device: typing.Union[str, torch.device, NoneType] = None, sigmas: typing.Union[list[float], torch.Tensor, NoneType] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_minimax_h3.py#L162)

**Parameter:**

num_inference_steps (`int`, *opsional*) : Jumlah titik grid sigma, termasuk `0` terminal. Diabaikan ketika `sigmas` diberikan.

device (`str` atau `torch.device`, *opsional*) : Perangkat tempat tensor jadwal dipindahkan. Grid itu sendiri selalu dibangun di CPU dalam float32 sehingga jadwal tidak bergantung pada akselerator.

sigmas (`list[float]` atau `torch.Tensor`, *opsional*) : Grid eksplisit, menurun secara ketat dan berakhir di `0.0`. Dengan `shift_provided_sigmas=True`, ini adalah grid dasar dalam `[0, 1]` yang melewati shift seperti grid `linspace`; selain itu, grid ini digunakan apa adanya (default yang tidak lagi didukung).

Bangun jadwal sigma / timestep.

Grid adalah `linspace(1, 0, num_inference_steps)` yang diproses melalui pergeseran eksponensial, dengan duplikat berurutan yang digabungkan, atau `sigmas` eksplisit, yang juga digeser ketika `shift_provided_sigmas` disetel. Terminal `0` sudah menjadi bagian dari grid — pergeseran memetakan `0` tepat ke `0` — sehingga jadwal mempertahankan `num_inference_steps` sigmas dan menggerakkan `num_inference_steps - 1` evaluasi model, yang diekspos sebagai `self.timesteps = 1 - sigmas[:-1]`.

#### langkah[[diffusers.MiniMaxH3Scheduler.step]]

```python
step(model_output: FloatTensor, timestep: typing.Union[float, torch.FloatTensor], sample: FloatTensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_minimax_h3.py#L278)

**Parameter:**

model_output (`torch.FloatTensor`) : Prediksi kecepatan transformer pada `timestep`.

timestep (`float` atau `torch.FloatTensor`) : timestep saat ini, salah satu dari `self.timesteps` (sehingga `timestep == 1 - sigma`).

sample (`torch.FloatTensor`) : Sampel saat ini `x_t`.

generator (`torch.Generator`, *opsional*) : Generator tempat noise baru diambil dengan `stochastic_sampling`; tidak digunakan selain itu.

return_dict (`bool`, defaultnya `True`) : Apakah akan mengembalikan `MiniMaxH3SchedulerOutput` alih-alih tuple biasa.

**Mengembalikan:** `MiniMaxH3SchedulerOutput` atau `tuple`

sampel untuk langkah berikutnya.

Ambil satu langkah Euler (`eta = 0`) atau satu langkah re-noising dengan `stochastic_sampling`.

Output model adalah kecepatan data-ward, sehingga estimasi denoised adalah `x0 = x_t + (1 - t) * v` — perhatikan `+`, yang berlawanan dengan konvensi flow-match yang umum. Pembaruan kemudian adalah campuran `x_next = r*x_t + (1 - r)*x0` dengan `r = sigma_next / sigma`, dievaluasi dalam float32 untuk sampel half-precision. Dengan `stochastic_sampling`, pembaruannya adalah `x_next = (1 - sigma_next) * x0 + sigma_next * noise` dengan noise baru dari `generator`, semuanya dalam float32, sehingga langkah terakhir (`sigma_next = 0`) mengembalikan `x0`. Dengan `euler_update_form="velocity"`, pembaruan Euler yang sama dievaluasi sebagai `x_next = x_t + (sigma - sigma_next) * v` dalam float32.

## MiniMaxH3SchedulerOutput[[diffusers.schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput]]

#### diffusers.schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput[[diffusers.schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput]]

```python
diffusers.schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput(prev_sample: FloatTensor)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_minimax_h3.py#L61)

**Parameter:**

prev_sample (`torch.FloatTensor`) : Sampel `x_{t+1}` yang dihitung untuk langkah berikutnya dari loop denoising.

Kelas output untuk output fungsi `step` scheduler.