# Planificateur multistep pour le modèle de cohérence latente

## Aperçu

Planificateur multistep et onestep (Algorithme 3) introduit avec les modèles de cohérence latente dans l'article [Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference](https://huggingface.co/papers/2310.04378) de Simian Luo, Yiqin Tan, Longbo Huang, Jian Li et Hang Zhao. Ce planificateur doit être capable de générer de bons échantillons à partir de [LatentConsistencyModelPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/latent_consistency_models#diffusers.LatentConsistencyModelPipeline) en 1 à 8 étapes.

## LCMScheduler[[diffusers.LCMScheduler]]

#### diffusers.LCMScheduler[[diffusers.LCMScheduler]]

```python
diffusers.LCMScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.00085, beta_end: float = 0.012, beta_schedule: str = 'scaled_linear', trained_betas: numpy.ndarray | list[float] | None = None, original_inference_steps: int = 50, clip_sample: bool = False, clip_sample_range: float = 1.0, set_alpha_to_one: bool = True, steps_offset: int = 0, prediction_type: str = 'epsilon', thresholding: bool = False, dynamic_thresholding_ratio: float = 0.995, sample_max_value: float = 1.0, timestep_spacing: str = 'leading', timestep_scaling: float = 10.0, rescale_betas_zero_snr: bool = False)
```

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

**Paramètres :**

num_train_timesteps (`int`, par défaut `1000`) : Le nombre d'étapes de diffusion pour entraîner le modèle.

beta_start (`float`, par défaut `0.00085`) : valeur initiale de `beta` pour l'inférence.

beta_end (`float`, par défaut `0.012`) : La valeur finale de `beta`.

beta_schedule (`str`, par défaut `"scaled_linear"`) : Le planning des bêtas, une correspondance entre une plage de bêtas et une séquence de bêtas pour faire avancer le modèle. Choisissez parmi `linear`, `scaled_linear` ou `squaredcos_cap_v2`.

trained_betas (`np.ndarray` ou `list[float]`, *facultatif*) : Passez un tableau de bêtas directement au constructeur pour contourner `beta_start` et `beta_end`.

original_inference_steps (`int`, par défaut `50`) : Le nombre par défaut d'étapes d'inférence utilisé pour générer un calendrier de pas de temps linéairement espacés, à partir duquel nous extrairons finalement `num_inference_steps` pas de temps uniformément espacés pour former le calendrier de pas de temps final.

clip_sample (`bool`, par défaut `False`) : Applique un seuil à l'échantillon prédit pour la stabilité numérique.

clip_sample_range (`float`, par défaut `1.0`) : L'amplitude maximale pour le rognage des échantillons. Valable uniquement lorsque `clip_sample=True`.

set_alpha_to_one (`bool`, par défaut `True`) : Chaque étape de diffusion utilise la valeur du produit des alphas à cette étape et à l'étape précédente. Pour l'étape finale, il n'y a pas d'alpha précédent. Lorsque cette option est `True`, le produit des alphas précédents est fixé à `1`, sinon il utilise la valeur de l'alpha à l'étape 0.

steps_offset (`int`, par défaut `0`) : Un décalage ajouté aux étapes d'inférence, tel que requis par certaines familles de modèles.

prediction_type (`str`, defaults to `"epsilon"`) : Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper).

thresholding (`bool`, par défaut `False`) : Indique s'il faut utiliser la méthode de « seuillage dynamique ». Cette méthode n'est pas adaptée aux modèles de diffusion en espace latent, tels que Stable Diffusion.

dynamic_thresholding_ratio (`float`, par défaut `0.995`) : Le ratio pour la méthode de seuillage dynamique. Valable uniquement lorsque `thresholding=True`.

sample_max_value (`float`, par défaut `1.0`) : La valeur de seuil pour le seuillage dynamique. Valable uniquement lorsque `thresholding=True`.

timestep_spacing (`str`, par défaut `"leading"`) : La méthode de mise à l'échelle des timesteps. Consultez le tableau 2 de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) pour plus d'informations.

timestep_scaling (`float`, par défaut `10.0`) : Le facteur par lequel les timesteps seront multipliés lors du calcul des conditions aux limites du modèle de cohérence `c_skip` et `c_out`. L'augmenter réduira l'erreur d'approximation (bien que l'erreur d'approximation par défaut de `10.0` soit déjà assez faible).

rescale_betas_zero_snr (`bool`, par défaut `False`) : Indique s'il faut rééchelonner les bêtas pour obtenir un SNR terminal nul. Cela permet au modèle de générer des échantillons très clairs et très sombres, au lieu de se limiter à des échantillons de luminosité moyenne. Lié de manière lâche à [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506).

`LCMScheduler` étend la procédure de débruitage introduite dans les modèles probabilistes de diffusion débruitante (DDPM) avec un guidage non markovien.

Ce modèle hérite de [SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin) et de [ConfigMixin](/docs/diffusers/v0.43.0/fr/api/configuration#diffusers.ConfigMixin). [~ConfigMixin](/docs/diffusers/v0.43.0/fr/api/configuration#diffusers.ConfigMixin) gère le stockage de tous les attributs de configuration passés dans la fonction `__init__` du scheduler, tels que `num_train_timesteps`. Ils sont accessibles via `scheduler.config.num_train_timesteps`. [SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin) fournit des fonctionnalités générales de chargement et d'enregistrement via les fonctions [SchedulerMixin.save_pretrained()](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin.save_pretrained) et [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin.from_pretrained).

#### add_noise[[diffusers.LCMScheduler.add_noise]]

```python
add_noise(original_samples: Tensor, noise: Tensor, timesteps: IntTensor)
```

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

**Paramètres :**

original_samples (`torch.Tensor`) : Les échantillons d'origine auxquels du bruit sera ajouté.

noise (`torch.Tensor`) : Le bruit à ajouter aux échantillons.

timesteps (`torch.IntTensor`) : Les pas de temps indiquant le niveau de bruit pour chaque échantillon.

**Retourne :** `torch.Tensor`

Les échantillons bruités.

Ajoutez du bruit aux échantillons d'origine en fonction de l'amplitude du bruit à chaque pas de temps (il s'agit du processus de diffusion avant).

#### get_scalings_for_boundary_condition_discrete[[diffusers.LCMScheduler.get_scalings_for_boundary_condition_discrete]]

```python
get_scalings_for_boundary_condition_discrete(timestep: int)
```

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

**Paramètres :**

timestep (`int`) : L'instant discret pour lequel calculer les échelles.

**Retourne :** `tuple[float, float]`

Un tuple contenant `c_skip` (mise à l'échelle de l'échantillon d'entrée) et `c_out` (mise à l'échelle de l'échantillon débruité prédit).

Calcule les échelles des conditions aux limites (`c_skip` et `c_out`) pour l'étape discrète donnée, telles qu'utilisées dans le Latent Consistency Model.

#### get_velocity[[diffusers.LCMScheduler.get_velocity]]

```python
get_velocity(sample: Tensor, noise: Tensor, timesteps: IntTensor)
```

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

**Paramètres :**

sample (`torch.Tensor`) : L'échantillon d'entrée.

noise (`torch.Tensor`) : Le tenseur de bruit.

timesteps (`torch.IntTensor`) : Les pas de temps pour le calcul de la vitesse.

**Retourne :** `torch.Tensor`

La vitesse calculée.

Calculer la prédiction de vitesse à partir de l'échantillon et du bruit selon la formule de vitesse.

#### index_for_timestep[[diffusers.LCMScheduler.index_for_timestep]]

```python
index_for_timestep(timestep: typing.Union[float, torch.Tensor], schedule_timesteps: typing.Optional[torch.Tensor] = None)
```

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

**Paramètres :**

timestep (`float` ou `torch.Tensor`) : La valeur de timestep à rechercher dans le planning.

schedule_timesteps (`torch.Tensor`, *facultatif*) : Le calendrier des pas de temps à explorer. Si `None`, utilise `self.timesteps`.

**Retourne :** `int`

L'indice de la pas de temps dans le planning. Pour la toute première étape, renvoie le deuxième indice si plusieurs correspondances existent, afin d'éviter de sauter un sigma lors d'un démarrage en cours de planning (par exemple, pour l'image-vers-image).

Trouver l'index d'une étape de temps donnée dans le calendrier des étapes de temps.

#### previous_timestep[[diffusers.LCMScheduler.previous_timestep]]

```python
previous_timestep(timestep)
```

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

**Paramètres :**

timestep (`int`) : L'étape temporelle actuelle.

**Retourne :** `int` ou `torch.Tensor`

L'étape de temps précédente.

Calculer l'étape précédente dans la chaîne de diffusion.

#### scale_model_input[[diffusers.LCMScheduler.scale_model_input]]

```python
scale_model_input(sample: Tensor, timestep: int | None = None)
```

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

**Paramètres :**

sample (`torch.Tensor`) : L'échantillon d'entrée.

timestep (`int`, *facultatif*) : L'étape temporelle actuelle dans la chaîne de diffusion.

**Retourne :** `torch.Tensor`

Un échantillon d'entrée mis à l'échelle.

Assure l'interchangeabilité avec les planificateurs qui doivent mettre à l'échelle l'entrée du modèle de débruitage en fonction de l'étape temporelle actuelle.

#### set_begin_index[[diffusers.LCMScheduler.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_lcm.py#L331)

**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_timesteps[[diffusers.LCMScheduler.set_timesteps]]

```python
set_timesteps(num_inference_steps: int | None = None, device: typing.Union[str, torch.device, NoneType] = None, original_inference_steps: int | None = None, timesteps: list[int] | None = None, strength: float = 1.0)
```

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

**Paramètres :**

num_inference_steps (`int`, *facultatif*) : Le nombre d'étapes de diffusion utilisées lors de la génération d'échantillons avec un modèle pré-entraîné. Si utilisé, `timesteps` doit être `None`.

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.

original_inference_steps (`int`, *facultatif*) : Le nombre original d'étapes d'inférence, qui sera utilisé pour générer un calendrier de pas de temps linéairement espacé (différent de l'implémentation standard de `diffusers`). Nous prendrons ensuite `num_inference_steps` pas de temps de ce calendrier, espacés uniformément en termes d'indices, et l'utiliserons comme calendrier final des pas de temps. S'il n'est pas défini, il prendra par défaut la valeur de l'attribut `original_inference_steps`.

timesteps (`list[int]`, *facultatif*) : Étapes personnalisées utilisées pour prendre en charge un espacement arbitraire entre les étapes. Si `None`, la stratégie d’espacement par défaut, à savoir un espacement égal entre les étapes sur le calendrier d’entraînement/distillation, est utilisée. Si `timesteps` est transmis, `num_inference_steps` doit être `None`.

strength (`float`, par défaut `1.0`) : Facteur de force utilisé pour générer un calendrier de pas de temps partiel (par exemple pour l'image vers image). Une valeur de `1.0` utilise le calendrier complet.

**Retourne :** `None`

Définit les pas de temps discrets utilisés pour la chaîne de diffusion (à exécuter avant l'inférence).

#### étape[[diffusers.LCMScheduler.step]]

```python
step(model_output: Tensor, timestep: int, sample: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True)
```

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

**Paramètres :**

model_output (`torch.Tensor`) : La sortie directe du modèle de diffusion appris.

timestep (`int`) : L'étape discrète actuelle dans la chaîne de diffusion.

sample (`torch.Tensor`) : Une instance actuelle d'un échantillon créé par le processus de diffusion.

generator (`torch.Generator`, *facultatif*) : Un générateur de nombres aléatoires pour un échantillonnage reproductible.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `LCMSchedulerOutput` ou un `tuple`.

**Retourne :** `LCMSchedulerOutput` ou `tuple`

Si `True` est renvoyé, `LCMSchedulerOutput` 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).