# CMStochasticIterativeScheduler

[Consistency Models](https://huggingface.co/papers/2303.01469), de Yang Song, Prafulla Dhariwal, Mark Chen e Ilya Sutskever, apresentou um agendador multietapa e de etapa única (Algoritmo 1) capaz de gerar boas amostras em uma ou um pequeno número de etapas.

O resumo do artigo é:

*Os modelos de difusão avançaram significativamente os campos de geração de imagens, áudio e vídeo, mas dependem de um processo de amostragem iterativo que causa uma geração lenta. Para superar essa limitação, propomos os modelos de consistência, uma nova família de modelos que geram amostras de alta qualidade mapeando diretamente o ruído para os dados. Eles suportam, por design, a geração rápida em uma única etapa, ao mesmo tempo em que permitem a amostragem em múltiplas etapas para trocar computação por qualidade da amostra. Eles também suportam edição de dados zero-shot, como inpainting de imagens, colorização e super-resolução, sem exigir treinamento explícito nessas tarefas. Os modelos de consistência podem ser treinados seja destilando modelos de difusão pré-treinados, seja como modelos generativos independentes. Por meio de extensos experimentos, demonstramos que eles superam as técnicas de destilação existentes para modelos de difusão na amostragem em uma e poucas etapas, alcançando o novo estado da arte de FID de 3,55 no CIFAR-10 e 6,20 no ImageNet 64x64 para geração em uma única etapa. Quando treinados de forma isolada, os modelos de consistência se tornam uma nova família de modelos generativos que podem superar os modelos generativos existentes de uma etapa e não adversariais em benchmarks padrão, como CIFAR-10, ImageNet 64x64 e LSUN 256x256.*

O código original pode ser encontrado em [openai/consistency_models](https://github.com/openai/consistency_models).

## CMStochasticIterativeScheduler[[diffusers.CMStochasticIterativeScheduler]]

#### diffusers.CMStochasticIterativeScheduler[[diffusers.CMStochasticIterativeScheduler]]

```python
diffusers.CMStochasticIterativeScheduler(num_train_timesteps: int = 40, sigma_min: float = 0.002, sigma_max: float = 80.0, sigma_data: float = 0.5, s_noise: float = 1.0, rho: float = 7.0, clip_denoised: bool = True)
```

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

**Parâmetros:**

num_train_timesteps (`int`, padrão 40) : O número de etapas de difusão para treinar o modelo.

sigma_min (`float`, padrão 0.002) : Magnitude mínima de ruído no agendamento de sigma. O padrão é 0.002, conforme a implementação original.

sigma_max (`float`, padrão 80.0) : Magnitude máxima de ruído no agendamento de sigma. O padrão é 80.0, conforme a implementação original.

sigma_data (`float`, padrão 0.5) : O desvio padrão da distribuição dos dados do [artigo](https://huggingface.co/papers/2206.00364) do EDM. O padrão é 0.5, conforme a implementação original.

s_noise (`float`, padrão 1.0) : A quantidade de ruído adicional para compensar a perda de detalhes durante a amostragem. Um intervalo razoável é [1.000, 1.011]. O padrão é 1.0, conforme a implementação original.

rho (`float`, padrão 7.0) : O parâmetro para calcular o agendamento de sigma Karras a partir do [artigo](https://huggingface.co/papers/2206.00364) do EDM. O padrão é 7.0, conforme a implementação original.

clip_denoised (`bool`, padrão `True`) : Se deve limitar as saídas desruídas para `(-1, 1)`.

timesteps (`list` ou `np.ndarray` ou `torch.Tensor`, *opcional*) : Um agendamento explícito de timesteps que pode ser especificado opcionalmente. Os timesteps devem estar em ordem crescente.

Amostragem multietapa e de etapa única para modelos de consistência.

Este modelo herda de [SchedulerMixin](/docs/diffusers/v0.43.0/pt/api/schedulers/overview#diffusers.SchedulerMixin) e [ConfigMixin](/docs/diffusers/v0.43.0/pt/api/configuration#diffusers.ConfigMixin). Consulte a documentação da superclasse para os métodos genéricos que a biblioteca implementa para todos os agendadores, como carregamento e salvamento.

#### add_noise[[diffusers.CMStochasticIterativeScheduler.add_noise]]

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

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

**Parâmetros:**

original_samples (`torch.Tensor`) : As amostras originais às quais o ruído será adicionado.

noise (`torch.Tensor`) : O tensor de ruído a ser adicionado às amostras originais.

timesteps (`torch.Tensor`) : Os passos de tempo nos quais adicionar ruído, determinando o nível de ruído a partir da agenda.

**Retorna:** `torch.Tensor`

As amostras ruidosas com ruído adicionado, escalado de acordo com a agenda de passos temporais.

Adicione ruído às amostras originais de acordo com o agendamento de ruído nos timesteps especificados.

#### get_scalings[[diffusers.CMStochasticIterativeScheduler.get_scalings]]

```python
get_scalings(sigma: Tensor)
```

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

**Parâmetros:**

sigma (`torch.Tensor`) : O valor atual de sigma no cronograma de ruído.

**Retorna:** `tuple[torch.Tensor, torch.Tensor]`

Uma tupla contendo `c_skip` (escalonamento para a amostra de entrada) e `c_out` (escalonamento para a saída do modelo).

Calcula os fatores de escala para a saída do modelo de consistência.

#### get_scalings_for_boundary_condition[[diffusers.CMStochasticIterativeScheduler.get_scalings_for_boundary_condition]]

```python
get_scalings_for_boundary_condition(sigma: Tensor)
```

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

**Parâmetros:**

sigma (`torch.Tensor`) : O sigma atual no agendamento de sigma do Karras.

**Retorna:** `tuple[torch.Tensor, torch.Tensor]`

Uma tupla de dois elementos em que `c_skip` (que pondera a amostra atual) é o primeiro elemento e `c_out` (que pondera a saída do modelo de consistência) é o segundo elemento.

Obtém as escalas usadas na parametrização do modelo de consistência (do Apêndice C do [artigo](https://huggingface.co/papers/2303.01469)) para impor a condição de fronteira.

> [!TIP] > `epsilon` nas equações para `c_skip` e `c_out` é definido como `sigma_min`.

#### index_for_timestep[[diffusers.CMStochasticIterativeScheduler.index_for_timestep]]

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

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

**Parâmetros:**

timestep (`float` ou `torch.Tensor`) : O valor do timestep a ser encontrado no schedule.

schedule_timesteps (`torch.Tensor`, *opcional*) : O cronograma de passos de tempo a ser pesquisado. Se `None`, usa `self.timesteps`.

**Retorna:** `int`

O índice do timestep no schedule. Para o primeiro passo, retorna o segundo índice se existirem múltiplas correspondências, a fim de evitar pular um sigma ao iniciar no meio do schedule (por exemplo, para image-to-image).

Encontre o índice de um timestep específico na agenda de timesteps.

#### scale_model_input[[diffusers.CMStochasticIterativeScheduler.scale_model_input]]

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

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

**Parâmetros:**

sample (`torch.Tensor`) : A amostra de entrada.

timestep (`float` ou `torch.Tensor`) : O timestep atual na cadeia de difusão.

**Retorna:** `torch.Tensor`

Uma amostra de entrada escalada.

Escala a entrada do modelo de consistência por `(sigma**2 + sigma_data**2) ** 0.5`.

#### set_begin_index[[diffusers.CMStochasticIterativeScheduler.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_consistency_models.py#L126)

**Parâmetros:**

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

Define o índice inicial para o agendador. Esta função deve ser executada a partir do pipeline antes da inferência.

#### set_timesteps[[diffusers.CMStochasticIterativeScheduler.set_timesteps]]

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

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

**Parâmetros:**

num_inference_steps (`int`, *opcional*) : O número de etapas de difusão usadas ao gerar amostras com um modelo pré-treinado.

device (`str` ou `torch.device`, *opcional*) : O dispositivo para o qual os timesteps devem ser movidos. Se `None`, os timesteps não são movidos.

timesteps (`list[int]`, *opcional*) : Passos de tempo personalizados usados para suportar espaçamento arbitrário entre os passos de tempo. Se `None`, a estratégia de espaçamento padrão de passos de tempo, com espaçamento igual entre eles, é utilizada. Se `timesteps` for passado, `num_inference_steps` deve ser `None`.

Define os passos de tempo usados para a cadeia de difusão (a ser executado antes da inferência).

#### sigma_to_t[[diffusers.CMStochasticIterativeScheduler.sigma_to_t]]

```python
sigma_to_t(sigmas: float | numpy.ndarray)
```

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

**Parâmetros:**

sigmas (`float` ou `np.ndarray`) : Um único sigma de Karras ou um array de sigmas de Karras.

**Retorna:** `np.ndarray`

Um array de timestep de entrada escalado.

Obtém os passos de tempo escalonados a partir dos sigmas de Karras para a entrada do modelo de consistência.

#### etapa[[diffusers.CMStochasticIterativeScheduler.step]]

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

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

**Parâmetros:**

model_output (`torch.Tensor`) : A saída direta do modelo de difusão aprendido.

timestep (`float` ou `torch.Tensor`) : O timestep atual na cadeia de difusão.

sample (`torch.Tensor`) : Uma instância atual de uma amostra criada pelo processo de difusão.

generator (`torch.Generator`, *opcional*) : Um gerador de números aleatórios.

return_dict (`bool`, padrão `True`) : Se deve ou não retornar um [CMStochasticIterativeSchedulerOutput](/docs/diffusers/v0.43.0/pt/api/schedulers/cm_stochastic_iterative#diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput) ou um `tuple`.

**Retorna:** [CMStochasticIterativeSchedulerOutput](/docs/diffusers/v0.43.0/pt/api/schedulers/cm_stochastic_iterative#diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput) ou `tuple`

If return_dict is `True`, [CMStochasticIterativeSchedulerOutput](/docs/diffusers/v0.43.0/pt/api/schedulers/cm_stochastic_iterative#diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput) is returned, otherwise a tuple is returned where the first element is the sample tensor.

Preveja a amostra do passo de tempo anterior revertendo o SDE. Esta função propaga o processo de difusão a partir das saídas do modelo aprendido (na maioria das vezes, o ruído previsto).

## CMStochasticIterativeSchedulerOutput[[diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput]]

#### diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput[[diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput]]

```python
diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput(prev_sample: Tensor)
```

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

**Parâmetros:**

prev_sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` para imagens) : Amostra calculada `(x_{t-1})` do passo anterior. `prev_sample` deve ser usado como entrada do próximo modelo no loop de remoção de ruído.

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