# FlowMapEulerDiscreteScheduler

`FlowMapEulerDiscreteScheduler` là một trình lấy mẫu theo phong cách Euler, được thiết kế cho các mô hình khuếch tán đã được chưng cất bằng flow-map. Các mô hình flow-map học các chuyển tiếp có khoảng tùy ý $\mathbf{z}_t \to \mathbf{z}_r$ thay vì ánh xạ cố định $\mathbf{z}_t \to \mathbf{z}_0$ của các mô hình consistency. Cả hai đầu mút của bước đều do người gọi cung cấp, đây chính là yếu tố cho phép lấy mẫu với số bước tùy ý: một checkpoint chưng cất duy nhất có thể được đánh giá ở 1, 2, 4, 8, 16... NFE mà không cần huấn luyện lại.

Trình điều phối được giới thiệu trong [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) và được cung cấp kèm theo các tích hợp `AnyFlowPipeline` và `AnyFlowFARPipeline`, nhưng nó không chỉ dành riêng cho AnyFlow — bất kỳ checkpoint nào đã được chưng cất flow-map đều có thể sử dụng nó.

## FlowMapEulerDiscreteScheduler[[diffusers.FlowMapEulerDiscreteScheduler]]

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_flow_map_euler_discrete.py#L42)

**Tham số:**

num_train_timesteps (*int*, mặc định là 1000) : Số bước khuếch tán được sử dụng để huấn luyện mô hình flow-map cơ bản.

shift (*float*, mặc định là 1.0) : Hệ số dịch chuyển bước thời gian nhân áp dụng cho lịch suy luận. `shift=1.0` là phép đồng nhất; các giá trị lớn hơn 1.0 đẩy lịch tiến gần hơn đến việc khử nhiễu ở các bước muộn hơn (ví dụ, `shift=5` khớp với mặc định của Wan2.1).

Bộ lấy mẫu kiểu Euler cho các mô hình khuếch tán được chưng cất bằng flow-map.

Mô hình Flow-map học các chuyển tiếp có khoảng tùy ý \\(z_t \to z_r\\) thay vì ánh xạ cố định \\(z_t \to z_0\\) của các mô hình consistency, do đó một checkpoint đã được chưng cất có thể được đánh giá ở 1, 2, 4, 8, ... NFE mà không cần huấn luyện lại. Phương thức *step* di chuyển mẫu từ *timestep* đến *r_timestep* dọc theo vận tốc dự đoán.

Được giới thiệu trong [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) của Yuchao Gu, Guian Fang và cộng sự.

Trình lập lịch này kế thừa từ [*SchedulerMixin*] và [*ConfigMixin*]. Xem tài liệu của lớp cha để biết các phương thức chung được triển khai cho tất cả các trình lập lịch (tải, lưu, v.v.).

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_flow_map_euler_discrete.py#L117)

Áp dụng phép biến đổi dịch chuyển đã cấu hình lên một tensor sigma.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_flow_map_euler_discrete.py#L207)

Trả về chỉ số của `timestep` trên lịch trình hiện tại, hoặc `None` nếu không nằm trong lịch trình.

Việc tra cứu được thực hiện đối với `self.timesteps` với một dung sai fp nhỏ. Được sử dụng để khôi phục sigma tương ứng mà không giả định mối quan hệ tuyến tính `timesteps = sigmas * num_train_timesteps` — nhờ đó, một lịch trình tùy chỉnh (ví dụ: dịch chuyển phi tuyến, timesteps được đặt thủ công) vẫn được phân giải chính xác.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_flow_map_euler_discrete.py#L99)

Thang đo nhận dạng không thao tác. Được cung cấp để đảm bảo tương thích API với các trình lập lịch Diffusers khác.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_flow_map_euler_discrete.py#L103)

Nội suy tuyến tính `sample` về phía `noise` theo `timestep` đã được chuẩn hóa.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_flow_map_euler_discrete.py#L94)

Đặt chỉ số bắt đầu cho trình lập lịch. Các pipeline bắt đầu giữa lịch trình (ví dụ: image-to-image) sẽ gọi hàm này giữa `set_timesteps` và `step` đầu tiên để neo quá trình 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_flow_map_euler_discrete.py#L123)

**Tham số:**

num_inference_steps (*int*, *optional*) : Số bước suy luận. Nếu là `None`, phải truyền `sigmas` hoặc `timesteps`.

device (*str* hoặc *torch.device*, *tuỳ chọn*) : Thiết bị đích cho `self.sigmas` / `self.timesteps`.

sigmas (*List[float]*, *optional*) : Lịch sigma tùy chỉnh có độ dài `num_inference_steps`. Sigma cuối cùng `0` sẽ được thêm vào tự động. Giá trị `shift` đã cấu hình sẽ được áp dụng thêm lên trên.

timesteps (*List[float]*, *optional*) : Lịch trình bước thời gian tùy chỉnh có độ dài `num_inference_steps`, cùng đơn vị với `self.timesteps` (tức là được nhân với `num_train_timesteps`). Được chuyển đổi thành sigmas bên trong. Nếu cả `sigmas` và `timesteps` đều được truyền vào, độ dài của chúng phải khớp nhau.

Xây dựng lịch trình bước thời gian suy luận.

Theo dõi nội bộ `self.sigmas` có độ dài `num_inference_steps + 1` (mặc định là shift được cấu hình áp dụng cho một linspace từ `1.0` đến `0.0`); `self.timesteps` hiển thị `num_inference_steps` sigmas đầu tiên được nhân với `num_train_timesteps` — tức là một timestep cho mỗi bước suy luận, khớp với [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler). Sigma cuối cùng (`0`) là điểm cuối r ngầm của bước cuối và được thêm tự động khi `sigmas` / `timesteps` do người dùng cung cấp.

#### bước[[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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_flow_map_euler_discrete.py#L223)

**Tham số:**

model_output (*torch.Tensor*) : Đầu ra trực tiếp từ mô hình flow-map (tốc độ trung bình dự đoán).

timestep (*float* hoặc *torch.Tensor*) : Bước thời gian nguồn `t` cùng đơn vị với `self.timesteps`.

sample (*torch.Tensor*) : Mẫu hiện tại \\(z_t\\).

r_timestep (*float* hoặc *torch.Tensor*, *optional*) : Timestep đích `r`. Mặc định là timestep tiếp theo trên lịch trình khi `None`; truyền một giá trị rõ ràng cho any-step sampling. `r_timestep == timestep` là một thao tác không làm gì (no-op).

return_dict (*bool*, mặc định là *True*) : Xác định việc trả về một [*FlowMapEulerDiscreteSchedulerOutput*] (mặc định) hay một tuple thông thường.

**Trả về:** [*FlowMapEulerDiscreteSchedulerOutput*] hoặc *tuple*

Khi `return_dict=True`, trả về một [*FlowMapEulerDiscreteSchedulerOutput*] mà `prev_sample` của nó là \\(z_r\\). Ngược lại, trả về một 1-tuple `(prev_sample,)`.

Tiến hành `sample` từ `timestep` đến `r_timestep` bằng cách sử dụng vận tốc do mô hình dự đoán.

Khác với trình lập lịch Euler tiêu chuẩn, cả hai đầu mút của khoảng đều có thể do người gọi cung cấp, cho phép lấy mẫu với bất kỳ bước nào: một lần gọi mô hình có thể bước từ *t* đến bất kỳ đích *r* nào được chọn (bao gồm *r=0* cho sinh một lần). Khi `r_timestep` bị bỏ qua, giá trị mặc định sẽ là bước thời gian tiếp theo trong lịch (khớp với ngữ nghĩa của `FlowMatchEulerDiscreteScheduler`).

Bên trong, các sigma nguồn và đích được khôi phục bằng cách chỉ mục `self.sigmas` thông qua `index_for_timestep` thay vì chia các timestep đầu vào cho `num_train_timesteps`, do đó bất kỳ lịch trình nào có mối quan hệ timestep / sigma phi tuyến tính (ví dụ như một shift tùy chỉnh) vẫn được giữ đúng. Đối với một `r_timestep` nằm ngoài lịch trình, trình điều độ sẽ quay lại dùng `r_timestep / num_train_timesteps` để đảm bảo việc lấy mẫu ở bất kỳ bước nào bên ngoài lịch trình vẫn được hỗ trợ.