# FlowMapEulerDiscreteScheduler

`FlowMapEulerDiscreteScheduler` adalah sampler bergaya Euler yang dirancang untuk model difusi yang telah melalui distilasi flow-map. Model flow-map mempelajari transisi dengan interval sembarang $\mathbf{z}_t \to \mathbf{z}_r$, bukan pemetaan tetap $\mathbf{z}_t \to \mathbf{z}_0$ seperti pada model konsistensi. Kedua ujung dari setiap langkah disediakan oleh pemanggil, yang memungkinkan sampling dengan jumlah langkah apa pun: satu checkpoint hasil distilasi dapat dievaluasi pada 1, 2, 4, 8, 16... NFE tanpa perlu pelatihan ulang.

Scheduler diperkenalkan dalam [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) dan disertakan bersama integrasi `AnyFlowPipeline` dan `AnyFlowFARPipeline`, tetapi tidak spesifik untuk AnyFlow — checkpoint mana pun yang telah melalui flow-map distillation dapat menggunakannya.

## FlowMapEulerDiscreteScheduler[[diffusers.FlowMapEulerDiscreteScheduler]]

#### diffusers.FlowMapEulerDiscreteScheduler[[diffusers.FlowMapEulerDiscreteScheduler]]

```python
diffusers.FlowMapEulerDiscreteScheduler(num_train_timesteps: int = 1000, shift: float = 1.0)
```

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

**Parameter:**

num_train_timesteps (*int*, defaultnya 1000) : Jumlah langkah difusi yang digunakan untuk melatih model flow-map yang mendasarinya.

shift (*float*, default 1.0) : Pergeseran langkah waktu multiplikatif yang diterapkan pada jadwal inferensi. `shift=1.0` adalah identitas; nilai yang lebih besar dari 1.0 mendorong jadwal menuju lebih banyak denoising pada langkah-langkah akhir (misalnya, `shift=5` sesuai dengan default Wan2.1).

Sampler bergaya Euler untuk model difusi yang telah didistilasi melalui flow-map.

Model flow-map mempelajari transisi interval arbitrer \\(z_t \to z_r\\) alih-alih pemetaan tetap \\(z_t \to z_0\\) dari model consistency, sehingga satu checkpoint yang telah di-distil dapat dievaluasi pada 1, 2, 4, 8, ... NFE tanpa pelatihan ulang. Metode *step* memajukan sampel dari *timestep* ke *r_timestep* sepanjang kecepatan yang diprediksi.

Diperkenalkan dalam [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) oleh Yuchao Gu, Guian Fang, dkk.

Scheduler ini mewarisi dari [*SchedulerMixin*] dan [*ConfigMixin*]. Periksa dokumentasi superclass untuk metode generik yang diimplementasikan untuk semua scheduler (pemuatan, penyimpanan, dll.).

#### apply_shift[[diffusers.FlowMapEulerDiscreteScheduler.apply_shift]]

```python
apply_shift(sigmas: Tensor)
```

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

Terapkan transformasi pergeseran yang dikonfigurasi ke tensor sigma.

#### index_for_timestep[[diffusers.FlowMapEulerDiscreteScheduler.index_for_timestep]]

```python
index_for_timestep(timestep: typing.Union[float, torch.FloatTensor])
```

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

Kembalikan indeks dari `timestep` pada jadwal saat ini, atau `None` jika di luar jadwal.

Lookup dilakukan terhadap `self.timesteps` dengan toleransi fp yang kecil. Digunakan untuk memulihkan sigma yang sesuai tanpa mengasumsikan hubungan linear `timesteps = sigmas * num_train_timesteps` — dengan cara itu, jadwal kustom (misalnya pergeseran non-linear, timesteps yang diatur secara manual) tetap dapat diselesaikan dengan benar.

#### scale_model_input[[diffusers.FlowMapEulerDiscreteScheduler.scale_model_input]]

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

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

Skala identitas no-op. Disediakan untuk kompatibilitas API dengan scheduler Diffusers lainnya.

#### scale_noise[[diffusers.FlowMapEulerDiscreteScheduler.scale_noise]]

```python
scale_noise(sample: FloatTensor, timestep: typing.Union[float, torch.FloatTensor], noise: typing.Optional[torch.FloatTensor] = None)
```

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

Interpolasi linear `sample` menuju `noise` sesuai dengan `timestep` yang dinormalisasi.

#### set_begin_index[[diffusers.FlowMapEulerDiscreteScheduler.set_begin_index]]

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

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

Atur indeks awal untuk scheduler. Pipeline yang dimulai di tengah jadwal (misalnya image-to-image) memanggil ini antara `set_timesteps` dan `step` pertama untuk mengaitkan rollout.

#### set_timesteps[[diffusers.FlowMapEulerDiscreteScheduler.set_timesteps]]

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

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

**Parameter:**

num_inference_steps (*int*, *opsional*) : Jumlah langkah inferensi. Jika `None`, harus meneruskan `sigmas` atau `timesteps`.

device (*str* atau *torch.device*, *opsional*) : Perangkat target untuk `self.sigmas` / `self.timesteps`.

sigmas (*List[float]*, *opsional*) : Jadwal sigma kustom dengan panjang `num_inference_steps`. Sigma terminal `0` ditambahkan secara otomatis. `shift` yang dikonfigurasi diterapkan di atasnya.

timesteps (*List[float]*, *opsional*) : Jadwal timestep kustom dengan panjang `num_inference_steps`, dalam satuan yang sama dengan `self.timesteps` (yaitu diskalakan oleh `num_train_timesteps`). Dikonversi menjadi sigma secara internal. Jika `sigmas` dan `timesteps` keduanya diteruskan, panjangnya harus sama.

Bangun jadwal timestep inferensi.

Secara internal melacak `self.sigmas` dengan panjang `num_inference_steps + 1` (shift yang dikonfigurasi diterapkan pada linspace dari `1.0` ke `0.0` secara default); `self.timesteps` mengekspos `num_inference_steps` sigma pertama yang diskalakan oleh `num_train_timesteps` — yaitu satu timestep per langkah inferensi, sesuai dengan [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler). Sigma terakhir (`0`) adalah r-endpoint implisit dari langkah terakhir dan ditambahkan secara otomatis ketika `sigmas` / `timesteps` disediakan oleh pengguna.

#### langkah[[diffusers.FlowMapEulerDiscreteScheduler.step]]

```python
step(model_output: FloatTensor, timestep: typing.Union[float, torch.FloatTensor], sample: FloatTensor, r_timestep: typing.Union[float, torch.FloatTensor, NoneType] = None, return_dict: bool = True)
```

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

**Parameter:**

model_output (*torch.Tensor*) : Output langsung dari model flow-map (kecepatan rata-rata yang diprediksi).

timestep (*float* atau *torch.Tensor*) : Timestep sumber `t` dalam satuan yang sama dengan `self.timesteps`.

sample (*torch.Tensor*) : Sampel saat ini \\(z_t\\).

r_timestep (*float* atau *torch.Tensor*, *opsional*) : Target timestep `r`. Bawaan adalah timestep berikutnya pada jadwal ketika `None`; berikan nilai eksplisit untuk any-step sampling. `r_timestep == timestep` adalah no-op.

return_dict (*bool*, defaultnya *True*) : Apakah akan mengembalikan [*FlowMapEulerDiscreteSchedulerOutput*] (default) atau tuple biasa.

**Mengembalikan:** [*FlowMapEulerDiscreteSchedulerOutput*] atau *tuple*

Ketika `return_dict=True`, mengembalikan [*FlowMapEulerDiscreteSchedulerOutput*] yang `prev_sample` adalah \\(z_r\\). Jika tidak, mengembalikan 1-tuple `(prev_sample,)`.

Majukan `sample` dari `timestep` ke `r_timestep` menggunakan kecepatan yang diprediksi model.

Berbeda dengan penjadwal Euler standar, kedua ujung interval dapat disediakan oleh pemanggil sehingga pengambilan sampel langkah apa pun menjadi mungkin: satu panggilan model dapat melangkah dari *t* ke target *r* yang dipilih (termasuk *r=0* untuk generasi sekali jalan). Ketika `r_timestep` diabaikan, nilainya secara default adalah langkah waktu berikutnya pada jadwal (sesuai dengan semantik `FlowMatchEulerDiscreteScheduler`).

Secara internal, sigma sumber dan target dipulihkan dengan mengindeks `self.sigmas` melalui `index_for_timestep`, bukan dengan membagi timestep input oleh `num_train_timesteps`, sehingga jadwal apa pun yang memiliki hubungan timestep / sigma non-linear (misalnya shift kustom) tetap akurat. Untuk `r_timestep` yang berada di luar jadwal, scheduler kembali ke `r_timestep / num_train_timesteps` sehingga sampling di langkah mana pun di luar jadwal tetap didukung.