# FlowMapEulerDiscreteScheduler

`FlowMapEulerDiscreteScheduler` es un muestreador de estilo Euler diseñado para modelos de difusión destilados con flow-map. Los modelos de flow-map aprenden transiciones de intervalo arbitrario $\mathbf{z}_t \to \mathbf{z}_r$ en lugar del mapeo fijo $\mathbf{z}_t \to \mathbf{z}_0$ de los modelos de consistencia. Ambos extremos del paso los proporciona el llamador, lo que permite el muestreo de cualquier número de pasos: un único checkpoint destilado puede evaluarse con 1, 2, 4, 8, 16... NFE sin necesidad de volver a entrenarlo.

El programador se introdujo en [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) y se incluye con las integraciones `AnyFlowPipeline` y `AnyFlowFARPipeline`, pero no es específico de AnyFlow: cualquier punto de control destilado mediante flow-map puede utilizarlo.

## FlowMapEulerDiscreteScheduler[[diffusers.FlowMapEulerDiscreteScheduler]]

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

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

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

**Parámetros:**

num_train_timesteps (*int*, por defecto 1000) : El número de pasos de difusión utilizados para entrenar el modelo de flujo subyacente.

shift (*float*, valor predeterminado 1.0) : Desplazamiento multiplicativo del paso de tiempo aplicado al programa de inferencia. `shift=1.0` es la identidad; los valores mayores que 1.0 desplazan el programa hacia más desruido en los pasos posteriores (p. ej., `shift=5` coincide con el valor predeterminado de Wan2.1).

Muestreador de estilo Euler para modelos de difusión destilados con mapa de flujo.

Los modelos flow-map aprenden transiciones de intervalo arbitrario \\(z_t \to z_r\\) en lugar del mapeo fijo \\(z_t \to z_0\\) de los modelos de consistencia, por lo que un único punto de control destilado puede evaluarse con 1, 2, 4, 8, ... NFE sin necesidad de volver a entrenarlo. El método *step* avanza la muestra desde *timestep* hasta *r_timestep* a lo largo de la velocidad predicha.

Introducido en [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) por Yuchao Gu, Guian Fang et al.

Este programador hereda de [*SchedulerMixin*] y [*ConfigMixin*]. Consulte la documentación de la superclase para los métodos genéricos implementados para todos los programadores (carga, guardado, etc.).

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

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

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

Aplicar la transformación de desplazamiento configurada a un tensor sigma.

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

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

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

Devuelve el índice de `timestep` en la programación actual, o `None` si no está en la programación.

La búsqueda se realiza contra `self.timesteps` con una pequeña tolerancia de punto flotante. Se utiliza para recuperar el sigma correspondiente sin asumir la relación lineal `timesteps = sigmas * num_train_timesteps`; de esta manera, un programa personalizado (p. ej., un desplazamiento no lineal, timesteps establecidos manualmente) se resuelve correctamente.

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

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

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

Escalar de identidad sin operación. Se proporciona para compatibilidad de API con otros programadores de Diffusers.

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

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

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

Interpola linealmente `sample` hacia `noise` según el `timestep` normalizado.

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

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

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

Establece el índice inicial del programador. Las tuberías que comienzan a mitad del programa (p. ej., imagen-a-imagen) llaman a esto entre `set_timesteps` y el primer `step` para anclar el despliegue.

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

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

**Parámetros:**

num_inference_steps (*int*, *optional*) : Número de pasos de inferencia. Si es `None`, debe pasar `sigmas` o `timesteps`.

device (*str* o *torch.device*, *opcional*) : Dispositivo de destino para `self.sigmas` / `self.timesteps`.

sigmas (*List[float]*, *opcional*) : Programa de sigma personalizado de longitud `num_inference_steps`. El sigma terminal `0` se añade automáticamente. El `shift` configurado se aplica encima.

timesteps (*List[float]*, *opcional*) : Programa de pasos de tiempo personalizado de longitud `num_inference_steps`, en las mismas unidades que `self.timesteps` (es decir, escalado por `num_train_timesteps`). Se convierte internamente a sigmas. Si se pasan tanto `sigmas` como `timesteps`, sus longitudes deben coincidir.

Construye el calendario de pasos de inferencia.

Internamente, rastrea `self.sigmas` de longitud `num_inference_steps + 1` (el desplazamiento configurado aplicado a un linspace de `1.0` a `0.0` por defecto); `self.timesteps` expone los primeros `num_inference_steps` sigmas escalados por `num_train_timesteps`, es decir, un timestep por paso de inferencia, coincidiendo con [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler). El sigma final (`0`) es el extremo r implícito del último paso y se añade automáticamente cuando `sigmas` / `timesteps` son proporcionados por el usuario.

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

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

**Parámetros:**

model_output (*torch.Tensor*) : Salida directa del modelo flow-map (velocidad media predicha).

timestep (*float* o *torch.Tensor*) : Paso de tiempo de origen `t` en las mismas unidades que `self.timesteps`.

sample (*torch.Tensor*) : Muestra actual \\(z_t\\).

r_timestep (*float* o *torch.Tensor*, *opcional*) : Paso temporal objetivo `r`. Por defecto, es el siguiente paso temporal en la programación cuando es `None`; pase un valor explícito para muestreo de cualquier paso. `r_timestep == timestep` no tiene efecto.

return_dict (*bool*, por defecto *True*) : Si se debe devolver un [*FlowMapEulerDiscreteSchedulerOutput*] (el valor predeterminado) o una tupla simple.

**Devuelve:** [*FlowMapEulerDiscreteSchedulerOutput*] o *tuple*

Cuando `return_dict=True`, devuelve un [*FlowMapEulerDiscreteSchedulerOutput*] cuyo `prev_sample` es \\(z_r\\). En caso contrario, devuelve una 1-tupla `(prev_sample,)`.

Avance `sample` desde `timestep` hasta `r_timestep` usando la velocidad predicha por el modelo.

A diferencia de un planificador Euler estándar, ambos extremos del intervalo pueden ser proporcionados por el llamador, lo que permite una muestreo de cualquier paso: una única llamada al modelo puede avanzar desde *t* hasta cualquier objetivo *r* elegido (incluido *r=0* para una generación de un solo paso). Cuando se omite `r_timestep`, toma por defecto el siguiente paso temporal del planificador (coincidiendo con la semántica de `FlowMatchEulerDiscreteScheduler`).

Internamente, las sigmas de origen y destino se recuperan indexando `self.sigmas` mediante `index_for_timestep` en lugar de dividir los timesteps de entrada por `num_train_timesteps`, por lo que cualquier programa cuya relación timestep / sigma sea no lineal (por ejemplo, un shift personalizado) se mantiene correcto. Para un `r_timestep` fuera del programa, el scheduler recurre a `r_timestep / num_train_timesteps` para que la muestreo en cualquier paso fuera del programa siga siendo compatible.