# RePaintScheduler

`RePaintScheduler` est un planificateur d'inpainting basé sur DDPM pour l'inpainting non supervisé avec des masques extrêmes. Il est conçu pour être utilisé avec le `RePaintPipeline` et s'appuie sur l'article [RePaint: Inpainting using Denoising Diffusion Probabilistic Models](https://huggingface.co/papers/2201.09865) d'Andreas Lugmayr et al.

L'abstract de l'article est :

*L'inpainting libre est la tâche qui consiste à ajouter du nouveau contenu à une image dans les régions spécifiées par un masque binaire arbitraire. La plupart des approches existantes sont entraînées pour une certaine distribution de masques, ce qui limite leur capacité de généralisation à des types de masques inconnus. De plus, l'entraînement avec des pertes pixel par pixel et perceptives conduit souvent à de simples extensions texturales vers les zones manquantes au lieu d'une génération sémantiquement significative. Dans ce travail, nous proposons RePaint : une approche d'inpainting basée sur un modèle probabiliste de diffusion de débruitage (DDPM) applicable même aux masques extrêmes. Nous utilisons un DDPM non conditionné pré-entraîné comme prior génératif. Pour conditionner le processus de génération, nous ne modifions que les itérations de diffusion inverse en échantillonnant les régions non masquées à l'aide des informations de l'image donnée. Comme cette technique ne modifie ni ne conditionne le réseau DDPM original lui-même, le modèle produit des images de sortie de haute qualité et variées pour toute forme d'inpainting. Nous validons notre méthode pour l'inpainting de visages et d'images à usage général en utilisant des masques standard et extrêmes. RePaint surpasse les approches autoregressives et GAN de l'état de l'art pour au moins cinq des six distributions de masques. Dépôt GitHub : [ce lien http](http://git.io/RePaint).*

L'implémentation originale peut être trouvée sur [andreas128/RePaint](https://github.com/andreas128/).

## RePaintScheduler[[diffusers.RePaintScheduler]]

#### diffusers.RePaintScheduler[[diffusers.RePaintScheduler]]

```python
diffusers.RePaintScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.0001, beta_end: float = 0.02, beta_schedule: str = 'linear', eta: float = 0.0, trained_betas: numpy.ndarray | None = None, clip_sample: bool = True)
```

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

**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.0001`) : valeur initiale de `beta` pour l'inférence.

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

beta_schedule (`str`, par défaut `"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`, `squaredcos_cap_v2` ou `sigmoid`.

eta (`float`, par défaut `0.0`) : Le poids du bruit ajouté lors d'une étape de diffusion. Une valeur de `0.0` correspond à DDIM et une valeur de `1.0` correspond à DDPM.

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

clip_sample (`bool`, par défaut `True`) : Limite l'échantillon prédit entre -1 et 1 pour la stabilité numérique.

`RePaintScheduler` est un planificateur pour l'inpainting DDPM à l'intérieur d'un masque donné.

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.

#### add_noise[[diffusers.RePaintScheduler.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_repaint.py#L395)

**Paramètres :**

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

noise (`torch.Tensor`) : Le bruit qui serait ajouté aux échantillons.

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

**Levée :** ``NotImplementedError``

- ``NotImplementedError`` -- L'entraînement de RePaint devrait utiliser [DDPMScheduler.add_noise()](/docs/diffusers/v0.43.0/fr/api/schedulers/ddpm#diffusers.DDPMScheduler.add_noise) à la place.

Indique que l’ajout de bruit pour l’entraînement de RePaint n’est pas pris en charge par ce planificateur.

#### scale_model_input[[diffusers.RePaintScheduler.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_repaint.py#L171)

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

```python
set_timesteps(num_inference_steps: int, jump_length: int = 10, jump_n_sample: int = 10, device: typing.Union[str, torch.device, NoneType] = None)
```

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

**Paramètres :**

num_inference_steps (`int`) : Le nombre d'étapes de diffusion utilisées lors de la génération d'échantillons avec un modèle pré-entraîné.

jump_length (`int`, par défaut `10`) : Le nombre d'étapes effectuées vers l'avant dans le temps avant de revenir en arrière pour un saut unique (« j » dans l'article RePaint). Consultez les figures 9 et 10 de l'article.

jump_n_sample (`int`, par défaut `10`) : Le nombre de fois pour effectuer un saut temporel en avant pour un échantillon de temps choisi donné. Consultez les figures 9 et 10 de l'article.

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.

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

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

```python
step(model_output: Tensor, timestep: int, sample: Tensor, original_image: Tensor, mask: 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_repaint.py#L264)

**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.

original_image (`torch.Tensor`) : L'image d'origine sur laquelle effectuer l'inpainting.

mask (`torch.Tensor`) : Le masque où une valeur de 0.0 indique la partie de l'image d'origine à inpainter.

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

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un [RePaintSchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/repaint#diffusers.schedulers.scheduling_repaint.RePaintSchedulerOutput) plutôt qu'un tuple.

**Retourne :** [RePaintSchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/repaint#diffusers.schedulers.scheduling_repaint.RePaintSchedulerOutput) ou `tuple[torch.Tensor, torch.Tensor]`

Si return_dict est `True`, [RePaintSchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/repaint#diffusers.schedulers.scheduling_repaint.RePaintSchedulerOutput) est retourné, sinon un tuple est retourné dont le premier élément est l'échantillon précédent et le second est l'échantillon original prédit.

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).

#### undo_step[[diffusers.RePaintScheduler.undo_step]]

```python
undo_step(sample: Tensor, timestep: int, generator: typing.Optional[torch.Generator] = None)
```

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

**Paramètres :**

sample (`torch.Tensor`) : L'échantillon auquel le bruit est ajouté.

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

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

**Retourne :** `torch.Tensor`

L'échantillon au pas de temps suivant dans la chaîne de diffusion.

Ajouter du bruit à un échantillon pour le faire avancer d'une étape de diffusion.

## RePaintSchedulerOutput[[diffusers.schedulers.scheduling_repaint.RePaintSchedulerOutput]]

#### diffusers.schedulers.scheduling_repaint.RePaintSchedulerOutput[[diffusers.schedulers.scheduling_repaint.RePaintSchedulerOutput]]

```python
diffusers.schedulers.scheduling_repaint.RePaintSchedulerOutput(prev_sample: Tensor, pred_original_sample: Tensor)
```

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

**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.

pred_original_sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` pour les images) : l'échantillon débruité prédit (x_{0}) basé sur la sortie du modèle à l'étape temporelle actuelle. `pred_original_sample` peut être utilisé pour prévisualiser la progression ou pour le guidage.

Classe de sortie pour la fonction d'étape du planificateur.