# UniPCMultistepScheduler

`UniPCMultistepScheduler` adalah kerangka kerja tanpa pelatihan yang dirancang untuk pengambilan sampel cepat model difusi. Kerangka kerja ini diperkenalkan dalam [UniPC: A Unified Predictor-Corrector Framework for Fast Sampling of Diffusion Models](https://huggingface.co/papers/2302.04867) oleh Wenliang Zhao, Lujia Bai, Yongming Rao, Jie Zhou, Jiwen Lu.

Komponennya terdiri dari korektor (UniC) dan prediktor (UniP) yang berbagi bentuk analitis terpadu dan mendukung urutan arbitrer. UniPC secara desain bersifat model-agnostic, mendukung DPM ruang piksel/ruang laten pada sampling tanpa syarat/bersyarat. UniPC juga dapat diterapkan pada model prediksi noise dan model prediksi data. Korektor UniC juga dapat diterapkan setelah solver apa pun yang tersedia untuk meningkatkan urutan akurasi.

Abstrak dari makalah tersebut adalah:

*Model probabilistik difusi (DPM) telah menunjukkan kemampuan yang sangat menjanjikan dalam sintesis gambar resolusi tinggi. Namun, pengambilan sampel dari DPM yang telah dilatih memakan waktu karena adanya banyak evaluasi jaringan denoising, sehingga semakin penting untuk mempercepat pengambilan sampel DPM. Meskipun ada kemajuan terbaru dalam merancang sampler yang cepat, metode yang ada masih tidak dapat menghasilkan gambar yang memuaskan di banyak aplikasi di mana langkah yang lebih sedikit (misalnya, <10) lebih diutamakan. Dalam makalah ini, kami mengembangkan korektor terpadu (UniC) yang dapat diterapkan setelah sampler DPM mana pun untuk meningkatkan tingkat akurasi tanpa evaluasi model tambahan, dan menurunkan prediktor terpadu (UniP) yang mendukung urutan arbitrer sebagai produk sampingan. Dengan menggabungkan UniP dan UniC, kami mengusulkan kerangka prediktor-korektor terpadu yang disebut UniPC untuk pengambilan sampel DPM yang cepat, yang memiliki bentuk analitis terpadu untuk urutan apa pun dan dapat secara signifikan meningkatkan kualitas pengambilan sampel dibandingkan metode sebelumnya, terutama pada langkah yang sangat sedikit. Kami mengevaluasi metode kami melalui eksperimen yang luas, termasuk pengambilan sampel tanpa syarat dan bersyarat menggunakan DPM ruang piksel dan ruang laten. UniPC kami dapat mencapai FID 3,87 pada CIFAR10 (tanpa syarat) dan FID 7,51 pada ImageNet 256×256 (bersyarat) dengan hanya 10 evaluasi fungsi. Kode tersedia di [URL https ini](https://github.com/wl-zhao/UniPC).*

## Tips

Disarankan untuk mengatur `solver_order` ke 2 untuk guide sampling, dan `solver_order=3` untuk unconditional sampling.

Dynamic thresholding dari [Imagen](https://huggingface.co/papers/2205.11487) didukung, dan untuk model difusi ruang piksel, Anda dapat mengatur `predict_x0=True` dan `thresholding=True` untuk menggunakan dynamic thresholding. Metode thresholding ini tidak cocok untuk model difusi ruang laten seperti 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L123)

**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 (`"linear"`, `"scaled_linear"`, atau `"squaredcos_cap_v2"`, defaultnya `"linear"`) : Jadwal beta, pemetaan dari rentang beta ke urutan beta untuk melangkah 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.

solver_order (`int`, defaultnya `2`) : Urutan UniPC yang dapat berupa bilangan bulat positif apa pun. Urutan akurasi efektifnya adalah `solver_order + 1` karena UniC. Disarankan untuk menggunakan `solver_order=2` untuk pengambilan sampel terpandu, dan `solver_order=3` untuk pengambilan sampel tak bersyarat.

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`, defaultnya `False`) : Apakah akan menggunakan metode "dynamic thresholding". Metode ini tidak cocok untuk model difusi ruang laten seperti Stable Diffusion.

dynamic_thresholding_ratio (`float`, defaultnya 0.995) : Rasio untuk metode ambang batas dinamis. Hanya valid ketika `thresholding=True`.

sample_max_value (`float`, defaultnya 1.0) : Nilai ambang untuk pengambangan dinamis. Hanya valid ketika `thresholding=True` dan `predict_x0=True`.

predict_x0 (`bool`, defaultnya `True`) : Apakah akan menggunakan algoritma pembaruan pada x0 yang diprediksi.

solver_type (`"bh1"` atau `"bh2"`, defaultnya `"bh2"`) : Jenis solver untuk UniPC. Disarankan untuk menggunakan `bh1` untuk sampling tanpa kondisi ketika langkah < 10, dan `bh2` selain itu.

lower_order_final (`bool`, default `True`) : Apakah akan menggunakan solver orde lebih rendah pada langkah-langkah akhir. Hanya valid untuk < 15 langkah inferensi. Hal ini dapat menstabilkan sampling DPMSolver untuk langkah < 15, terutama untuk langkah <= 10.

disable_corrector (`list`, default `[]`) : Menentukan langkah mana yang akan menonaktifkan corrector untuk memitigasi ketidakselarasan antara `epsilon_theta(x_t, c)` dan `epsilon_theta(x_t^c, c)` yang dapat memengaruhi konvergensi untuk skala panduan yang besar. Corrector biasanya dinonaktifkan selama beberapa langkah pertama.

solver_p (`SchedulerMixin`, default `None`) : Scheduler lain mana pun yang, jika ditentukan, membuat algoritma menjadi `solver_p + UniC`.

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.

use_flow_sigmas (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan flow sigmas untuk ukuran langkah dalam jadwal noise selama proses sampling.

timestep_spacing (`"linspace"`, `"leading"`, atau `"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.

steps_offset (`int`, default 0) : Offset yang ditambahkan ke langkah inferensi, sesuai kebutuhan beberapa keluarga model.

final_sigmas_type (`"zero"` atau `"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.

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

`UniPCMultistepScheduler` adalah kerangka kerja tanpa pelatihan yang dirancang untuk pengambilan sampel cepat model difusi.

Model ini mewarisi dari [SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin) dan [ConfigMixin](/docs/diffusers/v0.43.0/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.UniPCMultistepScheduler.add_noise]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1250)

**Parameter:**

original_samples (`torch.Tensor`) : Sampel asli tanpa noise.

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

timesteps (`torch.IntTensor`) : Langkah waktu di mana noise akan ditambahkan ke sampel.

**Mengembalikan:** `torch.Tensor`

Sampel yang bising.

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

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L760)

**Parameter:**

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

timestep (`int`) : Langkah waktu diskret saat ini dalam rantai difusi.

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

**Mengembalikan:** `torch.Tensor`

Output model yang telah dikonversi.

Konversi keluaran model ke tipe yang sesuai yang dibutuhkan oleh algoritma UniPC.

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1100)

**Parameter:**

timestep (`int` atau `torch.Tensor`) : timestep yang akan dicari indeksnya.

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

**Mengembalikan:** `int`

Indeks timestep dalam jadwal.

Cari indeks untuk timestep tertentu dalam jadwal.

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L962)

**Parameter:**

this_model_output (`torch.Tensor`) : Output model pada `x_t`.

this_timestep (`int`) : Langkah waktu saat ini `t`.

last_sample (`torch.Tensor`) : Sampel yang dihasilkan sebelum prediktor terakhir `x_{t-1}`.

this_sample (`torch.Tensor`) : Sampel yang dihasilkan setelah predictor terakhir `x_{t}`.

order (`int`) : Nilai `p` dari UniC-p pada langkah ini. Orde akurasi efektif seharusnya `order + 1`.

**Mengembalikan:** `torch.Tensor`

Tensor sampel yang dikoreksi pada langkah waktu saat ini.

Satu langkah untuk UniC (versi 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L833)

**Parameter:**

model_output (`torch.Tensor`) : Output langsung dari model difusi yang dipelajari pada timestep saat ini.

prev_timestep (`int`) : Langkah waktu diskrit sebelumnya dalam rantai difusi.

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

order (`int`) : Urutan UniP pada timestep ini (sesuai dengan *p* dalam UniPC-p).

**Mengembalikan:** `torch.Tensor`

Tensor sampel pada langkah waktu sebelumnya.

Satu langkah untuk UniP (versi B(h)). Sebagai alternatif, `self.solver_p` digunakan jika ditentukan.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1234)

**Parameter:**

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

**Mengembalikan:** `torch.Tensor`

Contoh input yang diskalakan.

Memastikan interoperabilitas dengan scheduler yang perlu menskalakan input model denoising berdasarkan timestep saat ini.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L308)

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L318)

**Parameter:**

num_inference_steps (`int`) : 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 (`List[float]`, *opsional*) : Nilai kustom untuk sigma yang akan digunakan untuk setiap langkah difusi. Jika `None`, sigma dihitung secara otomatis.

mu (`float`, *opsional*) : Parameter mu opsional untuk pergeseran dinamis saat menggunakan tipe pergeseran waktu eksponensial.

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

#### langkah[[diffusers.UniPCMultistepScheduler.step]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1153)

**Parameter:**

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

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

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

return_dict (`bool`, defaultnya `True`) : Apakah akan mengembalikan [SchedulerOutput](/docs/diffusers/v0.43.0/id/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) atau `tuple`.

**Mengembalikan:** [SchedulerOutput](/docs/diffusers/v0.43.0/id/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) atau `tuple`

If return_dict is `True`, [SchedulerOutput](/docs/diffusers/v0.43.0/id/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) dikembalikan, selain itu sebuah tuple dikembalikan di mana elemen pertama adalah tensor sampel.

Prediksikan sampel dari langkah waktu sebelumnya dengan membalikkan SDE. Fungsi ini menyebarkan sampel dengan UniPC multistep.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L506)

**Parameter:**

t (`torch.Tensor`) : Tensor berisi timestep yang akan diregangkan dan digeser.

**Mengembalikan:** `torch.Tensor`

Tensor dari timestep yang disesuaikan sehingga nilai akhirnya sama dengan `self.config.shift_terminal`.

Melakukan peregangan dan pergeseran pada jadwal timestep untuk memastikan bahwa jadwal tersebut berakhir pada nilai konfigurasi `shift_terminal` yang telah diatur.

Referensi: 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_unipc_multistep.py#L484)

**Parameter:**

mu (`float`) : Parameter mu untuk pergeseran waktu.

sigma (`float`) : Parameter sigma untuk pergeseran waktu.

t (`torch.Tensor`) : Langkah-langkah waktu (timesteps) input.

**Mengembalikan:** `torch.Tensor`

Langkah-langkah waktu yang digeser.

Terapkan pergeseran waktu ke sigmas.

## 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_utils.py#L66)

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

Kelas dasar untuk keluaran dari fungsi `step` sebuah scheduler.