# FlowMapEulerDiscreteScheduler

`FlowMapEulerDiscreteScheduler` est un échantillonneur de type Euler conçu pour les modèles de diffusion distillés par flow-map. Les modèles flow-map apprennent des transitions sur des intervalles arbitraires $\mathbf{z}_t \to \mathbf{z}_r$, plutôt que la correspondance fixe $\mathbf{z}_t \to \mathbf{z}_0$ des modèles de cohérence. Les deux extrémités de la étape sont fournies par l'appelant, ce qui permet un échantillonnage à nombre de pas arbitraire : un seul point de contrôle distillé peut être évalué avec 1, 2, 4, 8, 16... NFE sans réentraînement.

Le planificateur a été introduit dans [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) et est fourni avec les intégrations `AnyFlowPipeline` et `AnyFlowFARPipeline`, mais il n'est pas spécifique à AnyFlow — tout point de contrôle distillé par carte de flux peut l'utiliser.

## FlowMapEulerDiscreteScheduler[[diffusers.FlowMapEulerDiscreteScheduler]]

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

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

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

**Paramètres :**

num_train_timesteps (*int*, par défaut 1000) : Le nombre d'étapes de diffusion utilisées pour entraîner le modèle de carte de flux sous-jacent.

shift (*float*, valeur par défaut 1.0) : Décalage multiplicatif appliqué à l'échelle des pas de temps lors de l'inférence. `shift=1.0` correspond à l'identité ; les valeurs supérieures à 1.0 déplacent l'échelle vers un débruitage plus important aux étapes ultérieures (par exemple, `shift=5` correspond à la valeur par défaut de Wan2.1).

Échantillonneur de type Euler pour les modèles de diffusion distillés par carte de flux.

Les modèles Flow-map apprennent des transitions sur des intervalles arbitraires \\(z_t \to z_r\\) plutôt que la correspondance fixe \\(z_t \to z_0\\) des modèles de cohérence, si bien qu'un point de contrôle distillé unique peut être évalué avec 1, 2, 4, 8, ... NFE sans réentraînement. La méthode *step* fait avancer l'échantillon de *timestep* à *r_timestep* le long de la vitesse prédite.

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

Ce planificateur hérite de [*SchedulerMixin*] et de [*ConfigMixin*]. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les planificateurs (chargement, sauvegarde, etc.).

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

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

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

Appliquer la transformation de décalage configurée à un tenseur sigma.

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

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

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

Retourne l'index de `timestep` sur le planning actuel, ou `None` s'il est hors planning.

La recherche est effectuée par rapport à `self.timesteps` avec une petite tolérance fp. Elle sert à récupérer le sigma correspondant sans supposer la relation linéaire `timesteps = sigmas * num_train_timesteps` — de cette façon, un calendrier personnalisé (par exemple un décalage non linéaire, des timesteps définis manuellement) est toujours résolu correctement.

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

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

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

Mise à l'échelle d'identité sans effet. Fournie pour la compatibilité de l'API avec d'autres planificateurs Diffusers.

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

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

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

Interpoler linéairement `sample` vers `noise` en fonction de la valeur normalisée de `timestep`.

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

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

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

Définit l'index de début pour le planificateur. Les pipelines qui démarrent en cours de planification (par exemple image-to-image) appellent cette fonction entre `set_timesteps` et la première `step` pour ancrer le déroulement.

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

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

**Paramètres :**

num_inference_steps (*int*, *optionnel*) : Nombre d'étapes d'inférence. Si `None`, il faut passer `sigmas` ou `timesteps`.

device (*str* ou *torch.device*, *facultatif*) : Appareil cible pour `self.sigmas` / `self.timesteps`.

sigmas (*List[float]*, *facultatif*) : Plan de sigma personnalisé de longueur `num_inference_steps`. Le sigma terminal `0` est ajouté automatiquement. Le `shift` configuré est appliqué par-dessus.

timesteps (*List[float]*, *facultatif*) : Planification personnalisée des pas de temps de longueur `num_inference_steps`, dans les mêmes unités que `self.timesteps` (c'est-à-dire mise à l'échelle par `num_train_timesteps`). Convertie en sigmas en interne. Si `sigmas` et `timesteps` sont tous les deux fournis, leurs longueurs doivent correspondre.

Construire le calendrier des pas de temps d'inférence.

Gère en interne `self.sigmas` de longueur `num_inference_steps + 1` (le décalage configuré appliqué par défaut à un linspace allant de `1.0` à `0.0`) ; `self.timesteps` expose les `num_inference_steps` premiers sigmas mis à l'échelle par `num_train_timesteps` — c'est-à-dire un timestep par étape d'inférence, ce qui correspond à [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler). Le sigma final (`0`) est l'extrémité r implicite de la dernière étape et est ajouté automatiquement lorsque `sigmas` / `timesteps` sont fournis par l'utilisateur.

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

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

**Paramètres :**

model_output (*torch.Tensor*) : Sortie directe du modèle flow-map (vitesse moyenne prédite).

timestep (*float* ou *torch.Tensor*) : Pas de temps source `t` dans les mêmes unités que `self.timesteps`.

sample (*torch.Tensor*) : Échantillon actuel \\(z_t\\).

r_timestep (*float* ou *torch.Tensor*, *facultatif*) : Pas de temps cible `r`. Par défaut, il s'agit du pas de temps suivant dans le planning lorsque la valeur est `None` ; passez une valeur explicite pour un échantillonnage à pas arbitraire. `r_timestep == timestep` est une opération sans effet.

return_dict (*bool*, par défaut *True*) : Indique s'il faut retourner un [*FlowMapEulerDiscreteSchedulerOutput*] (par défaut) ou un simple tuple.

**Retourne :** [*FlowMapEulerDiscreteSchedulerOutput*] ou *tuple*

Lorsque `return_dict=True`, renvoie un [*FlowMapEulerDiscreteSchedulerOutput*] dont `prev_sample` est \\(z_r\\). Sinon, renvoie un 1-tuple `(prev_sample,)`.

Faites avancer `sample` de `timestep` à `r_timestep` en utilisant la vitesse prédite par le modèle.

Contrairement à un planificateur Euler standard, les deux extrémités de l'intervalle peuvent être fournies par l'appelant, ce qui permet un échantillonnage à nombre de pas arbitraire : un seul appel au modèle peut passer de *t* à toute cible *r* choisie (y compris *r=0* pour une génération en une seule étape). Lorsque `r_timestep` est omis, il prend par défaut la prochaine étape du planificateur (correspondant à la sémantique de `FlowMatchEulerDiscreteScheduler`).

En interne, les sigmas source et cible sont récupérés en indexant `self.sigmas` via `index_for_timestep` plutôt qu’en divisant les timesteps d’entrée par `num_train_timesteps`, de sorte que tout planning dont la relation timestep / sigma est non linéaire (par exemple un décalage personnalisé) reste correct. Pour un `r_timestep` hors planning, le planificateur revient à `r_timestep / num_train_timesteps` afin que l’échantillonnage à n’importe quel pas en dehors du planning reste pris en charge.