# EulerDiscreteScheduler

Trình lập lịch Euler (Thuật toán 2) được lấy từ bài báo [Elucidating the Design Space of Diffusion-Based Generative Models](https://huggingface.co/papers/2206.00364) của Karras và cộng sự. Đây là một trình lập lịch nhanh, thường có thể tạo ra các kết quả tốt chỉ trong 20-30 bước. Trình lập lịch này dựa trên bản triển khai [k-diffusion](https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L51) ban đầu của [Katherine Crowson](https://github.com/crowsonkb/).

## EulerDiscreteScheduler[[diffusers.EulerDiscreteScheduler]]

#### diffusers.EulerDiscreteScheduler[[diffusers.EulerDiscreteScheduler]]

```python
diffusers.EulerDiscreteScheduler(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, prediction_type: str = 'epsilon', interpolation_type: str = 'linear', use_karras_sigmas: bool | None = False, use_exponential_sigmas: bool | None = False, use_beta_sigmas: bool | None = False, sigma_min: float | None = None, sigma_max: float | None = None, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'linspace', timestep_type: typing.Literal['discrete', 'continuous'] = 'discrete', steps_offset: int = 0, rescale_betas_zero_snr: bool = False, final_sigmas_type: typing.Literal['zero', 'sigma_min'] = 'zero')
```

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

**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 (`Literal["linear", "scaled_linear", "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. 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`.

prediction_type (`Literal["epsilon", "sample", "v_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`) or `"v_prediction"` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper).

interpolation_type (`Literal["linear", "log_linear"]`, mặc định là `"linear"`, *không bắt buộc*) : Kiểu nội suy để tính các sigma trung gian cho các bước khử nhiễu của trình lập lịch. Phải là một trong `"linear"` hoặc `"log_linear"`.

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.

sigma_min (`float`, *optional*) : Giá trị sigma tối thiểu cho lịch trình nhiễu. Nếu không được cung cấp, mặc định là sigma cuối cùng trong lịch trình.

sigma_max (`float`, *optional*) : Giá trị sigma tối đa cho lịch trình nhiễu. Nếu không được cung cấp, mặc định là sigma đầu tiên trong lịch trình.

timestep_spacing (`Literal["linspace", "leading", "trailing"]`, mặc định là `"linspace"`) : Cách các bước thời gian (timesteps) nên được mở rộng. 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.

timestep_type (`Literal["discrete", "continuous"]`, mặc định là `"discrete"`) : Kiểu của các bước thời gian (timesteps) cần sử dụng. Có thể là `"discrete"` hoặc `"continuous"`.

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

final_sigmas_type (`Literal["zero", "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.

Trình lập lịch Euler.

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.EulerDiscreteScheduler.add_noise]]

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

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

**Tham số:**

original_samples (`torch.Tensor`) : Các mẫu gốc mà nhiễu sẽ được thêm vào.

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

timesteps (`torch.Tensor`) : Các bước thời gian (timesteps) để thêm nhiễu, xác định mức nhiễu từ lịch trình (schedule).

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

Các mẫu nhiễu với nhiễu được thêm vào, được điều chỉnh theo lịch trình bước thời gian.

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.

#### get_velocity[[diffusers.EulerDiscreteScheduler.get_velocity]]

```python
get_velocity(sample: Tensor, noise: Tensor, timesteps: Tensor)
```

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

**Tham số:**

sample (`torch.Tensor`) : Mẫu đầu vào để tính toán vận tốc.

noise (`torch.Tensor`) : Tensor nhiễu tương ứng với mẫu.

timesteps (`torch.Tensor`) : Các bước thời gian để tính toán vận tốc.

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

Dự đoán vận tốc được tính bằng `sqrt(alpha_prod) * noise - sqrt(1 - alpha_prod) * sample`.

Tính toán dự đoán vận tốc cho mẫu và nhiễu đã cho tại các bước thời gian được chỉ định.

Phương pháp này triển khai dự đoán vận tốc được sử dụng trong các mô hình v-prediction, trong đó dự đoán một tổ hợp tuyến tính của mẫu và nhiễu.

#### index_for_timestep[[diffusers.EulerDiscreteScheduler.index_for_timestep]]

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

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

**Tham số:**

timestep (`float` hoặc `torch.Tensor`) : Giá trị bước thời gian cần tìm trong lịch trình.

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. Đối với bước đầu tiên, trả về chỉ số thứ hai nếu có nhiều kết quả khớp để tránh bỏ qua một sigma khi bắt đầu giữa lịch trình (ví dụ: cho image-to-image).

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

#### scale_model_input[[diffusers.EulerDiscreteScheduler.scale_model_input]]

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

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

**Tham số:**

sample (`torch.Tensor`) : Mẫu đầu vào cần được chuẩn hóa.

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

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

Một mẫu đầu vào đã được chuẩn hóa, chia cho `(sigma**2 + 1) ** 0.5`.

Đả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. Mở rộng đầu vào của mô hình khử nhiễu bằng `(sigma**2 + 1) ** 0.5` để khớp với thuật toán Euler.

#### set_begin_index[[diffusers.EulerDiscreteScheduler.set_begin_index]]

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

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

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

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

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

**Tham số:**

num_inference_steps (`int`, *optional*) : 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. Nếu là `None`, bắt buộc phải cung cấp `timesteps` hoặc `sigmas`.

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.

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.

sigmas (`list[float]`, *optional*) : Các sigma 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 và sigma sẽ được tạo dựa trên các thuộc tính liên quan của trình lập lịch. Nếu `sigmas` được truyền vào, `num_inference_steps` và `timesteps` phải là `None`, và các bước thời gian sẽ được tạo dựa trên lịch trình sigma tùy chỉnh.

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

```python
step(model_output: Tensor, timestep: typing.Union[float, torch.Tensor], sample: Tensor, s_churn: float = 0.0, s_tmin: float = 0.0, s_tmax: float = inf, s_noise: float = 1.0, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True)
```

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

**Tham số:**

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

timestep (`float` 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.

s_churn (`float`, *tùy chọn*, mặc định là `0.0`) : Tham số ngẫu nhiên kiểm soát lượng nhiễu được thêm vào trong quá trình lấy mẫu. Giá trị cao hơn làm tăng tính ngẫu nhiên.

s_tmin (`float`, *optional*, mặc định là `0.0`) : Ngưỡng tối thiểu của bước thời gian để áp dụng tính ngẫu nhiên. Chỉ các bước thời gian có giá trị lớn hơn ngưỡng này mới được thêm nhiễu.

s_tmax (`float`, *optional*, mặc định là `inf`) : Ngưỡng bước thời gian tối đa để áp dụng tính ngẫu nhiên. Chỉ các bước thời gian có giá trị nhỏ hơn ngưỡng này sẽ được thêm nhiễu.

s_noise (`float`, *tùy chọn*, mặc định là `1.0`) : Hệ số tỷ lệ cho nhiễu được thêm vào mẫu.

generator (`torch.Generator`, *tùy chọn*) : Bộ tạo số ngẫu nhiên để lấy mẫu có thể tái lập.

return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có trả về [EulerDiscreteSchedulerOutput](/docs/diffusers/main/vi/api/schedulers/euler#diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput) hay tuple hay không.

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

Nếu `return_dict` là `True`, [EulerDiscreteSchedulerOutput](/docs/diffusers/main/vi/api/schedulers/euler#diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput) 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 và phần tử thứ hai là mẫu gốc được dự đoán.

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 quá trình khuếch tán từ các đầu ra của mô hình đã học (thường nhất là nhiễu được dự đoán).

## EulerDiscreteSchedulerOutput[[diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput]]

#### diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput[[diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput]]

```python
diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput(prev_sample: Tensor, pred_original_sample: typing.Optional[torch.Tensor] = None)
```

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

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

pred_original_sample (`torch.Tensor` có shape `(batch_size, num_channels, height, width)` đối với ảnh) : Mẫu khử nhiễu dự đoán `(x_{0})` dựa trên đầu ra của mô hình tại bước thời gian hiện tại. `pred_original_sample` có thể được dùng để xem trước tiến độ hoặc cho guidance.

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