# Planificateurs 🤗 Diffusers fournit de nombreuses fonctions de planificateur pour le processus de diffusion. Un planificateur prend la sortie d'un modèle (l'échantillon sur lequel le processus de diffusion itère) et un pas de temps pour retourner un échantillon débruité. Le pas de temps est important car il indique à quel point du processus de diffusion se situe l'étape ; les données sont générées en itérant en avant sur *n* pas de temps et l'inférence se fait en propageant en arrière à travers les pas de temps. En fonction du pas de temps, un planificateur peut être *discret*, auquel cas le pas de temps est un `int`, ou *continu*, auquel cas le pas de temps est un `float`. Selon le contexte, un planificateur définit comment ajouter itérativement du bruit à une image ou comment mettre à jour un échantillon en fonction de la sortie d'un modèle : - lors de l'*entraînement*, un planificateur ajoute du bruit (il existe différents algorithmes pour la manière d'ajouter du bruit) à un échantillon afin d'entraîner un modèle de diffusion - lors de l'*inférence*, un planificateur définit la manière de mettre à jour un échantillon en fonction de la sortie d'un modèle pré-entraîné De nombreux planificateurs sont implémentés à partir de la bibliothèque [k-diffusion](https://github.com/crowsonkb/k-diffusion) de [Katherine Crowson](https://github.com/crowsonkb/), et ils sont également largement utilisés dans A1111. Pour vous aider à associer les planificateurs de k-diffusion et d'A1111 aux planificateurs de 🤗 Diffusers, consultez le tableau ci-dessous : | A1111/k-diffusion | 🤗 Diffusers | Utilisation | |---------------------|-------------------------------------|---------------------------------------------------------------------------------------------------------------| | DPM++ 2M | [DPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler) | | | DPM++ 2M Karras | [DPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler) | initialiser avec `use_karras_sigmas=True` | | DPM++ 2M SDE | [DPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler) | initialiser avec `algorithm_type="sde-dpmsolver++"` | | DPM++ 2M SDE Karras | [DPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler) | initialiser avec `use_karras_sigmas=True` et `algorithm_type="sde-dpmsolver++"` | | DPM++ 2S a | N/A | très similaire à `DPMSolverSinglestepScheduler` | | DPM++ 2S a Karras | N/A | très similaire à `DPMSolverSinglestepScheduler(use_karras_sigmas=True, ...)` | | DPM++ SDE | [DPMSolverSinglestepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/singlestep_dpm_solver#diffusers.DPMSolverSinglestepScheduler) | | | DPM++ SDE Karras | [DPMSolverSinglestepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/singlestep_dpm_solver#diffusers.DPMSolverSinglestepScheduler) | initialiser avec `use_karras_sigmas=True` | | DPM2 | [KDPM2DiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/dpm_discrete#diffusers.KDPM2DiscreteScheduler) | | | DPM2 Karras | [KDPM2DiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/dpm_discrete#diffusers.KDPM2DiscreteScheduler) | initialiser avec `use_karras_sigmas=True` | | DPM2 a | [KDPM2AncestralDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/dpm_discrete_ancestral#diffusers.KDPM2AncestralDiscreteScheduler) | | | DPM2 a Karras | [KDPM2AncestralDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/dpm_discrete_ancestral#diffusers.KDPM2AncestralDiscreteScheduler) | initialiser avec `use_karras_sigmas=True` | | DPM adaptatif | N/A | | | DPM fast | N/A | | | Euler | [EulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/euler#diffusers.EulerDiscreteScheduler) | | | Euler a | [EulerAncestralDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/euler_ancestral#diffusers.EulerAncestralDiscreteScheduler) | | | Heun | [HeunDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/heun#diffusers.HeunDiscreteScheduler) | | | LMS | [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) | | | LMS Karras | [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) | initialiser avec `use_karras_sigmas=True` | | N/A | [DEISMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/deis#diffusers.DEISMultistepScheduler) | | | N/A | [UniPCMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/unipc#diffusers.UniPCMultistepScheduler) | | ## Planning du bruit et types de planning | A1111/k-diffusion | 🤗 Diffusers | |--------------------------|----------------------------------------------------------------------------| | Karras | initialiser avec `use_karras_sigmas=True` | | sgm_uniform | initialiser avec `timestep_spacing="trailing"` | | simple | initialiser avec `timestep_spacing="trailing"` | | exponentielle | init avec `timestep_spacing="linspace"`, `use_exponential_sigmas=True` | | beta | init avec `timestep_spacing="linspace"`, `use_beta_sigmas=True` | Tous les planificateurs sont construits à partir de la classe de base [SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin), qui implémente les utilitaires de bas niveau partagés par tous les planificateurs. ## SchedulerMixin[[diffusers.SchedulerMixin]] #### diffusers.SchedulerMixin[[diffusers.SchedulerMixin]] ```python diffusers.SchedulerMixin() ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_utils.py#L79) Classe de base pour tous les planificateurs. [SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin) contient des fonctions communes partagées par tous les planificateurs, telles que les fonctionnalités générales de chargement et d’enregistrement. [ConfigMixin](/docs/diffusers/v0.43.0/fr/api/configuration#diffusers.ConfigMixin) gère le stockage des attributs de configuration (comme `num_train_timesteps`) transmis à la fonction `__init__` du planificateur, et ces attributs sont accessibles via `scheduler.config.num_train_timesteps`. Attributs de classe : - **_compatibles** (`list[str]`) -- Une liste de classes de planificateurs compatibles avec la classe de planificateur parent. Utilisez [from_config()](/docs/diffusers/v0.43.0/fr/api/configuration#diffusers.ConfigMixin.from_config) pour charger une autre classe de planificateur compatible (devrait être surchargée par la classe parente). #### from_pretrained[[diffusers.SchedulerMixin.from_pretrained]] ```python from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None = None, subfolder: str | None = None, return_unused_kwargs: bool = False, **kwargs: Any) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_utils.py#L99) **Paramètres :** pretrained_model_name_or_path (`str` ou `os.PathLike`, *facultatif*) : Peut être : - Une chaîne de caractères, l'*identifiant du modèle* (par exemple `google/ddpm-celebahq-256`) d'un modèle pré-entraîné hébergé sur le Hub. - Un chemin vers un *dossier* (par exemple `./my_model_directory`) contenant la configuration du planificateur enregistrée avec [save_pretrained()](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin.save_pretrained). subfolder (`str`, *facultatif*) : Emplacement du sous-dossier d'un fichier de modèle au sein d'un dépôt de modèle plus large sur le Hub ou en local. return_unused_kwargs (`bool`, *facultatif*, par défaut `False`) : Indique si les kwargs non consommés par la classe Python doivent être retournés ou non. cache_dir (`str` ou `os.PathLike`, *facultatif*) : Chemin vers un répertoire où la configuration d'un modèle pré-entraîné téléchargé est mise en cache si le cache standard n'est pas utilisé. force_download (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut forcer le (re)téléchargement des poids du modèle et des fichiers de configuration, en ignorant les versions mises en cache si elles existent. proxies (`dict[str, str]`, *facultatif*) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Les proxys sont utilisés pour chaque requête. output_loading_info (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut également retourner un dictionnaire contenant les clés manquantes, les clés inattendues et les messages d'erreur. local_files_only (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut charger uniquement les poids et les fichiers de configuration du modèle locaux. Si défini sur `True`, le modèle ne sera pas téléchargé depuis le Hub. token (`str` ou `bool`, *facultatif*) : Jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Si `True`, le jeton généré par `diffusers-cli login` (stocké dans `~/.huggingface`) est utilisé. revision (`str`, *facultatif*, par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag, d'un identifiant de commit ou de tout identifiant autorisé par Git. **Retourne :** [SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin) ou `tuple[SchedulerMixin, dict[str, Any]]` Le planificateur instancié à partir de la configuration. Si `return_unused_kwargs` est `True`, un tuple est retourné dont le deuxième élément est un dictionnaire des arguments de mot-clé non utilisés. Instanciez un planificateur à partir d'un fichier de configuration JSON prédéfini dans un répertoire local ou un dépôt du Hub. > [!TIP] > Pour utiliser des modèles privés ou [gated models](https://huggingface.co/docs/hub/models-gated#gated-models), connectez-vous avec `hf > auth login`. Vous pouvez également activer le mode spécial > ["offline-mode"](https://huggingface.co/diffusers/installation.html#offline-mode) pour utiliser cette méthode dans un environnement > protégé par un pare-feu. #### save_pretrained[[diffusers.SchedulerMixin.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike, push_to_hub: bool = False, **kwargs: Any) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_utils.py#L164) **Paramètres :** save_directory (`str` ou `os.PathLike`) : répertoire où le fichier JSON de configuration sera enregistré (sera créé s'il n'existe pas). push_to_hub (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non pousser votre modèle sur le Hugging Face Hub après l'avoir enregistré. Vous pouvez spécifier le dépôt auquel vous souhaitez pousser avec `repo_id` (par défaut, il s'agit du nom de `save_directory` dans votre espace de noms). kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires passés à la méthode [push_to_hub()](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.utils.PushToHubMixin.push_to_hub). Enregistrer un objet de configuration de planificateur dans un répertoire afin qu'il puisse être rechargé à l'aide de la méthode de classe [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin.from_pretrained). ## SchedulerOutput[[diffusers.schedulers.scheduling_utils.SchedulerOutput]] #### diffusers.schedulers.scheduling_utils.SchedulerOutput[[diffusers.schedulers.scheduling_utils.SchedulerOutput]] ```python diffusers.schedulers.scheduling_utils.SchedulerOutput(prev_sample: Tensor) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_utils.py#L66) **Paramètres :** prev_sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` pour les images) : Échantillon calculé `(x_{t-1})` de l'étape temporelle précédente. `prev_sample` doit être utilisé comme entrée du modèle suivante dans la boucle de débruitage. Classe de base pour la sortie de la fonction `step` d'un planificateur. ## KarrasDiffusionSchedulers `KarrasDiffusionSchedulers` est une généralisation large des planificateurs dans 🤗 Diffusers. Les planificateurs de cette classe se distinguent à un niveau élevé par leur stratégie d’échantillonnage du bruit, le type de réseau et de mise à l’échelle, la stratégie d’entraînement et la manière dont la perte est pondérée. Les différents planificateurs de cette classe, en fonction du type de solveur d'équations différentielles ordinaires (EDO), s'inscrivent dans la taxonomie ci-dessus et offrent une bonne abstraction pour la conception des principaux planificateurs implémentés dans 🤗 Diffusers. Les planificateurs de cette classe sont donnés [ici](https://github.com/huggingface/diffusers/blob/a69754bb879ed55b9b6dc9dd0b3cf4fa4124c765/src/diffusers/schedulers/scheduling_utils.py#L32). ## PushToHubMixin[[diffusers.utils.PushToHubMixin]] #### diffusers.utils.PushToHubMixin[[diffusers.utils.PushToHubMixin]] ```python diffusers.utils.PushToHubMixin() ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L491) Un Mixin pour pousser un modèle, un planificateur ou un pipeline vers le Hugging Face Hub. #### push_to_hub[[diffusers.utils.PushToHubMixin.push_to_hub]] ```python push_to_hub(repo_id: str, commit_message: str | None = None, private: bool | None = None, token: str | None = None, create_pr: bool = False, safe_serialization: bool = True, variant: str | None = None, subfolder: str | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L526) **Paramètres :** repo_id (`str`) : Le nom du dépôt vers lequel vous souhaitez pousser vos fichiers de modèle, de planificateur ou de pipeline. Il doit contenir le nom de votre organisation lors d'une poussée vers une organisation. `repo_id` peut également être un chemin vers un répertoire local. commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. Par défaut, `"Upload {object}"`. private (`bool`, *facultatif*) : Indique si le dépôt doit être privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l’organisation est privé. Cette valeur est ignorée si le dépôt existe déjà. token (`str`, *facultatif*) : Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`). create_pr (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. safe_serialization (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut convertir les poids du modèle au format `safetensors`. variant (`str`, *facultatif*) : Si spécifié, les poids sont enregistrés au format `pytorch_model..bin`. Téléchargez des fichiers de modèle, de planificateur ou de pipeline sur le 🤗 Hugging Face Hub. Exemples : ```python from diffusers import UNet2DConditionModel unet = UNet2DConditionModel.from_pretrained("stabilityai/stable-diffusion-2", subfolder="unet") # Push the `unet` to your namespace with the name "my-finetuned-unet". unet.push_to_hub("my-finetuned-unet") # Push the `unet` to an organization with the name "my-finetuned-unet". unet.push_to_hub("your-org/my-finetuned-unet") ```