# MiniMaxH3Scheduler

`MiniMaxH3Scheduler` es el planificador Euler de flujo rectificado (`eta = 0`) con un desplazamiento exponencial de sigma utilizado por [MiniMax-H3](https://huggingface.co/MiniMaxAI), `sigma' = s * sigma / (1 + (s - 1) * sigma)`.

Los pipelines de MiniMax-H3 registran **dos** de ellos, porque los latentes de video y de audio siguen dos agendas diferentes dentro de una sola llamada al transformer por paso: `scheduler` lleva la agenda de video (`shift=12.0` en los puntos de control publicados) y `audio_scheduler` la de 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')
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L73)

**Parámetros:**

shift (`float`, por defecto `12.0`) : Desplazamiento exponencial aplicado a la cuadrícula de sigma, `sigma' = s*sigma / (1 + (s-1)*sigma)`. Los puntos de control publicados utilizan `12.0` para los latentes de video y `3.0` para los latentes de audio.

stochastic_sampling (`bool`, por defecto `False`) : Reemplaza la mezcla de Euler con una actualización de re-ruído: predice la muestra limpia y luego la vuelve a ruidar hasta la siguiente sigma con ruido nuevo. Los adaptadores de pocos pasos de Pika H3 Flex fueron entrenados para esta actualización; los puntos de control base no.

shift_provided_sigmas (`bool`, *opcional*) : Si los `sigmas` explícitos pasados a [set_timesteps()](/docs/diffusers/main/es/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps) son una cuadrícula base que el programador desplaza, como su cuadrícula `linspace`, o un programa terminado tomado tal cual. Si no se establece, se toma tal cual con una advertencia de obsolescencia; el valor predeterminado será `True` en 0.44.0.

euler_update_form (`str`, por defecto `"blend"`) : Cómo se evalúa la actualización de Euler. `"blend"` es la mezcla `x_t` / `x0` `x_next = r*x_t + (1 - r)*x0`; `"velocity"` es `x_next = x_t + (sigma - sigma_next) * v`, en float32. Son la misma actualización y solo difieren en el redondeo de float32; MiniMax-H3-Image se destiló con la forma de velocidad.

Planificador Euler de flujo rectificado (`eta = 0`) con un desplazamiento exponencial de sigma, tal como lo utiliza MiniMax-H3.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L225)

**Parámetros:**

timestep (`float` o `torch.Tensor`) : Un valor tomado de `self.timesteps`. La secuencia es estrictamente creciente en `t`, por lo que la coincidencia es única.

**Devuelve:** `int`

El índice de `timestep`.

Mapea un valor de paso de tiempo a su índice en la programación.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L246)

**Parámetros:**

sample (`torch.FloatTensor`) : La muestra limpia `x_0`.

timestep (`float` o `torch.FloatTensor`) : El tiempo objetivo en `[0, 1]`; `1` devuelve `sample` sin cambios.

noise (`torch.FloatTensor`) : El ruido que se mezclará.

**Devuelve:** `torch.FloatTensor`

La muestra con ruido.

Proceso de avance de flujo rectificado, según la convención de `t` de MiniMax-H3: `x_t = t*x_0 + (1 - t)*noise`.

MiniMax-H3 uses this to noise its conditioning anchors, where `t` is the `noise_aug` level rather than a schedule entry, so `timestep` is taken at face value and is *not* looked up in `self.timesteps`.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L138)

**Parámetros:**

begin_index (`int`, por defecto `0`) : El índice inicial del programador.

Establece el índice inicial del programador.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L148)

**Parámetros:**

shift (`float`) : El desplazamiento exponencial a utilizar para el siguiente planificador.

Anula el desplazamiento de sigma configurado; llámalo antes de [set_timesteps()](/docs/diffusers/main/es/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler.set_timesteps).

MiniMax-H3 expone esto por solicitud como `flow_shift` (vídeo) / `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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L162)

**Parámetros:**

num_inference_steps (`int`, *opcional*) : Número de puntos de la cuadrícula de sigma, incluido el terminal `0`. Se ignora cuando se proporciona `sigmas`.

device (`str` o `torch.device`, *opcional*) : Dispositivo al que se mueven los tensores de la programación. La cuadrícula en sí siempre se construye en CPU en float32, por lo que la programación no depende del acelerador.

sigmas (`list[float]` o `torch.Tensor`, *opcional*) : Una cuadrícula explícita, estrictamente decreciente y que termina en `0.0`. Con `shift_provided_sigmas=True` es una cuadrícula base en `[0, 1]` que pasa por el desplazamiento como la cuadrícula `linspace`; de lo contrario, se usa tal cual (valor predeterminado obsoleto).

Construir la programación de sigma / timestep.

La cuadrícula es `linspace(1, 0, num_inference_steps)` procesada mediante el desplazamiento exponencial, con los duplicados consecutivos colapsados, o bien los `sigmas` explícitos, desplazados también cuando se establece `shift_provided_sigmas`. El `0` terminal ya forma parte de la cuadrícula: el desplazamiento mapea `0` exactamente a `0`, por lo que la secuencia contiene `num_inference_steps` sigmas y dirige `num_inference_steps - 1` evaluaciones del modelo, expuestas como `self.timesteps = 1 - sigmas[:-1]`.

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L278)

**Parámetros:**

model_output (`torch.FloatTensor`) : La predicción de velocidad del transformer en el `timestep`.

timestep (`float` o `torch.FloatTensor`) : El paso temporal actual, uno de `self.timesteps` (por lo que `timestep == 1 - sigma`).

sample (`torch.FloatTensor`) : La muestra actual `x_t`.

generator (`torch.Generator`, *opcional*) : El generador del que se extrae el ruido nuevo con `stochastic_sampling`; no se utiliza en caso contrario.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un `MiniMaxH3SchedulerOutput` en lugar de una tupla simple.

**Devuelve:** `MiniMaxH3SchedulerOutput` o `tuple`

la muestra para el siguiente paso.

Realiza un paso de Euler (`eta = 0`) o un paso de re-ruido con `stochastic_sampling`.

La salida del modelo es una velocidad data-ward, por lo que la estimación desruidada es `x0 = x_t + (1 - t) * v` — fíjate en el `+`, lo opuesto a la convención habitual de flow-match. La actualización es entonces la mezcla `x_next = r*x_t + (1 - r)*x0` con `r = sigma_next / sigma`, evaluada en float32 para muestras de media precisión. Con `stochastic_sampling` la actualización es `x_next = (1 - sigma_next) * x0 + sigma_next * noise` con ruido nuevo de `generator`, todo en float32, de modo que el último paso (`sigma_next = 0`) devuelve `x0`. Con `euler_update_form="velocity"` la misma actualización de Euler se evalúa como `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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_minimax_h3.py#L61)

**Parámetros:**

prev_sample (`torch.FloatTensor`) : Muestra `x_{t+1}` calculada para el siguiente paso del bucle de desruido.

Clase de salida para la salida de la función `step` del programador.