# CogVideoXDPMScheduler

`CogVideoXDPMScheduler` est basé sur [DPM-Solver: A Fast ODE Solver for Diffusion Probabilistic Model Sampling in Around 10 Steps](https://huggingface.co/papers/2206.00927) et [DPM-Solver++: Fast Solver for Guided Sampling of Diffusion Probabilistic Models](https://huggingface.co/papers/2211.01095), spécifiquement pour les modèles CogVideoX.

## CogVideoXDPMScheduler[[diffusers.CogVideoXDPMScheduler]]

#### diffusers.CogVideoXDPMScheduler[[diffusers.CogVideoXDPMScheduler]]

```python
diffusers.CogVideoXDPMScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.00085, beta_end: float = 0.012, beta_schedule: typing.Literal['linear', 'scaled_linear', 'squaredcos_cap_v2'] = 'scaled_linear', trained_betas: numpy.ndarray | list[float] | None = None, clip_sample: bool = True, set_alpha_to_one: bool = True, steps_offset: int = 0, prediction_type: typing.Literal['epsilon', 'sample', 'v_prediction'] = 'epsilon', clip_sample_range: float = 1.0, sample_max_value: float = 1.0, timestep_spacing: typing.Literal['leading', 'linspace', 'trailing'] = 'leading', rescale_betas_zero_snr: bool = False, snr_shift_scale: float = 3.0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpm_cogvideox.py#L134)

**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` ou `squaredcos_cap_v2`.

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`) : 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`, valeur 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`, *optional*) : 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. Choisissez parmi `leading`, `linspace` ou `trailing`.

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

snr_shift_scale (`float`, par défaut 3.0) : Échelle de décalage pour le SNR.

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

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.

#### add_noise[[diffusers.CogVideoXDPMScheduler.add_noise]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpm_cogvideox.py#L522)

**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_mult[[diffusers.CogVideoXDPMScheduler.get_mult]]

```python
get_mult(h: Tensor, r: Tensor, alpha_prod_t: Tensor, alpha_prod_t_prev: Tensor, alpha_prod_t_back: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpm_cogvideox.py#L364)

**Paramètres :**

h (`torch.Tensor`) : La différence de log-SNR.

r (`torch.Tensor`) : Le ratio des différences de log-SNR.

alpha_prod_t (`torch.Tensor`) : Produit cumulé des alphas à l'étape temporelle actuelle.

alpha_prod_t_prev (`torch.Tensor`) : Produit cumulé des alphas à l'étape précédente.

alpha_prod_t_back (`torch.Tensor`, *facultatif*) : Le produit cumulé des alphas à l'étape temporelle précédant l'étape temporelle précédente.

**Retourne :** `tuple`

Un tuple contenant les multiplicateurs.

Calculez les multiplicateurs pour l'échantillon précédent et l'échantillon original prédit.

#### get_variables[[diffusers.CogVideoXDPMScheduler.get_variables]]

```python
get_variables(alpha_prod_t: Tensor, alpha_prod_t_prev: Tensor, alpha_prod_t_back: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpm_cogvideox.py#L331)

**Paramètres :**

alpha_prod_t (`torch.Tensor`) : Produit cumulé des alphas à l'étape temporelle actuelle.

alpha_prod_t_prev (`torch.Tensor`) : Produit cumulé des alphas à l'étape précédente.

alpha_prod_t_back (`torch.Tensor`, *facultatif*) : Le produit cumulé des alphas à l'étape temporelle précédant l'étape temporelle précédente.

**Retourne :** `tuple`

Un tuple contenant les variables `h`, `r`, `lamb`, `lamb_next`.

Calculer les variables utilisées pour DPM-Solver++ (2M) en se référant à l'implémentation originale.

#### get_velocity[[diffusers.CogVideoXDPMScheduler.get_velocity]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpm_cogvideox.py#L565)

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

#### scale_model_input[[diffusers.CogVideoXDPMScheduler.scale_model_input]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpm_cogvideox.py#L262)

**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.CogVideoXDPMScheduler.set_timesteps]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpm_cogvideox.py#L279)

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

device (`str` ou `torch.device`, *facultatif*) : L'appareil vers lequel les timesteps doivent être déplacés. Si `None` (par défaut), 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.CogVideoXDPMScheduler.step]]

```python
step(model_output: Tensor, old_pred_original_sample: Tensor, timestep: int, timestep_back: int, sample: Tensor, eta: float = 0.0, use_clipped_model_output: bool = False, generator: typing.Optional[torch.Generator] = None, variance_noise: typing.Optional[torch.Tensor] = None, return_dict: bool = False)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpm_cogvideox.py#L401)

**Paramètres :**

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

old_pred_original_sample (`torch.Tensor`) : L'échantillon original prédit à partir de l'étape temporelle précédente.

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

timestep_back (`int`) : L'indice de pas temporel auquel revenir en arrière.

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

eta (`float`) : Le poids du bruit pour le bruit ajouté à l'étape de diffusion.

use_clipped_model_output (`bool`, par défaut `False`) : Si `True`, calcule le `model_output` « corrigé » à partir de l'échantillon original prédit tronqué. Nécessaire car l'échantillon original prédit est tronqué à [-1, 1] lorsque `self.config.clip_sample` est `True`. Si aucun troncage n'a eu lieu, le `model_output` « corrigé » coïnciderait avec celui fourni en entrée et `use_clipped_model_output` n'a aucun effet.

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

variance_noise (`torch.Tensor`) : Alternative à la génération de bruit avec `generator` en fournissant directement le bruit pour la variance elle-même. Utile pour des méthodes telles que `CycleDiffusion`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [DDIMSchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.schedulers.scheduling_ddim.DDIMSchedulerOutput) ou un `tuple`.

**Retourne :** [DDIMSchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.schedulers.scheduling_ddim.DDIMSchedulerOutput) ou `tuple`

If return_dict is `True`, [DDIMSchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.schedulers.scheduling_ddim.DDIMSchedulerOutput) 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).