# EDMEulerScheduler

Formulasi Karras dari penjadwal Euler (Algoritma 2) dari makalah [Elucidating the Design Space of Diffusion-Based Generative Models](https://huggingface.co/papers/2206.00364) oleh Karras dkk. Ini adalah penjadwal cepat yang sering kali dapat menghasilkan keluaran yang baik dalam 20-30 langkah. Penjadwal ini didasarkan pada implementasi [k-diffusion](https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L51) asli oleh [Katherine Crowson](https://github.com/crowsonkb/).

## EDMEulerScheduler[[diffusers.EDMEulerScheduler]]

#### diffusers.EDMEulerScheduler[[diffusers.EDMEulerScheduler]]

```python
diffusers.EDMEulerScheduler(sigma_min: float = 0.002, sigma_max: float = 80.0, sigma_data: float = 0.5, sigma_schedule: typing.Literal['karras', 'exponential'] = 'karras', num_train_timesteps: int = 1000, prediction_type: typing.Literal['epsilon', 'v_prediction'] = 'epsilon', rho: float = 7.0, final_sigmas_type: typing.Literal['zero', 'sigma_min'] = 'zero')
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L49)

**Parameter:**

sigma_min (`float`, *opsional*, default `0.002`) : Magnitudo noise minimum dalam jadwal sigma. Nilai ini diatur ke 0.002 dalam paper EDM [1]; rentang yang wajar adalah [0, 10].

sigma_max (`float`, *opsional*, default `80.0`) : Magnitudo maksimum noise dalam jadwal sigma. Nilai ini diatur ke 80.0 dalam paper EDM [1]; rentang yang wajar adalah [0.2, 80.0].

sigma_data (`float`, *opsional*, default `0.5`) : Standar deviasi dari distribusi data. Nilai ini diatur ke 0,5 dalam paper EDM [1].

sigma_schedule (`Literal["karras", "exponential"]`, *opsional*, defaultnya `"karras"`) : Jadwal sigma untuk menghitung `sigmas`. Secara default, kami menggunakan jadwal yang diperkenalkan dalam paper EDM (https://huggingface.co/papers/2206.00364). Jadwal `"exponential"` diintegrasikan ke dalam model ini: https://huggingface.co/stabilityai/cosxl.

num_train_timesteps (`int`, *opsional*, defaultnya `1000`) : Jumlah langkah difusi untuk melatih model.

prediction_type (`Literal["epsilon", "v_prediction"]`, *opsional*, defaultnya `"epsilon"`) : Jenis prediksi dari fungsi scheduler. `"epsilon"` memprediksi noise dari proses difusi, dan `"v_prediction"` (lihat bagian 2.4 dari paper [Imagen Video](https://huggingface.co/papers/2210.02303)).

rho (`float`, *opsional*, defaultnya `7.0`) : Parameter rho yang digunakan untuk menghitung jadwal sigma Karras, yang diset ke 7.0 dalam paper EDM [1].

final_sigmas_type (`Literal["zero", "sigma_min"]`, *opsional*, defaultnya `"zero"`) : Nilai `sigma` akhir untuk jadwal noise selama proses sampling. Jika `"sigma_min"`, sigma akhir sama dengan sigma terakhir dalam jadwal pelatihan. Jika `"zero"`, sigma akhir diatur ke 0.

Menerapkan penjadwal Euler dalam formulasi EDM seperti yang disajikan dalam Karras et al. 2022 [1].

[1] Karras, Tero, dkk. "Elucidating the Design Space of Diffusion-Based Generative Models." https://huggingface.co/papers/2206.00364

Model ini mewarisi dari [SchedulerMixin](/docs/diffusers/main/id/api/schedulers/overview#diffusers.SchedulerMixin) dan [ConfigMixin](/docs/diffusers/main/id/api/configuration#diffusers.ConfigMixin). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan pustaka ini untuk semua scheduler, seperti pemuatan dan penyimpanan.

#### add_noise[[diffusers.EDMEulerScheduler.add_noise]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L536)

**Parameter:**

original_samples (`torch.Tensor`) : Sampel asli yang akan ditambahkan dengan noise.

noise (`torch.Tensor`) : Tensor noise yang akan ditambahkan ke sampel asli.

timesteps (`torch.Tensor`) : Langkah waktu untuk menambahkan noise, yang menentukan tingkat noise dari jadwal.

**Mengembalikan:** `torch.Tensor`

Sampel berisik dengan tambahan noise yang diskalakan sesuai dengan jadwal timestep.

Tambahkan noise ke sampel asli sesuai dengan jadwal noise pada timestep yang ditentukan.

#### index_for_timestep[[diffusers.EDMEulerScheduler.index_for_timestep]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L381)

**Parameter:**

timestep (`float` atau `torch.Tensor`) : Nilai timestep yang akan dicari dalam jadwal.

schedule_timesteps (`torch.Tensor`, *opsional*) : Jadwal timestep untuk dicari. Jika `None`, menggunakan `self.timesteps`.

**Mengembalikan:** `int`

Indeks timestep dalam jadwal. Untuk langkah pertama, mengembalikan indeks kedua jika ada beberapa kecocokan untuk menghindari pengabaian sigma saat memulai di tengah jadwal (misalnya, untuk image-to-image).

Cari indeks dari timestep tertentu dalam jadwal timestep.

#### precondition_inputs[[diffusers.EDMEulerScheduler.precondition_inputs]]

```python
precondition_inputs(sample: Tensor, sigma: typing.Union[float, torch.Tensor])
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L177)

**Parameter:**

sample (`torch.Tensor`) : Tensor sampel input untuk preconditioning.

sigma (`float` atau `torch.Tensor`) : Nilai sigma (tingkat noise) saat ini.

**Mengembalikan:** `torch.Tensor`

Contoh input yang diskalakan.

Lakukan pra-kondisi pada sampel input dengan menskalakannya sesuai dengan formulasi EDM.

#### precondition_noise[[diffusers.EDMEulerScheduler.precondition_noise]]

```python
precondition_noise(sigma: typing.Union[float, torch.Tensor])
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L195)

**Parameter:**

sigma (`float` atau `torch.Tensor`) : Nilai sigma (level noise) untuk preconditioning.

**Mengembalikan:** `torch.Tensor`

Nilai noise preconditioned yang dihitung sebagai `0.25 * log(sigma)`.

Prakondisikan tingkat noise dengan menerapkan transformasi logaritmik.

#### precondition_outputs[[diffusers.EDMEulerScheduler.precondition_outputs]]

```python
precondition_outputs(sample: Tensor, model_output: Tensor, sigma: typing.Union[float, torch.Tensor])
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L214)

**Parameter:**

sample (`torch.Tensor`) : Tensor sampel input.

model_output (`torch.Tensor`) : Output langsung dari model difusi yang dipelajari.

sigma (`float` atau `torch.Tensor`) : Nilai sigma (tingkat noise) saat ini.

**Mengembalikan:** `torch.Tensor`

Contoh yang telah dinoised yang dihitung dengan menggabungkan koneksi lompatan dan penskalaan output.

Prakondisikan keluaran model sesuai dengan formulasi EDM.

#### scale_model_input[[diffusers.EDMEulerScheduler.scale_model_input]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L249)

**Parameter:**

sample (`torch.Tensor`) : Tensor sampel input.

timestep (`float` atau `torch.Tensor`) : Langkah waktu (timestep) saat ini dalam rantai difusi.

**Mengembalikan:** `torch.Tensor`

Contoh input yang diskalakan.

Skalakan input model denoising agar sesuai dengan algoritma Euler. Menjamin interoperabilitas dengan scheduler yang perlu menskalakan input model denoising tergantung pada timestep saat ini.

#### set_begin_index[[diffusers.EDMEulerScheduler.set_begin_index]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L167)

**Parameter:**

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

Menetapkan indeks awal untuk penjadwal. Fungsi ini harus dijalankan dari pipeline sebelum inferensi.

#### set_timesteps[[diffusers.EDMEulerScheduler.set_timesteps]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L273)

**Parameter:**

num_inference_steps (`int`, *opsional*) : Jumlah langkah difusi yang digunakan saat menghasilkan sampel dengan model terlatih sebelumnya.

device (`str` atau `torch.device`, *opsional*) : Perangkat tempat timestep harus dipindahkan. Jika `None`, timestep tidak dipindahkan.

sigmas (`torch.Tensor | list[float]`, *opsional*) : Sigma kustom untuk digunakan dalam proses denoising. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.

Menetapkan langkah waktu diskrit yang digunakan untuk rantai difusi (untuk dijalankan sebelum inferensi).

#### langkah[[diffusers.EDMEulerScheduler.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, pred_original_sample: typing.Optional[torch.Tensor] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L427)

**Parameter:**

model_output (`torch.Tensor`) : Output langsung dari model difusi yang dipelajari.

timestep (`float` atau `torch.Tensor`) : Langkah waktu diskret saat ini dalam rantai difusi.

sample (`torch.Tensor`) : Instans saat ini dari sampel yang dibuat oleh proses difusi.

s_churn (`float`, *opsional*, defaultnya `0.0`) : Jumlah stokastisitas yang ditambahkan pada setiap langkah. Nilai yang lebih tinggi menambahkan lebih banyak noise.

s_tmin (`float`, *opsional*, defaultnya `0.0`) : Ambang batas sigma minimum di bawahnya tidak ada noise yang ditambahkan.

s_tmax (`float`, *opsional*, defaultnya `float("inf")`) : Ambang batas sigma maksimum di atasnya tidak ada noise yang ditambahkan.

s_noise (`float`, *opsional*, default `1.0`) : Faktor penskalaan untuk noise yang ditambahkan ke sampel.

generator (`torch.Generator`, *opsional*) : Generator angka acak untuk reproduktibilitas.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [EDMEulerSchedulerOutput](/docs/diffusers/main/id/api/schedulers/edm_euler#diffusers.schedulers.scheduling_edm_euler.EDMEulerSchedulerOutput) atau tuple.

pred_original_sample (`torch.Tensor`, *opsional*) : Sampel denoised yang diprediksi dari langkah sebelumnya. Jika diberikan, perhitungan ulang dilewati.

**Mengembalikan:** [EDMEulerSchedulerOutput](/docs/diffusers/main/id/api/schedulers/edm_euler#diffusers.schedulers.scheduling_edm_euler.EDMEulerSchedulerOutput) atau `tuple`

Jika `return_dict` adalah `True`, sebuah [EDMEulerSchedulerOutput](/docs/diffusers/main/id/api/schedulers/edm_euler#diffusers.schedulers.scheduling_edm_euler.EDMEulerSchedulerOutput) dikembalikan, selain itu sebuah tuple dikembalikan di mana elemen pertama adalah tensor sampel sebelumnya dan elemen kedua adalah tensor sampel asli yang diprediksi.

Prediksi sampel dari langkah waktu sebelumnya dengan membalik SDE. Fungsi ini menyebarkan proses difusi dari keluaran model yang dipelajari (paling sering berupa noise yang diprediksi).

## EDMEulerSchedulerOutput[[diffusers.schedulers.scheduling_edm_euler.EDMEulerSchedulerOutput]]

#### diffusers.schedulers.scheduling_edm_euler.EDMEulerSchedulerOutput[[diffusers.schedulers.scheduling_edm_euler.EDMEulerSchedulerOutput]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_edm_euler.py#L32)

**Parameter:**

prev_sample (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)` untuk gambar) : Sampel `(x_{t-1})` yang dihitung dari timestep sebelumnya. `prev_sample` harus digunakan sebagai input model berikutnya dalam loop denoising.

pred_original_sample (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)` untuk gambar) : Sampel denoised yang diprediksi `(x_{0})` berdasarkan output model dari timestep saat ini. `pred_original_sample` dapat digunakan untuk pratinjau progres atau untuk guidance.

Kelas output untuk output fungsi `step` scheduler.