# 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/v0.43.0/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/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin) et [ConfigMixin](/docs/diffusers/v0.43.0/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/v0.43.0/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/v0.43.0/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/v0.43.0/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/v0.43.0/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/v0.43.0/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/v0.43.0/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` Si `return_dict` est `True`, `FlowMatchEulerDiscreteSchedulerOutput` est renvoyé, sinon un tuple est renvoyé dont le premier élément est le tenseur d'échantillon. 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/v0.43.0/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/v0.43.0/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.