# PNDMScheduler

`PNDMScheduler`, o métodos numéricos pseudo para modelos de difusión, utiliza técnicas de integración de EDO más avanzadas, como Runge-Kutta y el método lineal de varios pasos. La implementación original se puede encontrar en [crowsonkb/k-diffusion](https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181).

## PNDMScheduler[[diffusers.PNDMScheduler]]

#### diffusers.PNDMScheduler[[diffusers.PNDMScheduler]]

```python
diffusers.PNDMScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.0001, beta_end: float = 0.02, beta_schedule: str = 'linear', trained_betas: numpy.ndarray | list[float] | None = None, skip_prk_steps: bool = False, set_alpha_to_one: bool = False, prediction_type: typing.Literal['epsilon', 'v_prediction'] = 'epsilon', timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'leading', steps_offset: int = 0)
```

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

**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 (`"linear"`, `"scaled_linear"` o `"squaredcos_cap_v2"`, por defecto `"linear"`) : El programa de betas, una función que mapea un rango de betas a una secuencia de betas para dar pasos al modelo.

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

skip_prk_steps (`bool`, por defecto `False`) : Permite al planificador omitir los pasos de Runge-Kutta definidos en el artículo original como necesarios antes de los pasos de PLMS.

set_alpha_to_one (`bool`, por defecto `False`) : Cada paso de difusión utiliza el valor del producto de alfas en ese paso y en el anterior. En el paso final no hay un alfa anterior. Cuando esta opción es `True`, el producto de alfas anterior se fija en `1`; de lo contrario, se utiliza el valor de alfa en el paso 0.

prediction_type (`"epsilon"` o `"v_prediction"`, por defecto `"epsilon"`) : Tipo de predicción de la función del programador; puede ser `epsilon` (predice el ruido del proceso de difusión) o `v_prediction` (ver la sección 2.4 del artículo [Imagen Video](https://huggingface.co/papers/2210.02303)).

timestep_spacing (`"linspace"`, `"leading"` o `"trailing"`, por defecto `"leading"`) : La forma en que se deben escalar 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`, por defecto `0`) : Un desplazamiento que se suma a los pasos de inferencia, tal como lo requieren algunas familias de modelos.

`PNDMScheduler` utiliza métodos numéricos pseudo para modelos de difusión, como el método de Runge-Kutta y el método lineal de varios pasos.

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.PNDMScheduler.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_pndm.py#L461)

**Parámetros:**

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

noise (`torch.Tensor`) : El ruido que se añadirá a las muestras.

timesteps (`torch.IntTensor`) : Los pasos de tiempo que indican el nivel de ruido para cada muestra.

**Devuelve:** `torch.Tensor`

Las muestras ruidosas.

Añada ruido a las muestras originales según la magnitud del ruido en cada paso temporal (este es el proceso de difusión hacia adelante).

#### scale_model_input[[diffusers.PNDMScheduler.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_pndm.py#L394)

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

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

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

**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.PNDMScheduler.step]]

```python
step(model_output: Tensor, timestep: int, sample: Tensor, return_dict: bool = True)
```

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

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

return_dict (`bool`, por defecto `True`) : Si se devuelve 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 el SDE. Esta función propaga el proceso de difusión desde las salidas del modelo aprendido (con mayor frecuencia el ruido predicho) y llama a [step_prk()](/docs/diffusers/v0.43.0/es/api/schedulers/pndm#diffusers.PNDMScheduler.step_prk) o [step_plms()](/docs/diffusers/v0.43.0/es/api/schedulers/pndm#diffusers.PNDMScheduler.step_plms) dependiendo de la variable interna `counter`.

#### step_plms[[diffusers.PNDMScheduler.step_plms]]

```python
step_plms(model_output: Tensor, timestep: int, sample: Tensor, return_dict: bool = True)
```

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

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

return_dict (`bool`, por defecto `True`) : Si se devuelve un [SchedulerOutput](/docs/diffusers/v0.43.0/es/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) o una tupla.

**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 el SDE. Esta función propaga la muestra con el método de multipaso lineal. Realiza una pasada hacia adelante varias veces para aproximar la solución.

#### step_prk[[diffusers.PNDMScheduler.step_prk]]

```python
step_prk(model_output: Tensor, timestep: int, sample: Tensor, return_dict: bool = True)
```

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

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

return_dict (`bool`, por defecto `True`) : Si se devuelve un [SchedulerOutput](/docs/diffusers/v0.43.0/es/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) o una tupla.

**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 método de Runge-Kutta. Realiza cuatro pases hacia adelante para aproximar la solución de la ecuación diferencial.

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