# MiniMaxH3Scheduler

`MiniMaxH3Scheduler` là trình lập lịch Euler của rectified-flow (`eta = 0`) với sự dịch chuyển sigma mũ được sử dụng bởi [MiniMax-H3](https://huggingface.co/MiniMaxAI), `sigma' = s * sigma / (1 + (s - 1) * sigma)`.

Các pipeline của MiniMax-H3 đăng ký **hai** trong số chúng, vì các latent của video và audio bước xuống theo hai lịch trình khác nhau bên trong một lần gọi transformer cho mỗi bước: `scheduler` mang lịch trình video (`shift=12.0` trong các checkpoint đã phát hành) và `audio_scheduler` mang lịch trình 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')
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L73)

**Tham số:**

shift (`float`, mặc định là `12.0`) : Độ dịch mũ áp dụng cho lưới sigma, `sigma' = s*sigma / (1 + (s-1)*sigma)`. Các checkpoint được phát hành sử dụng `12.0` cho video latents và `3.0` cho audio latents.

stochastic_sampling (`bool`, mặc định là `False`) : Thay thế phép trộn Euler bằng một bước cập nhật tái nhiễu: dự đoán mẫu sạch, sau đó tái nhiễu nó đến sigma tiếp theo với nhiễu mới. Các adapter Pika H3 Flex ít bước được huấn luyện cho bước cập nhật này; các checkpoint gốc thì không.

shift_provided_sigmas (`bool`, *tuỳ chọn*) : Xác định xem `sigmas` được truyền vào [set_timesteps()](/docs/diffusers/main/vi/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps) có phải là lưới cơ sở mà trình lập lịch sẽ dịch chuyển, giống như lưới `linspace` của nó, hay là một lịch trình hoàn chỉnh được sử dụng nguyên văn. Nếu không được đặt, giá trị mặc định là nguyên văn kèm theo cảnh báo sắp ngừng hỗ trợ; giá trị mặc định sẽ là `True` từ phiên bản 0.44.0.

euler_update_form (`str`, mặc định là `"blend"`) : Cách cập nhật Euler được đánh giá. `"blend"` là hỗn hợp `x_t` / `x0` `x_next = r*x_t + (1 - r)*x0`; `"velocity"` là `x_next = x_t + (sigma - sigma_next) * v`, ở float32. Chúng là cùng một phép cập nhật và chỉ khác nhau ở việc làm tròn float32; MiniMax-H3-Image được chưng cất với dạng velocity.

Trình lập lịch Euler cho luồng đã chỉnh sửa (`eta = 0`) với sự dịch chuyển sigma theo hàm mũ, như được sử dụng bởi MiniMax-H3.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L225)

**Tham số:**

timestep (`float` hoặc `torch.Tensor`) : Một giá trị lấy từ `self.timesteps`. Lịch trình tăng nghiêm ngặt theo `t`, do đó phép khớp là duy nhất.

**Trả về:** `int`

Chỉ số của `timestep`.

Ánh xạ một giá trị bước thời gian (timestep) đến chỉ số của nó trong lịch trình.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L246)

**Tham số:**

sample (`torch.FloatTensor`) : Mẫu sạch `x_0`.

timestep (`float` hoặc `torch.FloatTensor`) : Thời gian đích trong `[0, 1]`; `1` trả về `sample` không thay đổi.

noise (`torch.FloatTensor`) : Nhiễu cần trộn vào.

**Trả về:** `torch.FloatTensor`

Mẫu có nhiễu.

Quy trình tiến của rectified-flow, theo quy ước `t` của MiniMax-H3: `x_t = t*x_0 + (1 - t)*noise`.

MiniMax-H3 sử dụng điều này để thêm nhiễu vào các neo điều kiện của nó, trong đó `t` là mức `noise_aug` chứ không phải một mục trong lịch trình, do đó `timestep` được lấy theo giá trị thực và *không* được tra cứu trong `self.timesteps`.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L138)

**Tham số:**

begin_index (`int`, mặc định là `0`) : Chỉ số bắt đầu cho trình lập lịch.

Đặt chỉ số bắt đầu cho trình lập lịch.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L148)

**Tham số:**

shift (`float`) : Hệ số dịch mũ cần sử dụng cho lịch trình tiếp theo.

Ghi đè sigma shift đã cấu hình; gọi trước [set_timesteps()](/docs/diffusers/main/vi/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps).

MiniMax-H3 hiển thị điều này cho từng yêu cầu dưới dạng `flow_shift` (video) / `audio_flow_shift` (âm thanh).

#### 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L162)

**Tham số:**

num_inference_steps (`int`, *optional*) : Số lượng điểm lưới sigma, bao gồm `0` cuối cùng. Bỏ qua khi `sigmas` được cung cấp.

device (`str` hoặc `torch.device`, *tuỳ chọn*) : Thiết bị mà các tensor lịch được chuyển đến. Bản thân lưới luôn được xây dựng trên CPU ở float32 nên lịch không phụ thuộc vào bộ tăng tốc.

sigmas (`list[float]` hoặc `torch.Tensor`, *tuỳ chọn*) : Một lưới tường minh, giảm nghiêm ngặt và kết thúc tại `0.0`. Với `shift_provided_sigmas=True`, đây là một lưới cơ sở trong `[0, 1]` đi qua phép dịch chuyển giống như lưới `linspace`; ngược lại, nó được sử dụng nguyên văn (mặc định đã bị ngừng hỗ trợ).

Xây dựng lịch sigma / bước thời gian.

Lưới là `linspace(1, 0, num_inference_steps)` được đẩy qua phép dịch chuyển mũ, với các phần tử trùng lặp liên tiếp được gộp lại, hoặc là `sigmas` tường minh, cũng được dịch chuyển khi `shift_provided_sigmas` được đặt. Giá trị cuối `0` vốn đã là một phần của lưới — phép dịch chuyển ánh xạ `0` thành đúng `0` — nên lịch trình giữ `num_inference_steps` sigmas và điều khiển `num_inference_steps - 1` lần đánh giá mô hình, được phơi bày dưới dạng `self.timesteps = 1 - sigmas[:-1]`.

#### bước[[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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L278)

**Tham số:**

model_output (`torch.FloatTensor`) : Dự đoán vận tốc của transformer tại `timestep`.

timestep (`float` hoặc `torch.FloatTensor`) : Bước thời gian hiện tại, một trong số `self.timesteps` (do đó `timestep == 1 - sigma`).

sample (`torch.FloatTensor`) : Mẫu hiện tại `x_t`.

generator (`torch.Generator`, *tùy chọn*) : Bộ sinh mà nhiễu mới được lấy từ đó bằng `stochastic_sampling`; không được sử dụng trong các trường hợp khác.

return_dict (`bool`, mặc định là `True`) : Xác định có trả về một `MiniMaxH3SchedulerOutput` thay vì một tuple thông thường hay không.

**Trả về:** `MiniMaxH3SchedulerOutput` hoặc `tuple`

mẫu cho bước tiếp theo.

Thực hiện một bước Euler (`eta = 0`) hoặc một bước tái nhiễu với `stochastic_sampling`.

Đầu ra của mô hình là một vận tốc dữ liệu, do đó ước lượng khử nhiễu là `x0 = x_t + (1 - t) * v` — lưu ý dấu `+`, trái ngược với quy ước flow-match thông thường. Sau đó, phép cập nhật là sự pha trộn `x_next = r*x_t + (1 - r)*x0` với `r = sigma_next / sigma`, được tính trong float32 cho các mẫu half-precision. Với `stochastic_sampling`, phép cập nhật là `x_next = (1 - sigma_next) * x0 + sigma_next * noise` với nhiễu mới từ `generator`, tất cả trong float32, vì vậy bước cuối (`sigma_next = 0`) trả về `x0`. Với `euler_update_form="velocity"`, phép cập nhật Euler tương tự được tính dưới dạng `x_next = x_t + (sigma - sigma_next) * v` trong 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L61)

**Tham số:**

prev_sample (`torch.FloatTensor`) : Mẫu `x_{t+1}` đã được tính toán cho bước tiếp theo của vòng lặp khử nhiễu.

Lớp đầu ra cho kết quả của hàm `step` của trình lập lịch.