# DPMSolverMultistepScheduler

`DPMSolverMultistepScheduler` là một scheduler đa bước từ [DPM-Solver: A Fast ODE Solver for Diffusion Probabilistic Model Sampling in Around 10 Steps](https://huggingface.co/papers/2206.00927) và [DPM-Solver++: Fast Solver for Guided Sampling of Diffusion Probabilistic Models](https://huggingface.co/papers/2211.01095) của Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li và Jun Zhu.

DPMSolver (và phiên bản cải tiến DPMSolver++) là bộ giải bậc cao chuyên dụng, tốc độ cao cho các phương trình vi phân thường (ODE) của mô hình khuếch tán, với bảo đảm bậc hội tụ. Về mặt thực nghiệm, việc lấy mẫu bằng DPMSolver chỉ với 20 bước có thể tạo ra các mẫu chất lượng cao, và nó vẫn có thể tạo ra các mẫu khá tốt ngay cả khi chỉ dùng 10 bước.

## 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ả `algorithm_type="dpmsolver++"` 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.

Biến thể SDE của DPMSolver và DPM-Solver++ cũng được hỗ trợ, nhưng chỉ dành cho bộ giải bậc nhất và bậc hai. Đây là bộ giải SDE nhanh cho SDE khuếch tán ngược. Khuyến nghị sử dụng `sde-dpmsolver++` bậc hai.

## DPMSolverMultistepScheduler[[diffusers.DPMSolverMultistepScheduler]]

#### diffusers.DPMSolverMultistepScheduler[[diffusers.DPMSolverMultistepScheduler]]

```python
diffusers.DPMSolverMultistepScheduler(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, algorithm_type: typing.Literal['dpmsolver', 'dpmsolver++', 'sde-dpmsolver', 'sde-dpmsolver++'] = 'dpmsolver++', solver_type: typing.Literal['midpoint', 'heun'] = 'midpoint', lower_order_final: bool = True, euler_at_final: bool = False, use_karras_sigmas: bool = False, use_exponential_sigmas: bool = False, use_beta_sigmas: bool = False, use_lu_lambdas: bool = False, use_flow_sigmas: bool = False, flow_shift: float = 1.0, final_sigmas_type: typing.Literal['zero', 'sigma_min'] = 'zero', lambda_min_clipped: float = -inf, variance_type: typing.Optional[typing.Literal['learned', 'learned_range']] = None, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'linspace', steps_offset: int = 0, rescale_betas_zero_snr: bool = False, use_dynamic_shifting: bool = False, time_shift_type: typing.Literal['exponential'] = 'exponential')
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_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 sang một chuỗi các beta để bước qua mô hình.

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 của DPMSolver, có thể là `1` hoặc `2` hoặc `3`. 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"`, hoặc `"flow_prediction"`, mặc định là `"epsilon"`) : Kiểu dự đoán của hàm scheduler. `epsilon` dự đoán nhiễu của quá trình khuếch tán, `sample` dự đoán trực tiếp mẫu nhiễu, `v_prediction` dự đoán vận tốc (xem mục 2.4 của bài báo [Imagen Video](https://huggingface.co/papers/2210.02303)), và `flow_prediction` dự đoán dòng chảy.

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à `algorithm_type="dpmsolver++"`.

algorithm_type (`"dpmsolver"`, `"dpmsolver++"`, `"sde-dpmsolver"`, hoặc `"sde-dpmsolver++"`, mặc định là `"dpmsolver++"`) : Kiểu thuật toán cho bộ giải. Kiểu `dpmsolver` triển khai các thuật toán trong bài báo [DPMSolver](https://huggingface.co/papers/2206.00927), và kiểu `dpmsolver++` triển khai các thuật toán trong bài báo [DPMSolver++](https://huggingface.co/papers/2211.01095). Khuyến nghị sử dụng `dpmsolver++` hoặc `sde-dpmsolver++` với `solver_order=2` cho việc lấy mẫu có hướng dẫn như trong Stable Diffusion.

solver_type (`"midpoint"` hoặc `"heun"`, mặc định là `"midpoint"`) : Kiểu solver cho solver bậc hai. Kiểu solver ảnh hưởng nhẹ đến chất lượng mẫu, đặc biệt khi số bước nhỏ. Khuyến nghị sử dụng solver `midpoint`.

lower_order_final (`bool`, mặc định là `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.

euler_at_final (`bool`, mặc định là `False`) : Có sử dụng phương pháp Euler ở bước cuối cùng hay không. Đây là sự đánh đổi giữa độ ổn định số và độ phong phú của chi tiết. Điều này có thể ổn định việc lấy mẫu của biến thể SDE của DPMSolver khi số bước suy luận nhỏ, nhưng đôi khi có thể dẫn đến hiện tượng mờ.

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_lu_lambdas (`bool`, *tuỳ chọn*, mặc định là `False`) : Có sử dụng uniform-logSNR cho các bước đề xuất bởi DPM-Solver của Lu trong lịch trình nhiễu trong quá trình lấy mẫu hay không. Nếu `True`, các sigma và bước thời gian sẽ được xác định theo một chuỗi `lambda(t)`.

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.

flow_shift (`float`, *optional*, mặc định là 1.0) : Giá trị dịch cho lịch trình bước thời gian (timestep schedule) của flow matching.

final_sigmas_type (`"zero"` hoặc `"sigma_min"`, *tùy chọn*, 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.

lambda_min_clipped (`float`, mặc định là `-inf`) : Ngưỡng cắt cho giá trị tối thiểu của `lambda(t)` để đảm bảo ổn định số. Điều này rất quan trọng đối với lịch nhiễu cosine (`squaredcos_cap_v2`).

variance_type (`"learned"` hoặc `"learned_range"`, *tùy chọn*) : Đặt thành `"learned"` hoặc `"learned_range"` cho các mô hình khuếch tán dự đoán phương sai. Nếu được đặt, đầu ra của mô hình sẽ chứa phương sai Gaussian được dự đoán.

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.

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).

use_dynamic_shifting (`bool`, mặc định là `False`) : Có sử dụng dịch chuyển động (dynamic shifting) cho lịch trình bước thời gian (timestep schedule) hay không.

time_shift_type (`"exponential"`, mặc định là `"exponential"`) : Loại dịch chuyển thời gian được áp dụng khi sử dụng dịch chuyển động.

`DPMSolverMultistepScheduler` là bộ giải bậc cao chuyên dụng, tốc độ cao cho các phương trình vi phân thường (ODE) của mô hình khuếch tán.

Mô hình này kế thừa từ [SchedulerMixin](/docs/diffusers/v0.43.0/vi/api/schedulers/overview#diffusers.SchedulerMixin) và [ConfigMixin](/docs/diffusers/v0.43.0/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.DPMSolverMultistepScheduler.add_noise]]

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L1303)

**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.DPMSolverMultistepScheduler.convert_model_output]]

```python
convert_model_output(model_output: Tensor, *args, sample: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L749)

**Tham số:**

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

sample (`torch.Tensor`, *tùy chọn*) : Một bản thể hiện hiện tại của một mẫu đượ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 dữ liệu tương ứng mà thuật toán DPMSolver/DPMSolver++ cần. DPM-Solver được thiết kế để rời rạc hóa một tích phân của mô hình dự đoán nhiễu, và DPM-Solver++ được thiết kế để rời rạc hóa một tích phân của mô hình dự đoán dữ liệu.

> [!TIP] > Thuật toán và loại mô hình được tách rời. Bạn có thể sử dụng DPMSolver hoặc DPMSolver++ cho cả
noise > prediction và các mô hình dự đoán dữ liệu.

#### dpm_solver_first_order_update[[diffusers.DPMSolverMultistepScheduler.dpm_solver_first_order_update]]

```python
dpm_solver_first_order_update(model_output: Tensor, *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L847)

**Tham số:**

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

sample (`torch.Tensor`, *tùy chọn*) : Một bản thể hiện hiện tại của một mẫu được tạo ra bởi quá trình khuếch tán.

noise (`torch.Tensor`, *tùy chọn*) : Tensor nhiễu.

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

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

Một bước cho DPMSolver bậc nhất (tương đương với DDIM).

#### index_for_timestep[[diffusers.DPMSolverMultistepScheduler.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/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L1144)

**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_dpm_solver_second_order_update[[diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_second_order_update]]

```python
multistep_dpm_solver_second_order_update(model_output_list: list[torch.Tensor], *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L921)

**Tham số:**

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

sample (`torch.Tensor`, *tùy chọn*) : Một bản thể hiện hiện tại của một mẫu được tạo ra bởi quá trình khuếch tán.

noise (`torch.Tensor`, *tùy chọn*) : Nhiễu ngẫu nhiên được sử dụng bởi các biến thể bộ giải (`sde-*`) ngẫu nhiên. Bắt buộc khi `algorithm_type` được đặt thành một trong số chúng, và không được sử dụng trong các trường hợp khác.

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

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

Một bước cho DPMSolver đa bước bậc hai.

#### multistep_dpm_solver_third_order_update[[diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_third_order_update]]

```python
multistep_dpm_solver_third_order_update(model_output_list: list[torch.Tensor], *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L1047)

**Tham số:**

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

sample (`torch.Tensor`, *tùy chọn*) : Một bản thể hiện hiện tại của mẫu được tạo ra bởi quá trình khuếch tán.

noise (`torch.Tensor`, *tùy chọn*) : Tensor nhiễu.

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

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

Một bước cho DPMSolver đa bước bậc ba.

#### scale_model_input[[diffusers.DPMSolverMultistepScheduler.scale_model_input]]

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L1288)

**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.DPMSolverMultistepScheduler.set_begin_index]]

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L357)

**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.DPMSolverMultistepScheduler.set_timesteps]]

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L367)

**Tham số:**

num_inference_steps (`int`, *tuỳ chọn*) : 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.

mu (`float`, *optional*) : Số mũ cho phép dịch thời gian động. Yêu cầu `use_dynamic_shifting` và `time_shift_type` là `"exponential"`; khi được truyền vào, `flow_shift` sẽ được đặt thành `exp(mu)`.

timesteps (`list[int]`, *optional*) : Các bước thời gian tùy chỉnh được sử dụng để hỗ trợ lịch trình bước thời gian tùy ý. Nếu là `None`, các bước thời gian sẽ được tạo dựa trên thuộc tính `timestep_spacing`. Nếu `timesteps` được truyền vào, `num_inference_steps` và `sigmas` phải là `None`, và thuộc tính `timestep_spacing` sẽ bị bỏ qua.

Đặ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.DPMSolverMultistepScheduler.step]]

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L1196)

**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.

generator (`torch.Generator`, *tùy chọn*) : Bộ tạo số ngẫu nhiên.

variance_noise (`torch.Tensor`, *tùy chọn*) : Cách thay thế cho việc tạo nhiễu bằng `generator` bằng cách cung cấp trực tiếp nhiễu cho phương sai. Hữu ích cho các phương pháp như `LEdits++`.

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

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

Nếu `return_dict` là `True`, [SchedulerOutput](/docs/diffusers/v0.43.0/vi/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) sẽ được trả về, ngược lại một tuple sẽ được trả về trong đó phần tử đầu tiên là tensor mẫu.

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 DPMSolver đa bước.

## 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/v0.43.0/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.