# UniPCMultistepScheduler

`UniPCMultistepScheduler` là một framework không cần huấn luyện, được thiết kế để lấy mẫu nhanh các mô hình khuếch tán. Nó được giới thiệu trong [UniPC: A Unified Predictor-Corrector Framework for Fast Sampling of Diffusion Models](https://huggingface.co/papers/2302.04867) bởi Wenliang Zhao, Lujia Bai, Yongming Rao, Jie Zhou, Jiwen Lu.

Nó bao gồm một bộ hiệu chỉnh (UniC) và một bộ dự đoán (UniP) chia sẻ một dạng phân tích thống nhất và hỗ trợ các bậc tùy ý. UniPC được thiết kế để không phụ thuộc vào mô hình, hỗ trợ các DPM trong không gian pixel/không gian ẩn cho việc lấy mẫu không điều kiện/có điều kiện. Nó cũng có thể được áp dụng cho cả các mô hình dự đoán nhiễu và mô hình dự đoán dữ liệu. Bộ hiệu chỉnh UniC cũng có thể được áp dụng sau bất kỳ bộ giải nào có sẵn để tăng bậc chính xác.

Tóm tắt từ bài báo là:

*Các mô hình xác suất khuếch tán (DPM) đã chứng minh khả năng rất hứa hẹn trong tổng hợp ảnh độ phân giải cao. Tuy nhiên, việc lấy mẫu từ một DPM đã được huấn luyện là tốn thời gian do phải đánh giá mạng khử nhiễu nhiều lần, khiến việc tăng tốc lấy mẫu của DPM ngày càng trở nên quan trọng. Mặc dù có những tiến bộ gần đây trong việc thiết kế các trình lấy mẫu nhanh, các phương pháp hiện có vẫn không thể tạo ra những hình ảnh thỏa mãn trong nhiều ứng dụng mà người ta ưu tiên số bước ít hơn (ví dụ: <10). Trong bài báo này, chúng tôi phát triển một bộ hiệu chỉnh thống nhất (UniC) có thể được áp dụng sau bất kỳ trình lấy mẫu DPM hiện có nào để tăng bậc chính xác mà không cần đánh giá mô hình thêm, và suy ra một bộ dự đoán thống nhất (UniP) hỗ trợ bậc tùy ý như một sản phẩm phụ. Kết hợp UniP và UniC, chúng tôi đề xuất một khung dự đoán - hiệu chỉnh thống nhất gọi là UniPC cho việc lấy mẫu nhanh của DPM, có dạng phân tích thống nhất cho bất kỳ bậc nào và có thể cải thiện đáng kể chất lượng lấy mẫu so với các phương pháp trước đó, đặc biệt là trong trường hợp số bước cực kỳ ít. Chúng tôi đánh giá các phương pháp của mình thông qua các thí nghiệm rộng rãi bao gồm cả lấy mẫu không điều kiện và có điều kiện sử dụng DPM trong không gian pixel và không gian tiềm ẩn. UniPC của chúng tôi có thể đạt FID 3.87 trên CIFAR10 (không điều kiện) và FID 7.51 trên ImageNet 256×256 (có điều kiện) với chỉ 10 lần đánh giá hàm. Mã nguồn có sẵn tại [this https URL](https://github.com/wl-zhao/UniPC).*

## Mẹo

Khuyến nghị đặt `solver_order` thành 2 cho guide sampling, và `solver_order=3` cho unconditional sampling.

Ngưỡng động từ [Imagen](https://huggingface.co/papers/2205.11487) được hỗ trợ, và đối với các mô hình khuếch tán trong không gian pixel, bạn có thể đặt cả `predict_x0=True` và `thresholding=True` để sử dụng ngưỡng động. Phương pháp ngưỡng này không phù hợp với các mô hình khuếch tán trong không gian ẩn như Stable Diffusion.

## UniPCMultistepScheduler[[diffusers.UniPCMultistepScheduler]]

#### diffusers.UniPCMultistepScheduler[[diffusers.UniPCMultistepScheduler]]

```python
diffusers.UniPCMultistepScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.0001, beta_end: float = 0.02, beta_schedule: str = 'linear', trained_betas: numpy.ndarray | list[float] | None = None, solver_order: int = 2, prediction_type: typing.Literal['epsilon', 'sample', 'v_prediction', 'flow_prediction'] = 'epsilon', thresholding: bool = False, dynamic_thresholding_ratio: float = 0.995, sample_max_value: float = 1.0, predict_x0: bool = True, solver_type: typing.Literal['bh1', 'bh2'] = 'bh2', lower_order_final: bool = True, disable_corrector: list[int] = [], solver_p: SchedulerMixin = None, use_karras_sigmas: bool = False, use_exponential_sigmas: bool = False, use_beta_sigmas: bool = False, use_flow_sigmas: bool = False, flow_shift: float = 1.0, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'linspace', steps_offset: int = 0, final_sigmas_type: typing.Literal['zero', 'sigma_min'] = 'zero', rescale_betas_zero_snr: bool = False, use_dynamic_shifting: bool = False, time_shift_type: typing.Literal['exponential'] = 'exponential', sigma_min: float | None = None, sigma_max: bool | None = None, shift_terminal: bool | None = None)
```

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

**Tham số:**

num_train_timesteps (`int`, mặc định là 1000) : Số bước khuếch tán để huấn luyện mô hình.

beta_start (`float`, mặc định là 0.0001) : Giá trị `beta` ban đầu của suy luận.

beta_end (`float`, mặc định là 0.02) : Giá trị `beta` cuối cùng.

beta_schedule (`"linear"`, `"scaled_linear"`, hoặc `"squaredcos_cap_v2"`, mặc định là `"linear"`) : Lịch beta, một ánh xạ từ một khoảng beta đến một chuỗi các beta để bước qua mô hình. Chọn từ `linear`, `scaled_linear`, hoặc `squaredcos_cap_v2`.

trained_betas (`np.ndarray`, *tùy chọn*) : Truyền một mảng betas trực tiếp vào constructor để bỏ qua `beta_start` và `beta_end`.

solver_order (`int`, mặc định là `2`) : Bậc UniPC, có thể là bất kỳ số nguyên dương nào. Bậc chính xác hiệu dụng là `solver_order + 1` do UniC. Khuyến nghị sử dụng `solver_order=2` cho lấy mẫu có hướng dẫn và `solver_order=3` cho lấy mẫu không điều kiện.

prediction_type (`"epsilon"`, `"sample"`, `"v_prediction"`, or `"flow_prediction"`, defaults to `"epsilon"`, *optional*) : Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), `sample` (directly predicts the noisy sample`), `v_prediction` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper), or `flow_prediction`.

thresholding (`bool`, mặc định là `False`) : Có sử dụng phương pháp "dynamic thresholding" hay không. Phương pháp này không phù hợp với các mô hình khuếch tán trong không gian ẩn như Stable Diffusion.

dynamic_thresholding_ratio (`float`, mặc định là 0.995) : Tỷ lệ cho phương pháp ngưỡng động. Chỉ hợp lệ khi `thresholding=True`.

sample_max_value (`float`, mặc định là 1.0) : Giá trị ngưỡng cho ngưỡng động. Chỉ hợp lệ khi `thresholding=True` và `predict_x0=True`.

predict_x0 (`bool`, mặc định là `True`) : Có sử dụng thuật toán cập nhật trên x0 dự đoán hay không.

solver_type (`"bh1"` hoặc `"bh2"`, mặc định là `"bh2"`) : Loại solver cho UniPC. Khuyến nghị sử dụng `bh1` cho việc lấy mẫu không điều kiện khi số bước < 10, và `bh2` trong các trường hợp khác.

lower_order_final (`bool`, mặc định `True`) : Có sử dụng các bộ giải bậc thấp hơn trong các bước cuối cùng hay không. Chỉ hợp lệ cho < 15 bước suy luận. Điều này có thể ổn định việc lấy mẫu của DPMSolver cho các bước < 15, đặc biệt là cho các bước <= 10.

disable_corrector (`list`, mặc định `[]`) : Xác định bước nào để vô hiệu hóa bộ hiệu chỉnh nhằm giảm thiểu sự lệch pha giữa `epsilon_theta(x_t, c)` và `epsilon_theta(x_t^c, c)`, điều có thể ảnh hưởng đến sự hội tụ khi quy mô dẫn hướng lớn. Bộ hiệu chỉnh thường được vô hiệu hóa trong vài bước đầu tiên.

solver_p (`SchedulerMixin`, mặc định `None`) : Bất kỳ trình lập lịch nào khác, nếu được chỉ định, thuật toán sẽ trở thành `solver_p + UniC`.

use_karras_sigmas (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng Karras sigmas cho kích thước bước trong lịch trình nhiễu trong quá trình lấy mẫu hay không. Nếu `True`, các sigmas sẽ được xác định theo một chuỗi các mức nhiễu {σi}.

use_exponential_sigmas (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng các sigma mũ cho kích thước bước trong lịch trình nhiễu trong quá trình lấy mẫu hay không.

use_beta_sigmas (`bool`, *tuỳ chọn*, mặc định là `False`) : Có sử dụng beta sigmas cho kích thước bước trong lịch trình nhiễu trong quá trình lấy mẫu hay không. Xem [Beta Sampling is All You Need](https://huggingface.co/papers/2407.12173) để biết thêm thông tin.

use_flow_sigmas (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng flow sigmas cho kích thước bước trong lịch trình nhiễu trong quá trình lấy mẫu hay không.

timestep_spacing (`"linspace"`, `"leading"`, hoặc `"trailing"`, mặc định là `"linspace"`) : Cách các bước thời gian (timesteps) nên được điều chỉnh. Xem Bảng 2 trong [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) để biết thêm thông tin.

steps_offset (`int`, mặc định là 0) : Một giá trị bù được cộng vào các bước suy luận, theo yêu cầu của một số họ mô hình.

final_sigmas_type (`"zero"` hoặc `"sigma_min"`, mặc định là `"zero"`) : Giá trị `sigma` cuối cùng cho lịch trình nhiễu trong quá trình lấy mẫu. Nếu là `"sigma_min"`, sigma cuối cùng sẽ giống với sigma cuối cùng trong lịch trình huấn luyện. Nếu là `zero`, sigma cuối cùng được đặt thành 0.

rescale_betas_zero_snr (`bool`, mặc định là `False`) : Có nên điều chỉnh lại các hệ số beta để có SNR cuối bằng không hay không. Điều này cho phép mô hình tạo ra các mẫu rất sáng và rất tối thay vì giới hạn ở các mẫu có độ sáng trung bình. Liên quan lỏng lẻo đến [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506).

`UniPCMultistepScheduler` là một framework không cần huấn luyện, được thiết kế để lấy mẫu nhanh cho các mô hình khuếch tán.

Mô hình này kế thừa từ [SchedulerMixin](/docs/diffusers/main/vi/api/schedulers/overview#diffusers.SchedulerMixin) và [ConfigMixin](/docs/diffusers/main/vi/api/configuration#diffusers.ConfigMixin). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các scheduler, chẳng hạn như tải và lưu.

#### add_noise[[diffusers.UniPCMultistepScheduler.add_noise]]

```python
add_noise(original_samples: Tensor, noise: Tensor, timesteps: IntTensor)
```

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

**Tham số:**

original_samples (`torch.Tensor`) : Các mẫu gốc không có nhiễu.

noise (`torch.Tensor`) : Nhiễu cần thêm vào các mẫu.

timesteps (`torch.IntTensor`) : Các bước thời gian (timesteps) tại đó sẽ thêm nhiễu vào các mẫu.

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

Các mẫu nhiễu.

Thêm nhiễu vào các mẫu gốc theo lịch trình nhiễu tại các bước thời gian được chỉ định.

#### convert_model_output[[diffusers.UniPCMultistepScheduler.convert_model_output]]

```python
convert_model_output(model_output: Tensor, *args, sample: Tensor = None, **kwargs)
```

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

**Tham số:**

model_output (`torch.Tensor`) : Đầu ra trực tiếp từ mô hình khuếch tán đã học.

timestep (`int`) : Bước thời gian rời rạc hiện tại trong chuỗi khuếch tán.

sample (`torch.Tensor`) : Một bản sao mẫu hiện tại được tạo ra bởi quá trình khuếch tán.

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

Đầu ra của mô hình đã được chuyển đổi.

Chuyển đổi đầu ra của mô hình sang kiểu tương ứng mà thuật toán UniPC cần.

#### index_for_timestep[[diffusers.UniPCMultistepScheduler.index_for_timestep]]

```python
index_for_timestep(timestep: typing.Union[int, torch.Tensor], schedule_timesteps: typing.Optional[torch.Tensor] = None)
```

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

**Tham số:**

timestep (`int` hoặc `torch.Tensor`) : Bước thời gian để tìm chỉ số.

schedule_timesteps (`torch.Tensor`, *tùy chọn*) : Lịch trình bước thời gian để tìm kiếm. Nếu là `None`, sẽ sử dụng `self.timesteps`.

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

Chỉ số của bước thời gian trong lịch trình.

Tìm chỉ số cho một bước thời gian (timestep) cụ thể trong lịch trình.

#### multistep_uni_c_bh_update[[diffusers.UniPCMultistepScheduler.multistep_uni_c_bh_update]]

```python
multistep_uni_c_bh_update(this_model_output: Tensor, *args, last_sample: Tensor = None, this_sample: Tensor = None, order: int = None, **kwargs)
```

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

**Tham số:**

this_model_output (`torch.Tensor`) : Đầu ra của mô hình tại `x_t`.

this_timestep (`int`) : Bước thời gian hiện tại `t`.

last_sample (`torch.Tensor`) : Mẫu được tạo ra trước bộ dự đoán cuối cùng `x_{t-1}`.

this_sample (`torch.Tensor`) : Mẫu được tạo ra sau bộ dự đoán cuối cùng `x_{t}`.

order (`int`) : Giá trị `p` của UniC-p tại bước này. Bậc chính xác hiệu dụng nên là `order + 1`.

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

Tensor mẫu đã được hiệu chỉnh tại bước thời gian hiện tại.

Một bước cho UniC (phiên bản B(h)).

#### multistep_uni_p_bh_update[[diffusers.UniPCMultistepScheduler.multistep_uni_p_bh_update]]

```python
multistep_uni_p_bh_update(model_output: Tensor, *args, sample: Tensor = None, order: int = None, **kwargs)
```

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

**Tham số:**

model_output (`torch.Tensor`) : Đầu ra trực tiếp từ mô hình khuếch tán đã học tại bước thời gian hiện tại.

prev_timestep (`int`) : Bước thời gian rời rạc trước đó trong chuỗi khuếch tán.

sample (`torch.Tensor`) : Một bản sao mẫu hiện tại được tạo ra bởi quá trình khuếch tán.

order (`int`) : Bậc của UniP tại bước thời gian này (tương ứng với *p* trong UniPC-p).

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

Tensor mẫu tại bước thời gian trước đó.

Một bước cho UniP (phiên bản B(h)). Ngoài ra, `self.solver_p` sẽ được sử dụng nếu được chỉ định.

#### scale_model_input[[diffusers.UniPCMultistepScheduler.scale_model_input]]

```python
scale_model_input(sample: Tensor, *args, **kwargs)
```

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

**Tham số:**

sample (`torch.Tensor`) : Mẫu đầu vào.

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

Một mẫu đầu vào đã được chuẩn hóa.

Đảm bảo khả năng hoán đổi với các trình lập lịch cần mở rộng đầu vào của mô hình khử nhiễu tùy thuộc vào bước thời gian hiện tại.

#### set_begin_index[[diffusers.UniPCMultistepScheduler.set_begin_index]]

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

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

**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. Hàm này nên được chạy từ pipeline trước khi suy luận.

#### set_timesteps[[diffusers.UniPCMultistepScheduler.set_timesteps]]

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

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

**Tham số:**

num_inference_steps (`int`) : Số bước khuếch tán được sử dụng khi tạo mẫu bằng một mô hình đã được huấn luyện trước.

device (`str` hoặc `torch.device`, *tuỳ chọn*) : Thiết bị mà các bước thời gian (timesteps) sẽ được chuyển đến. Nếu là `None`, các bước thời gian sẽ không được chuyển.

sigmas (`List[float]`, *optional*) : Các giá trị tùy chỉnh cho sigmas được sử dụng cho mỗi bước khuếch tán. Nếu `None`, các sigmas sẽ được tính toán tự động.

mu (`float`, *optional*) : Tham số mu tùy chọn cho việc dịch động khi sử dụng kiểu dịch theo thời gian mũ.

Đặt các bước thời gian rời rạc được sử dụng cho chuỗi khuếch tán (cần chạy trước khi suy luận).

#### bước[[diffusers.UniPCMultistepScheduler.step]]

```python
step(model_output: Tensor, timestep: typing.Union[int, torch.Tensor], sample: Tensor, return_dict: bool = True)
```

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

**Tham số:**

model_output (`torch.Tensor`) : Đầu ra trực tiếp từ mô hình khuếch tán đã học.

timestep (`int` hoặc `torch.Tensor`) : Bước thời gian rời rạc hiện tại trong chuỗi khuếch tán.

sample (`torch.Tensor`) : Một bản sao mẫu hiện tại được tạo ra bởi quá trình khuếch tán.

return_dict (`bool`, mặc định là `True`) : Có nên trả về một [SchedulerOutput](/docs/diffusers/main/vi/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) hay `tuple` hay không.

**Trả về:** [SchedulerOutput](/docs/diffusers/main/vi/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) hoặc `tuple`

If return_dict is `True`, [SchedulerOutput](/docs/diffusers/main/vi/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) is returned, otherwise a tuple is returned where the first element is the sample tensor.

Dự đoán mẫu từ bước thời gian trước đó bằng cách đảo ngược SDE. Hàm này lan truyền mẫu bằng UniPC đa bước.

#### stretch_shift_to_terminal[[diffusers.UniPCMultistepScheduler.stretch_shift_to_terminal]]

```python
stretch_shift_to_terminal(t: Tensor)
```

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

**Tham số:**

t (`torch.Tensor`) : Một tensor chứa các bước thời gian (timesteps) cần được kéo dài và dịch chuyển.

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

Một tensor chứa các bước thời gian đã điều chỉnh sao cho giá trị cuối cùng bằng `self.config.shift_terminal`.

Kéo giãn và dịch lịch trình bước thời gian để đảm bảo nó kết thúc tại giá trị cấu hình `shift_terminal` đã được thiết lập.

Tham khảo: https://github.com/Lightricks/LTX-Video/blob/a01a171f8fe3d99dce2728d60a73fecf4d4238ae/ltx_video/schedulers/rf.py#L51

#### time_shift[[diffusers.UniPCMultistepScheduler.time_shift]]

```python
time_shift(mu: float, sigma: float, t: Tensor)
```

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

**Tham số:**

mu (`float`) : Tham số mu cho việc dịch chuyển thời gian.

sigma (`float`) : Tham số sigma cho phép dịch chuyển thời gian.

t (`torch.Tensor`) : Các bước thời gian đầu vào.

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

Các bước thời gian đã dịch chuyển.

Áp dụng dịch chuyển thời gian vào các sigma.

## SchedulerOutput[[diffusers.schedulers.scheduling_utils.SchedulerOutput]]

#### diffusers.schedulers.scheduling_utils.SchedulerOutput[[diffusers.schedulers.scheduling_utils.SchedulerOutput]]

```python
diffusers.schedulers.scheduling_utils.SchedulerOutput(prev_sample: Tensor)
```

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

**Tham số:**

prev_sample (`torch.Tensor` có shape `(batch_size, num_channels, height, width)` đối với ảnh) : Mẫu `(x_{t-1})` đã tính của bước thời gian trước đó. `prev_sample` nên được dùng làm đầu vào mô hình tiếp theo trong vòng lặp khử nhiễu.

Lớp cơ sở cho kết quả của hàm `step` của một trình lập lịch.