# FlowMatchEulerDiscreteScheduler `FlowMatchEulerDiscreteScheduler` est basé sur l'échantillonnage par correspondance de flux introduit dans [Stable Diffusion 3](https://huggingface.co/papers/2403.03206). ## FlowMatchEulerDiscreteScheduler[[diffusers.FlowMatchEulerDiscreteScheduler]] #### diffusers.FlowMatchEulerDiscreteScheduler[[diffusers.FlowMatchEulerDiscreteScheduler]] ```python diffusers.FlowMatchEulerDiscreteScheduler(num_train_timesteps: int = 1000, shift: float = 1.0, use_dynamic_shifting: bool = False, base_shift: float | None = 0.5, max_shift: float | None = 1.15, base_image_seq_len: int = 256, max_image_seq_len: int = 4096, invert_sigmas: bool = False, shift_terminal: float = None, use_karras_sigmas: bool = False, use_exponential_sigmas: bool = False, use_beta_sigmas: bool = False, time_shift_type: typing.Literal['exponential', 'linear'] = 'exponential', stochastic_sampling: bool = False) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L48) **Paramètres :** num_train_timesteps (`int`, par défaut 1000) : Le nombre d'étapes de diffusion pour entraîner le modèle. shift (`float`, par défaut 1.0) : La valeur de décalage pour le calendrier des pas de temps. use_dynamic_shifting (`bool`, défaut : False) : Indique s'il faut appliquer un décalage des pas de temps en temps réel en fonction de la résolution de l'image. base_shift (`float`, par défaut 0.5) : Valeur destinée à stabiliser la génération d'images. Augmenter `base_shift` réduit la variation et l'image est plus cohérente avec la sortie souhaitée. max_shift (`float`, par défaut 1.15) : Variation autorisée appliquée aux vecteurs latents. Augmenter `max_shift` encourage une plus grande variation et l'image peut être plus exagérée ou stylisée. base_image_seq_len (`int`, par défaut 256) : La longueur de séquence de l'image de base. max_image_seq_len (`int`, par défaut 4096) : La longueur maximale de la séquence d'image. invert_sigmas (`bool`, défaut : False) : Indique s'il faut inverser les sigmas. shift_terminal (`float`, par défaut None) : La valeur de fin de l'horloge des timesteps décalés. use_karras_sigmas (`bool`, défaut : False) : Indique s'il faut utiliser les sigmas de Karras pour les tailles de pas dans le calendrier de bruit lors de l'échantillonnage. use_exponential_sigmas (`bool`, défaut : False) : Indique s'il faut utiliser des sigmas exponentiels pour les tailles de pas dans le calendrier de bruit lors de l'échantillonnage. use_beta_sigmas (`bool`, défaut : False) : Indique s'il faut utiliser des sigmas bêta pour les tailles de pas dans le calendrier de bruit lors de l'échantillonnage. time_shift_type (`str`, par défaut "exponential") : Le type de décalage dynamique des pas de temps dépendant de la résolution à appliquer. Soit "exponential", soit "linear". stochastic_sampling (`bool`, défaut : False) : Indique s'il faut utiliser un échantillonnage stochastique. Planificateur Euler. Ce modèle hérite de [SchedulerMixin](/docs/diffusers/main/fr/api/schedulers/overview#diffusers.SchedulerMixin) et [ConfigMixin](/docs/diffusers/main/fr/api/configuration#diffusers.ConfigMixin). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous les planificateurs, telles que le chargement et l'enregistrement. #### index_for_timestep[[diffusers.FlowMatchEulerDiscreteScheduler.index_for_timestep]] ```python index_for_timestep(timestep: typing.Union[float, torch.FloatTensor], schedule_timesteps: typing.Optional[torch.FloatTensor] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L393) **Paramètres :** timestep (`float` ou `torch.FloatTensor`) : Le timestep pour lequel trouver l'index. schedule_timesteps (`torch.FloatTensor`, *facultatif*) : Les pas de temps du calendrier à valider. Si `None`, les pas de temps du planificateur sont utilisés. **Retourne :** `int` L'indice de la pas de temps. Obtenir l'index pour l'étape de temps donnée. #### scale_noise[[diffusers.FlowMatchEulerDiscreteScheduler.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/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L188) **Paramètres :** sample (`torch.FloatTensor`) : L'échantillon d'entrée. timestep (`torch.FloatTensor`) : L'étape temporelle actuelle dans la chaîne de diffusion. noise (`torch.FloatTensor`) : Le tenseur de bruit. **Retourne :** `torch.FloatTensor` Un échantillon d'entrée mis à l'échelle. Processus avant dans le flow-matching #### set_begin_index[[diffusers.FlowMatchEulerDiscreteScheduler.set_begin_index]] ```python set_begin_index(begin_index: int = 0) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L168) **Paramètres :** begin_index (`int`, par défaut `0`) : L'index de début pour le planificateur. Définit l'index de début pour le planificateur. Cette fonction doit être exécutée depuis le pipeline avant l'inférence. #### set_shift[[diffusers.FlowMatchEulerDiscreteScheduler.set_shift]] ```python set_shift(shift: float) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L178) **Paramètres :** shift (`float`) : La valeur de décalage à définir. Définit la valeur de décalage pour le planificateur. #### set_timesteps[[diffusers.FlowMatchEulerDiscreteScheduler.set_timesteps]] ```python set_timesteps(num_inference_steps: int | None = None, device: typing.Union[str, torch.device] = None, sigmas: list[float] | None = None, mu: float | None = None, timesteps: list[float] | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L283) **Paramètres :** num_inference_steps (`int`, *facultatif*) : Le nombre d'étapes de diffusion utilisé lors de la génération d'échantillons avec un modèle pré-entraîné. device (`str` ou `torch.device`, *facultatif*) : L'appareil vers lequel les timesteps doivent être déplacés. Si `None`, les timesteps ne sont pas déplacés. sigmas (`list[float]`, *facultatif*) : Valeurs personnalisées pour les sigmas à utiliser à chaque étape de diffusion. Si `None`, les sigmas sont calculés automatiquement. mu (`float`, *facultatif*) : Détermine la quantité de décalage appliquée aux sigmas lors de l'application d'un décalage des pas de temps dépendant de la résolution. timesteps (`list[float]`, *facultatif*) : Valeurs personnalisées pour les timesteps à utiliser à chaque étape de diffusion. Si `None`, les timesteps sont calculés automatiquement. Définit les pas de temps discrets utilisés pour la chaîne de diffusion (à exécuter avant l'inférence). #### étape[[diffusers.FlowMatchEulerDiscreteScheduler.step]] ```python step(model_output: FloatTensor, timestep: typing.Union[float, torch.FloatTensor], sample: FloatTensor, s_churn: float = 0.0, s_tmin: float = 0.0, s_tmax: float = inf, s_noise: float = 1.0, generator: typing.Optional[torch.Generator] = None, per_token_timesteps: typing.Optional[torch.Tensor] = None, return_dict: bool = True) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L432) **Paramètres :** model_output (`torch.FloatTensor`) : La sortie directe du modèle de diffusion appris. timestep (`float`) : L'étape discrète actuelle dans la chaîne de diffusion. sample (`torch.FloatTensor`) : Une instance actuelle d'un échantillon créé par le processus de diffusion. s_churn (`float`) -- s_tmin (`float`) -- s_tmax (`float`) -- s_noise (`float`, par défaut 1.0) : Facteur d'échelle pour le bruit ajouté à l'échantillon. generator (`torch.Generator`, *facultatif*) : Un générateur de nombres aléatoires. per_token_timesteps (`torch.Tensor`, *facultatif*) : Les pas de temps pour chaque jeton de l'échantillon. return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `FlowMatchEulerDiscreteSchedulerOutput` ou un tuple. **Retourne :** `FlowMatchEulerDiscreteSchedulerOutput` ou `tuple` If return_dict is `True`, `FlowMatchEulerDiscreteSchedulerOutput` is returned, otherwise a tuple is returned where the first element is the sample tensor. Prédit l'échantillon de l'étape temporelle précédente en inversant l'EDS. Cette fonction propage le processus de diffusion à partir des sorties du modèle appris (le plus souvent le bruit prédit). #### stretch_shift_to_terminal[[diffusers.FlowMatchEulerDiscreteScheduler.stretch_shift_to_terminal]] ```python stretch_shift_to_terminal(t: Tensor) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L262) **Paramètres :** t (`torch.Tensor`) : Un tenseur de pas de temps à étirer et à décaler. **Retourne :** `torch.Tensor` Un tenseur de pas de temps ajustés tel que la valeur finale soit égale à `self.config.shift_terminal`. Étire et décale le calendrier des pas de temps pour s'assurer qu'il se termine à la valeur de configuration `shift_terminal` définie. Référence : https://github.com/Lightricks/LTX-Video/blob/a01a171f8fe3d99dce2728d60a73fecf4d4238ae/ltx_video/schedulers/rf.py#L51 #### time_shift[[diffusers.FlowMatchEulerDiscreteScheduler.time_shift]] ```python time_shift(mu: float, sigma: float, t: Tensor) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L241) **Paramètres :** mu (`float`) : Le paramètre mu pour le décalage temporel. sigma (`float`) : Le paramètre sigma pour le décalage temporel. t (`torch.Tensor`) : Les pas de temps d'entrée. **Retourne :** `torch.Tensor` Les pas de temps décalés dans le temps. Appliquer un décalage temporel aux sigmas.