Buckets:

mishig's picture
|
download
raw
14.3 kB
# EulerDiscreteScheduler
Scheduler Euler (Algoritma 2) berasal dari paper [Elucidating the Design Space of Diffusion-Based Generative Models](https://huggingface.co/papers/2206.00364) oleh Karras et al. Ini adalah scheduler yang cepat dan sering kali dapat menghasilkan output yang baik dalam 20-30 langkah. Scheduler 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/).
## 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')
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_euler_discrete.py#L143)
**Parameter:**
num_train_timesteps (`int`, defaultnya 1000) : Jumlah langkah difusi untuk melatih model.
beta_start (`float`, defaultnya 0.0001) : Nilai awal `beta` untuk inferensi.
beta_end (`float`, defaultnya 0.02) : Nilai `beta` akhir.
beta_schedule (`Literal["linear", "scaled_linear", "squaredcos_cap_v2"]`, defaultnya `"linear"`) : Jadwal beta, pemetaan dari rentang beta ke urutan beta untuk melangkahkan model. Pilih dari `"linear"`, `"scaled_linear"`, atau `"squaredcos_cap_v2"`.
trained_betas (`np.ndarray`, *opsional*) : Lewatkan `beta_start` dan `beta_end` dengan meneruskan array betas secara langsung ke konstruktor.
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"]`, defaultnya `"linear"`, *opsional*) : Jenis interpolasi untuk menghitung sigma antara untuk langkah-langkah denoising scheduler. Harus berupa salah satu dari `"linear"` atau `"log_linear"`.
use_karras_sigmas (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan Karras sigmas untuk ukuran langkah dalam jadwal noise selama proses sampling. Jika `True`, sigmas ditentukan berdasarkan urutan tingkat noise {σi}.
use_exponential_sigmas (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan sigma eksponensial untuk ukuran langkah dalam jadwal noise selama proses sampling.
use_beta_sigmas (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan beta sigmas untuk ukuran langkah dalam jadwal noise selama proses sampling. Lihat [Beta Sampling is All You Need](https://huggingface.co/papers/2407.12173) untuk informasi lebih lanjut.
sigma_min (`float`, *opsional*) : Nilai sigma minimum untuk jadwal noise. Jika tidak disediakan, secara default menggunakan sigma terakhir dalam jadwal.
sigma_max (`float`, *opsional*) : Nilai sigma maksimum untuk jadwal noise. Jika tidak disediakan, secara default menggunakan sigma pertama dalam jadwal.
timestep_spacing (`Literal["linspace", "leading", "trailing"]`, defaultnya `"linspace"`) : Cara timestep harus diskalakan. Lihat Tabel 2 dari [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) untuk informasi lebih lanjut.
timestep_type (`Literal["discrete", "continuous"]`, defaultnya `"discrete"`) : Jenis timestep yang akan digunakan. Bisa berupa `"discrete"` atau `"continuous"`.
steps_offset (`int`, default 0) : Offset yang ditambahkan ke langkah inferensi, sesuai kebutuhan beberapa keluarga model.
rescale_betas_zero_snr (`bool`, defaultnya `False`) : Apakah akan melakukan penskalaan ulang betas agar memiliki SNR terminal nol. Hal ini memungkinkan model untuk menghasilkan sampel yang sangat terang dan gelap, alih-alih membatasi pada sampel dengan kecerahan sedang. Terkait secara longgar dengan [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506).
final_sigmas_type (`Literal["zero", "sigma_min"]`, 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.
Scheduler Euler.
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.EulerDiscreteScheduler.add_noise]]
```python
add_noise(original_samples: Tensor, noise: Tensor, timesteps: Tensor)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_euler_discrete.py#L802)
**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.
#### get_velocity[[diffusers.EulerDiscreteScheduler.get_velocity]]
```python
get_velocity(sample: Tensor, noise: Tensor, timesteps: Tensor)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_euler_discrete.py#L850)
**Parameter:**
sample (`torch.Tensor`) : Sampel input yang akan dihitung kecepatannya.
noise (`torch.Tensor`) : Tensor noise yang sesuai dengan sampel.
timesteps (`torch.Tensor`) : Langkah waktu di mana kecepatan dihitung.
**Mengembalikan:** `torch.Tensor`
Prediksi kecepatan yang dihitung sebagai `sqrt(alpha_prod) * noise - sqrt(1 - alpha_prod) * sample`.
Hitung prediksi kecepatan untuk sampel dan noise yang diberikan pada timestep yang ditentukan.
Metode ini mengimplementasikan prediksi kecepatan yang digunakan dalam model v-prediction, yang memprediksi kombinasi linear dari sampel dan noise.
#### 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)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_euler_discrete.py#L640)
**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.
#### scale_model_input[[diffusers.EulerDiscreteScheduler.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_euler_discrete.py#L326)
**Parameter:**
sample (`torch.Tensor`) : Sampel input yang akan diskalakan.
timestep (`float` atau `torch.Tensor`) : Langkah waktu (timestep) saat ini dalam rantai difusi.
**Mengembalikan:** `torch.Tensor`
Contoh input yang diskalakan, dibagi dengan `(sigma**2 + 1) ** 0.5`.
Memastikan interoperabilitas dengan scheduler yang perlu menskalakan input model denoising berdasarkan timestep saat ini. Menskalakan input model denoising dengan `(sigma**2 + 1) ** 0.5` untuk menyesuaikan dengan algoritma Euler.
#### set_begin_index[[diffusers.EulerDiscreteScheduler.set_begin_index]]
```python
set_begin_index(begin_index: int = 0)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_euler_discrete.py#L316)
**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.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)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_euler_discrete.py#L350)
**Parameter:**
num_inference_steps (`int`, *opsional*) : Jumlah langkah difusi yang digunakan saat menghasilkan sampel dengan model terlatih. Jika `None`, `timesteps` atau `sigmas` harus disediakan.
device (`str` atau `torch.device`, *opsional*) : Perangkat tempat timestep harus dipindahkan. Jika `None`, timestep tidak dipindahkan.
timesteps (`list[int]`, *opsional*) : Timesteps kustom yang digunakan untuk mendukung jadwal timesteps arbitrer. Jika `None`, timesteps akan dihasilkan berdasarkan atribut `timestep_spacing`. Jika `timesteps` diberikan, `num_inference_steps` dan `sigmas` harus `None`, dan atribut `timestep_spacing` akan diabaikan.
sigmas (`list[float]`, *opsional*) : Sigma kustom yang digunakan untuk mendukung jadwal timestep arbitrer. Jika `None`, timestep dan sigma akan dihasilkan berdasarkan atribut scheduler yang relevan. Jika `sigmas` diberikan, `num_inference_steps` dan `timesteps` harus `None`, dan timestep akan dihasilkan berdasarkan jadwal sigma kustom.
Menetapkan langkah waktu diskrit yang digunakan untuk rantai difusi (untuk dijalankan sebelum inferensi).
#### langkah[[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)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_euler_discrete.py#L685)
**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*, default `0.0`) : Parameter stokastisitas yang mengontrol jumlah noise yang ditambahkan selama sampling. Nilai yang lebih tinggi meningkatkan keacakan.
s_tmin (`float`, *opsional*, defaultnya `0.0`) : Ambang batas timestep minimum untuk menerapkan stokastisitas. Hanya timestep di atas nilai ini yang akan ditambahkan noise.
s_tmax (`float`, *opsional*, defaultnya `inf`) : Ambang batas timestep maksimum untuk menerapkan stokastisitas. Hanya timestep di bawah nilai ini yang akan ditambahkan noise.
s_noise (`float`, *opsional*, default `1.0`) : Faktor penskalaan untuk noise yang ditambahkan ke sampel.
generator (`torch.Generator`, *opsional*) : Generator angka acak untuk pengambilan sampel yang dapat direproduksi.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [EulerDiscreteSchedulerOutput](/docs/diffusers/main/id/api/schedulers/euler#diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput) atau tuple.
**Mengembalikan:** [EulerDiscreteSchedulerOutput](/docs/diffusers/main/id/api/schedulers/euler#diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput) atau `tuple`
Jika `return_dict` adalah `True`, [EulerDiscreteSchedulerOutput](/docs/diffusers/main/id/api/schedulers/euler#diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput) dikembalikan, selain itu sebuah tuple dikembalikan di mana elemen pertama adalah tensor sampel dan elemen kedua adalah 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).
## 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)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_euler_discrete.py#L36)
**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.

Xet Storage Details

Size:
14.3 kB
·
Xet hash:
0193081f473c2b6263d599a64cdefd994bf3f2eee88d6f4f17b4feed6ae92f20

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.