# MiniMaxH3Scheduler

`MiniMaxH3Scheduler` é o scheduler Euler de fluxo retificado (`eta = 0`) com um deslocamento exponencial de sigma usado por [MiniMax-H3](https://huggingface.co/MiniMaxAI), `sigma' = s * sigma / (1 + (s - 1) * sigma)`.

Os pipelines do MiniMax-H3 registram **dois** deles, porque os latentes de vídeo e de áudio seguem dois agendamentos diferentes dentro de uma única chamada do transformer por passo: `scheduler` carrega o agendamento de vídeo (`shift=12.0` nos checkpoints liberados) e `audio_scheduler` o de áudio (`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')
```

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

**Parâmetros:**

shift (`float`, padrão `12.0`) : Deslocamento exponencial aplicado à grade de sigma, `sigma' = s*sigma / (1 + (s-1)*sigma)`. Os checkpoints liberados usam `12.0` para latentes de vídeo e `3.0` para latentes de áudio.

stochastic_sampling (`bool`, padrão `False`) : Substitui o blend de Euler por uma atualização de re-noising: prevê a amostra limpa e, em seguida, re-noiseia-a para o próximo sigma com ruído novo. Os adaptadores de poucas etapas do Pika H3 Flex foram treinados para essa atualização; os checkpoints base não foram.

shift_provided_sigmas (`bool`, *opcional*) : Se os `sigmas` explícitos passados para [set_timesteps()](/docs/diffusers/v0.43.0/pt/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps) são uma grade base que o agendador desloca, como sua grade `linspace`, ou um agendamento finalizado tomado literalmente. Se não definido, significa literalmente com um aviso de depreciação; o padrão se torna `True` em 0.44.0.

euler_update_form (`str`, padrão `"blend"`) : Como a atualização de Euler é avaliada. `"blend"` é a mistura `x_t` / `x0` `x_next = r*x_t + (1 - r)*x0`; `"velocity"` é `x_next = x_t + (sigma - sigma_next) * v`, em float32. São a mesma atualização e diferem apenas no arredondamento em float32; o MiniMax-H3-Image foi destilado com a forma de velocidade.

Agendador Euler de fluxo retificado (`eta = 0`) com um deslocamento exponencial de sigma, conforme utilizado pelo MiniMax-H3.

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

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

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

**Parâmetros:**

timestep (`float` ou `torch.Tensor`) : Um valor obtido de `self.timesteps`. O agendamento é estritamente crescente em `t`, portanto, a correspondência é única.

**Retorna:** `int`

O índice de `timestep`.

Mapeia um valor de timestep para seu índice na agenda.

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

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

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

**Parâmetros:**

sample (`torch.FloatTensor`) : A amostra limpa `x_0`.

timestep (`float` ou `torch.FloatTensor`) : O tempo alvo em `[0, 1]`; `1` retorna `sample` inalterado.

noise (`torch.FloatTensor`) : O ruído a ser misturado.

**Retorna:** `torch.FloatTensor`

A amostra com ruído.

Processo de propagação do fluxo retificado, na convenção de `t` do MiniMax-H3: `x_t = t*x_0 + (1 - t)*noise`.

MiniMax-H3 usa isso para adicionar ruído às suas âncoras de condicionamento, onde `t` é o nível `noise_aug` em vez de uma entrada do agendamento, portanto `timestep` é tomado pelo valor de face e *não* é consultado em `self.timesteps`.

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

```python
set_begin_index(begin_index: int = 0)
```

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

**Parâmetros:**

begin_index (`int`, padrão `0`) : O índice inicial para o agendador.

Define o índice inicial para o agendador.

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

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

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

**Parâmetros:**

shift (`float`) : O deslocamento exponencial a ser usado para o próximo agendamento.

Substitui o deslocamento de sigma configurado; chame antes de [set_timesteps()](/docs/diffusers/v0.43.0/pt/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps).

MiniMax-H3 expõe isso por solicitação como `flow_shift` (vídeo) / `audio_flow_shift` (áudio).

#### 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)
```

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

**Parâmetros:**

num_inference_steps (`int`, *opcional*) : Número de pontos da grade de sigma, incluindo o terminal `0`. Ignorado quando `sigmas` é fornecido.

device (`str` ou `torch.device`, *opcional*) : Dispositivo para o qual os tensores do agendamento são movidos. A própria grade é sempre construída na CPU em float32, de modo que o agendamento não dependa do acelerador.

sigmas (`list[float]` ou `torch.Tensor`, *opcional*) : Uma grade explícita, estritamente decrescente e terminando em `0.0`. Com `shift_provided_sigmas=True`, é uma grade base em `[0, 1]` que passa pelo shift como a grade `linspace`; caso contrário, é usada literalmente (padrão obsoleto).

Construa o agendamento de sigma / timestep.

A grade é `linspace(1, 0, num_inference_steps)` submetida ao deslocamento exponencial, com duplicatas consecutivas colapsadas, ou os `sigmas` explícitos, também deslocados quando `shift_provided_sigmas` está definido. O terminal `0` já faz parte da grade — o deslocamento mapeia `0` exatamente para `0` — de modo que a agenda mantém `num_inference_steps` sigmas e dirige `num_inference_steps - 1` avaliações do modelo, expostas como `self.timesteps = 1 - sigmas[:-1]`.

#### etapa[[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)
```

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

**Parâmetros:**

model_output (`torch.FloatTensor`) : A previsão de velocidade do transformer no `timestep`.

timestep (`float` ou `torch.FloatTensor`) : O timestep atual, um dos `self.timesteps` (ou seja, `timestep == 1 - sigma`).

sample (`torch.FloatTensor`) : A amostra atual `x_t`.

generator (`torch.Generator`, *opcional*) : O gerador do qual o novo ruído é extraído com `stochastic_sampling`; não utilizado caso contrário.

return_dict (`bool`, padrão `True`) : Se deve retornar um `MiniMaxH3SchedulerOutput` em vez de uma tupla simples.

**Retorna:** `MiniMaxH3SchedulerOutput` ou `tuple`

a amostra para a próxima etapa.

Faça um passo de Euler (`eta = 0`) ou um passo de re-ruído com `stochastic_sampling`.

A saída do modelo é uma velocidade em direção aos dados, portanto a estimativa desruída é `x0 = x_t + (1 - t) * v` — observe o `+`, o oposto da convenção usual de flow-match. A atualização é então a mistura `x_next = r*x_t + (1 - r)*x0` com `r = sigma_next / sigma`, avaliada em float32 para amostras de meia precisão. Com `stochastic_sampling`, a atualização é `x_next = (1 - sigma_next) * x0 + sigma_next * noise` com ruído novo de `generator`, tudo em float32, de modo que o último passo (`sigma_next = 0`) retorna `x0`. Com `euler_update_form="velocity"`, a mesma atualização de Euler é avaliada como `x_next = x_t + (sigma - sigma_next) * v` em 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)
```

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

**Parâmetros:**

prev_sample (`torch.FloatTensor`) : Amostra `x_{t+1}` calculada para a próxima etapa do loop de desruidamento.

Classe de saída para a saída da função `step` do agendador.