# DPMSolverMultistepInverse

`DPMSolverMultistepInverse` es el programador invertido de [DPM-Solver: A Fast ODE Solver for Diffusion Probabilistic Model Sampling in Around 10 Steps](https://huggingface.co/papers/2206.00927) y [DPM-Solver++: Fast Solver for Guided Sampling of Diffusion Probabilistic Models](https://huggingface.co/papers/2211.01095) de Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li y Jun Zhu.

La implementación se basa principalmente en la definición de inversión DDIM de [Null-text Inversion for Editing Real Images using Guided Diffusion Models](https://huggingface.co/papers/2211.09794) y en la implementación del notebook de la inversión latente de `DiffEdit` de [Xiang-cd/DiffEdit-stable-diffusion](https://github.com/Xiang-cd/DiffEdit-stable-diffusion/blob/main/diffedit.ipynb).

## Consejos

El umbral dinámico de [Imagen](https://huggingface.co/papers/2205.11487) es compatible. En los modelos de difusión en el espacio de píxeles, puedes establecer tanto `algorithm_type="dpmsolver++"` como `thresholding=True` para utilizar el umbral dinámico. Este método de umbral no es adecuado para los modelos de difusión en el espacio latente, como Stable Diffusion.

## DPMSolverMultistepInverseScheduler[[diffusers.DPMSolverMultistepInverseScheduler]]

#### diffusers.DPMSolverMultistepInverseScheduler[[diffusers.DPMSolverMultistepInverseScheduler]]

```python
diffusers.DPMSolverMultistepInverseScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.0001, beta_end: float = 0.02, beta_schedule: typing.Literal['linear', 'scaled_linear', 'squaredcos_cap_v2'] = 'linear', trained_betas: numpy.ndarray | list[float] | None = None, solver_order: int = 2, prediction_type: typing.Literal['epsilon', 'sample', 'v_prediction', 'flow_prediction'] = 'epsilon', thresholding: bool = False, dynamic_thresholding_ratio: float = 0.995, sample_max_value: float = 1.0, algorithm_type: typing.Literal['dpmsolver', 'dpmsolver++', 'sde-dpmsolver', 'sde-dpmsolver++'] = 'dpmsolver++', solver_type: typing.Literal['midpoint', 'heun'] = 'midpoint', lower_order_final: bool = True, euler_at_final: bool = False, use_karras_sigmas: bool = False, use_exponential_sigmas: bool = False, use_beta_sigmas: bool = False, use_flow_sigmas: bool = False, flow_shift: float = 1.0, lambda_min_clipped: float = -inf, variance_type: typing.Optional[typing.Literal['learned', 'learned_range']] = None, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'linspace', steps_offset: int = 0)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L86)

**Parámetros:**

num_train_timesteps (`int`, por defecto 1000) : El número de pasos de difusión para entrenar el modelo.

beta_start (`float`, por defecto 0.0001) : El valor inicial de `beta` para la inferencia.

beta_end (`float`, por defecto 0.02) : El valor final de `beta`.

beta_schedule (`str`, por defecto `"linear"`) : La programación de beta, un mapeo desde un rango de beta hasta una secuencia de betas para dar pasos al modelo. Elija entre `linear`, `scaled_linear` o `squaredcos_cap_v2`.

trained_betas (`np.ndarray`, *opcional*) : Pasa un array de betas directamente al constructor para omitir `beta_start` y `beta_end`.

solver_order (`int`, valor predeterminado 2) : El orden de DPMSolver, que puede ser `1` o `2` o `3`. Se recomienda usar `solver_order=2` para muestreo guiado y `solver_order=3` para muestreo incondicional.

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`, por defecto `False`) : Si se debe utilizar el método de "umbral dinámico". No es adecuado para modelos de difusión en el espacio latente, como Stable Diffusion.

dynamic_thresholding_ratio (`float`, por defecto 0.995) : La proporción para el método de umbral dinámico. Solo es válido cuando `thresholding=True`.

sample_max_value (`float`, por defecto 1.0) : El valor de umbral para el umbral dinámico. Válido solo cuando `thresholding=True` y `algorithm_type="dpmsolver++"`.

algorithm_type (`str`, por defecto `dpmsolver++`) : Tipo de algoritmo para el solver; puede ser `dpmsolver`, `dpmsolver++`, `sde-dpmsolver` o `sde-dpmsolver++`. El tipo `dpmsolver` implementa los algoritmos del artículo [DPMSolver](https://huggingface.co/papers/2206.00927), y el tipo `dpmsolver++` implementa los algoritmos del artículo [DPMSolver++](https://huggingface.co/papers/2211.01095). Se recomienda usar `dpmsolver++` o `sde-dpmsolver++` con `solver_order=2` para muestreo guiado, como en Stable Diffusion.

solver_type (`str`, por defecto `midpoint`) : Tipo de solver para el solver de segundo orden; puede ser `midpoint` o `heun`. El tipo de solver afecta ligeramente a la calidad de la muestra, especialmente con un número pequeño de pasos. Se recomienda usar solvers `midpoint`.

lower_order_final (`bool`, por defecto `True`) : Si se deben usar solvers de orden inferior en los pasos finales. Solo es válido para < 15 pasos de inferencia. Esto puede estabilizar el muestreo de DPMSolver para pasos < 15, especialmente para pasos <= 10.

euler_at_final (`bool`, por defecto `False`) : Si se debe utilizar el método de Euler en el paso final. Es un equilibrio entre la estabilidad numérica y la riqueza de detalle. Esto puede estabilizar el muestreo de la variante SDE de DPMSolver para un número pequeño de pasos de inferencia, pero a veces puede resultar en un desenfoque.

use_karras_sigmas (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar sigmas de Karras para los tamaños de paso en el plan de ruido durante el proceso de muestreo. Si es `True`, los sigmas se determinan según una secuencia de niveles de ruido {σi}.

use_exponential_sigmas (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar sigmas exponenciales para los tamaños de paso en el plan de ruido durante el proceso de muestreo.

use_beta_sigmas (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar sigmas beta para los tamaños de paso en el plan de ruido durante el proceso de muestreo. Consulte [Beta Sampling is All You Need](https://huggingface.co/papers/2407.12173) para obtener más información.

use_flow_sigmas (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar sigmas de flujo para los tamaños de paso en el plan de ruido durante el proceso de muestreo.

flow_shift (`float`, *opcional*, valor predeterminado 1.0) : El factor de desplazamiento de flujo. Solo es válido cuando `use_flow_sigmas=True`.

lambda_min_clipped (`float`, por defecto `-inf`) : Umbral de recorte para el valor mínimo de `lambda(t)` para la estabilidad numérica. Esto es crítico para el plan de ruido coseno (`squaredcos_cap_v2`).

variance_type (`str`, *opcional*) : Establezca "learned" o "learned_range" para modelos de difusión que predicen la varianza. Si se establece, la salida del modelo contiene la varianza gaussiana predicha.

timestep_spacing (`str`, por defecto `"linspace"`) : La forma en que deben escalarse los pasos de tiempo. Consulte la Tabla 2 de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) para obtener más información.

steps_offset (`int`, valor predeterminado 0) : Un desplazamiento que se suma a los pasos de inferencia, tal como lo requieren algunas familias de modelos.

`DPMSolverMultistepInverseScheduler` es el programador inverso de [DPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler).

Este modelo hereda de [SchedulerMixin](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.SchedulerMixin) y [ConfigMixin](/docs/diffusers/v0.43.0/es/api/configuration#diffusers.ConfigMixin). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los programadores, como la carga y el guardado.

#### add_noise[[diffusers.DPMSolverMultistepInverseScheduler.add_noise]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L1118)

**Parámetros:**

original_samples (`torch.Tensor`) : Las muestras originales a las que se les añadirá ruido.

noise (`torch.Tensor`) : El tensor de ruido.

timesteps (`torch.IntTensor`) : Los pasos de tiempo en los que se añade ruido.

**Devuelve:** `torch.Tensor`

Las muestras ruidosas.

Añada ruido a las `original_samples` limpias usando la función equivalente del programador.

#### convert_model_output[[diffusers.DPMSolverMultistepInverseScheduler.convert_model_output]]

```python
convert_model_output(model_output: Tensor, *args, sample: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L600)

**Parámetros:**

model_output (`torch.Tensor`) : La salida directa del modelo de difusión aprendido.

sample (`torch.Tensor`, *opcional*) : Una instancia actual de una muestra creada por el proceso de difusión.

**Devuelve:** `torch.Tensor`

La salida del modelo convertido.

Convierta la salida del modelo al tipo correspondiente que necesita el algoritmo DPMSolver/DPMSolver++. DPM-Solver está diseñado para discretizar una integral del modelo de predicción de ruido, y DPM-Solver++ está diseñado para discretizar una integral del modelo de predicción de datos.

> [!TIP] > El algoritmo y el tipo de modelo están desacoplados. Puedes usar DPMSolver o DPMSolver++ para ambos
ruido > predicción y modelos de predicción de datos.

#### dpm_solver_first_order_update[[diffusers.DPMSolverMultistepInverseScheduler.dpm_solver_first_order_update]]

```python
dpm_solver_first_order_update(model_output: Tensor, *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L699)

**Parámetros:**

model_output (`torch.Tensor`) : La salida directa del modelo de difusión aprendido.

sample (`torch.Tensor`, *opcional*) : Una instancia actual de una muestra creada por el proceso de difusión.

noise (`torch.Tensor`, *opcional*) : El tensor de ruido.

**Devuelve:** `torch.Tensor`

El tensor de muestra en el paso de tiempo anterior.

Un paso para el DPMSolver de primer orden (equivalente a DDIM).

#### multistep_dpm_solver_second_order_update[[diffusers.DPMSolverMultistepInverseScheduler.multistep_dpm_solver_second_order_update]]

```python
multistep_dpm_solver_second_order_update(model_output_list: list[torch.Tensor], *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L774)

**Parámetros:**

model_output_list (`list[torch.Tensor]`) : Las salidas directas del modelo de difusión aprendido en los pasos de tiempo actuales y posteriores.

sample (`torch.Tensor`, *opcional*) : Una instancia actual de una muestra creada por el proceso de difusión.

noise (`torch.Tensor`, *opcional*) : Ruido aleatorio utilizado por las variantes de resolventor estocástico (`sde-*`). Es obligatorio cuando `algorithm_type` se establece en una de ellas y no se utiliza en caso contrario.

**Devuelve:** `torch.Tensor`

El tensor de muestra en el paso de tiempo anterior.

Un paso para el DPMSolver multipaso de segundo orden.

#### multistep_dpm_solver_third_order_update[[diffusers.DPMSolverMultistepInverseScheduler.multistep_dpm_solver_third_order_update]]

```python
multistep_dpm_solver_third_order_update(model_output_list: list[torch.Tensor], *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L901)

**Parámetros:**

model_output_list (`list[torch.Tensor]`) : Las salidas directas del modelo de difusión aprendido en los pasos de tiempo actuales y posteriores.

sample (`torch.Tensor`, *opcional*) : Una instancia actual de una muestra creada por el proceso de difusión.

noise (`torch.Tensor`, *opcional*) : El tensor de ruido.

**Devuelve:** `torch.Tensor`

El tensor de muestra en el paso de tiempo anterior.

Un paso para el DPMSolver multipaso de tercer orden.

#### scale_model_input[[diffusers.DPMSolverMultistepInverseScheduler.scale_model_input]]

```python
scale_model_input(sample: Tensor, *args, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L1103)

**Parámetros:**

sample (`torch.Tensor`) : La muestra de entrada.

**Devuelve:** `torch.Tensor`

Una muestra de entrada escalada.

Garantiza la interoperabilidad con los programadores que necesitan escalar la entrada del modelo de desruido en función del paso temporal actual.

#### set_timesteps[[diffusers.DPMSolverMultistepInverseScheduler.set_timesteps]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L283)

**Parámetros:**

num_inference_steps (`int`) : El número de pasos de difusión utilizados al generar muestras con un modelo preentrenado.

device (`str` o `torch.device`, *opcional*) : El dispositivo al que deben moverse los pasos de tiempo. Si es `None`, los pasos de tiempo no se mueven.

Establece los pasos discretos utilizados para la cadena de difusión (para ejecutarse antes de la inferencia).

#### paso[[diffusers.DPMSolverMultistepInverseScheduler.step]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L1017)

**Parámetros:**

model_output (`torch.Tensor`) : La salida directa del modelo de difusión aprendido.

timestep (`int`) : El paso de tiempo discreto actual en la cadena de difusión.

sample (`torch.Tensor`) : Una instancia actual de una muestra creada por el proceso de difusión.

generator (`torch.Generator`, *opcional*) : Un generador de números aleatorios.

variance_noise (`torch.Tensor`) : Alternativa a generar ruido con `generator` proporcionando directamente el ruido para la varianza. Útil para métodos como `CycleDiffusion`.

return_dict (`bool`) : Si se debe devolver un [SchedulerOutput](/docs/diffusers/v0.43.0/es/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) o un `tuple`.

**Devuelve:** [SchedulerOutput](/docs/diffusers/v0.43.0/es/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) o `tuple`

If return_dict es `True`, se devuelve [SchedulerOutput](/docs/diffusers/v0.43.0/es/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput); en caso contrario, se devuelve una tupla cuyo primer elemento es el tensor de muestras.

Predice la muestra del paso de tiempo anterior invirtiendo la EDE. Esta función propaga la muestra con el DPMSolver de múltiples pasos.

## SchedulerOutput[[diffusers.schedulers.scheduling_utils.SchedulerOutput]]

#### diffusers.schedulers.scheduling_utils.SchedulerOutput[[diffusers.schedulers.scheduling_utils.SchedulerOutput]]

```python
diffusers.schedulers.scheduling_utils.SchedulerOutput(prev_sample: Tensor)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_utils.py#L66)

**Parámetros:**

prev_sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` para imágenes) : Muestra `(x_{t-1})` calculada del paso de tiempo anterior. `prev_sample` debe usarse como entrada del modelo en la siguiente iteración del bucle de desruido.

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