# MiniMaxH3Scheduler

`MiniMaxH3Scheduler` est le planificateur Euler de flux rectifié (`eta = 0`) avec un décalage exponentiel de sigma utilisé par [MiniMax-H3](https://huggingface.co/MiniMaxAI), `sigma' = s * sigma / (1 + (s - 1) * sigma)`.

Les pipelines MiniMax-H3 enregistrent **deux** d’entre eux, car les latents vidéo et audio suivent deux calendriers distincts au sein d’un seul appel au transformateur par étape : `scheduler` porte le calendrier vidéo (`shift=12.0` dans les points de contrôle publiés) et `audio_scheduler` le calendrier audio (`shift=3.0`).

## MiniMaxH3Scheduler[[diffusers.MiniMaxH3Scheduler]]

#### diffusers.MiniMaxH3Scheduler[[diffusers.MiniMaxH3Scheduler]]

```python
diffusers.MiniMaxH3Scheduler(shift: float = 12.0, stochastic_sampling: bool = False, shift_provided_sigmas: bool | None = None, euler_update_form: str = 'blend')
```

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

**Paramètres :**

shift (`float`, par défaut `12.0`) : Décalage exponentiel appliqué à la grille des sigmas, `sigma' = s*sigma / (1 + (s-1)*sigma)`. Les points de contrôle publiés utilisent `12.0` pour les latents vidéo et `3.0` pour les latents audio.

stochastic_sampling (`bool`, par défaut `False`) : Remplace le mélange d’Euler par une mise à jour de re-bruitage : prédit l’échantillon propre, puis le re-bruit jusqu’au sigma suivant avec du bruit neuf. Les adaptateurs Pika H3 Flex à peu d’étapes ont été entraînés pour cette mise à jour ; ce n’est pas le cas des points de contrôle de base.

shift_provided_sigmas (`bool`, *facultatif*) : Indique si les `sigmas` explicites passés à [set_timesteps()](/docs/diffusers/v0.43.0/fr/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps) constituent une grille de base que le planificateur décale, comme sa grille `linspace`, ou un calendrier final utilisé tel quel. Si non défini, le calendrier est utilisé tel quel avec un avertissement de non-recommandation ; la valeur par défaut devient `True` dans la version 0.44.0.

euler_update_form (`str`, par défaut `"blend"`) : La manière dont la mise à jour d'Euler est évaluée. `"blend"` correspond au mélange `x_t` / `x0` `x_next = r*x_t + (1 - r)*x0` ; `"velocity"` correspond à `x_next = x_t + (sigma - sigma_next) * v`, en float32. Il s'agit de la même mise à jour, qui ne diffère que par l'arrondi en float32 ; MiniMax-H3-Image a été distillé avec la forme velocity.

Planificateur Euler de flux rectifié (`eta = 0`) avec un décalage exponentiel de sigma, tel que utilisé par MiniMax-H3.

#### index_for_timestep[[diffusers.MiniMaxH3Scheduler.index_for_timestep]]

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

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

**Paramètres :**

timestep (`float` ou `torch.Tensor`) : une valeur issue de `self.timesteps`. L'ordonnancement est strictement croissant en `t`, donc la correspondance est unique.

**Retourne :** `int`

L'indice de `timestep`.

Associer une valeur de pas de temps à son index dans le calendrier.

#### scale_noise[[diffusers.MiniMaxH3Scheduler.scale_noise]]

```python
scale_noise(sample: FloatTensor, timestep: typing.Union[float, torch.FloatTensor], noise: FloatTensor)
```

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

**Paramètres :**

sample (`torch.FloatTensor`) : L'échantillon propre `x_0`.

timestep (`float` ou `torch.FloatTensor`) : l'heure cible dans `[0, 1]` ; `1` renvoie `sample` inchangé.

noise (`torch.FloatTensor`) : Le bruit à mélanger.

**Retourne :** `torch.FloatTensor`

L'échantillon bruité.

Processus avant du flux rectifié, selon la convention de `t` de MiniMax-H3 : `x_t = t*x_0 + (1 - t)*noise`.

MiniMax-H3 utilise cela pour ajouter du bruit à ses ancres de conditionnement, où `t` est le niveau `noise_aug` plutôt qu'une entrée du planning, de sorte que `timestep` est pris à la lettre et n'est *pas* recherché dans `self.timesteps`.

#### set_begin_index[[diffusers.MiniMaxH3Scheduler.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_minimax_h3.py#L138)

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

#### set_shift[[diffusers.MiniMaxH3Scheduler.set_shift]]

```python
set_shift(shift: float)
```

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

**Paramètres :**

shift (`float`) : Le décalage exponentiel à utiliser pour le prochain planning.

Remplace le décalage sigma configuré ; à appeler avant [set_timesteps()](/docs/diffusers/v0.43.0/fr/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps).

MiniMax-H3 expose cette valeur par requête sous la forme de `flow_shift` (vidéo) / `audio_flow_shift` (audio).

#### set_timesteps[[diffusers.MiniMaxH3Scheduler.set_timesteps]]

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

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

**Paramètres :**

num_inference_steps (`int`, *facultatif*) : Nombre de points de la grille de sigma, le terminal `0` inclus. Ignoré lorsque `sigmas` est fourni.

device (`str` ou `torch.device`, *facultatif*) : Appareil sur lequel les tenseurs du planning sont déplacés. La grille elle-même est toujours construite sur CPU en float32, de sorte que le planning ne dépend pas de l'accélérateur.

sigmas (`list[float]` ou `torch.Tensor`, *facultatif*) : une grille explicite, strictement décroissante et se terminant à `0.0`. Avec `shift_provided_sigmas=True`, il s'agit d'une grille de base dans `[0, 1]` qui subit le décalage comme la grille `linspace` ; sinon, elle est utilisée telle quelle (défaut obsolète).

Construire le calendrier sigma / timestep.

La grille est `linspace(1, 0, num_inference_steps)` passée à travers le décalage exponentiel, avec les doublons consécutifs fusionnés, ou les `sigmas` explicites, décalés également lorsque `shift_provided_sigmas` est défini. Le `0` terminal fait déjà partie de la grille — le décalage mappe `0` exactement sur `0` — de sorte que le planning contient `num_inference_steps` sigmas et pilote `num_inference_steps - 1` évaluations du modèle, exposées sous la forme `self.timesteps = 1 - sigmas[:-1]`.

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

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

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

**Paramètres :**

model_output (`torch.FloatTensor`) : La prédiction de vitesse du transformateur à l'`timestep`.

timestep (`float` ou `torch.FloatTensor`) : L'étape temporelle actuelle, l'une des valeurs de `self.timesteps` (donc `timestep == 1 - sigma`).

sample (`torch.FloatTensor`) : L'échantillon actuel `x_t`.

generator (`torch.Generator`, *facultatif*) : Le générateur à partir duquel le bruit frais est tiré avec `stochastic_sampling` ; inutilisé dans le cas contraire.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `MiniMaxH3SchedulerOutput` plutôt qu'un simple tuple.

**Retourne :** `MiniMaxH3SchedulerOutput` ou `tuple`

l'échantillon pour l'étape suivante.

Effectuez une étape d'Euler (`eta = 0`) ou une étape de re-bruitage avec `stochastic_sampling`.

La sortie du modèle est une vitesse orientée données, donc l'estimation débruitée est `x0 = x_t + (1 - t) * v` — notez le `+`, l'opposé de la convention habituelle de flow-match. La mise à jour est ensuite le mélange `x_next = r*x_t + (1 - r)*x0` avec `r = sigma_next / sigma`, évalué en float32 pour les échantillons en demi-précision. Avec `stochastic_sampling`, la mise à jour est `x_next = (1 - sigma_next) * x0 + sigma_next * noise` avec du bruit frais issu de `generator`, le tout en float32, de sorte que la dernière étape (`sigma_next = 0`) renvoie `x0`. Avec `euler_update_form="velocity"`, la même mise à jour Euler est évaluée comme `x_next = x_t + (sigma - sigma_next) * v` en float32.

## MiniMaxH3SchedulerOutput[[diffusers.schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput]]

#### diffusers.schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput[[diffusers.schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput]]

```python
diffusers.schedulers.scheduling_minimax_h3.MiniMaxH3SchedulerOutput(prev_sample: FloatTensor)
```

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

**Paramètres :**

prev_sample (`torch.FloatTensor`) : Échantillon calculé `x_{t+1}` pour l'étape suivante de la boucle de débruitage.

Classe de sortie pour la sortie de la fonction `step` du planificateur.