# FlowMatchEulerDiscreteScheduler

`FlowMatchEulerDiscreteScheduler` é baseado na amostragem por flow-matching introduzida em [Stable Diffusion 3](https://huggingface.co/papers/2403.03206).

## FlowMatchEulerDiscreteScheduler[[diffusers.FlowMatchEulerDiscreteScheduler]]

#### diffusers.FlowMatchEulerDiscreteScheduler[[diffusers.FlowMatchEulerDiscreteScheduler]]

```python
diffusers.FlowMatchEulerDiscreteScheduler(num_train_timesteps: int = 1000, shift: float = 1.0, use_dynamic_shifting: bool = False, base_shift: float | None = 0.5, max_shift: float | None = 1.15, base_image_seq_len: int = 256, max_image_seq_len: int = 4096, invert_sigmas: bool = False, shift_terminal: float = None, use_karras_sigmas: bool = False, use_exponential_sigmas: bool = False, use_beta_sigmas: bool = False, time_shift_type: typing.Literal['exponential', 'linear'] = 'exponential', stochastic_sampling: bool = False)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L48)

**Parâmetros:**

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

shift (`float`, padrão 1.0) : O valor de deslocamento para o cronograma de passos de tempo.

use_dynamic_shifting (`bool`, padrão é False) : Se deve aplicar o deslocamento de passo de tempo em tempo real com base na resolução da imagem.

base_shift (`float`, padrão 0.5) : Valor para estabilizar a geração de imagens. Aumentar `base_shift` reduz a variação e a imagem fica mais consistente com a saída desejada.

max_shift (`float`, padrão 1.15) : Variação de valor permitida para os vetores latentes. Aumentar `max_shift` incentiva mais variação e a imagem pode ficar mais exagerada ou estilizada.

base_image_seq_len (`int`, padrão 256) : O comprimento da sequência da imagem base.

max_image_seq_len (`int`, padrão 4096) : O comprimento máximo da sequência de imagem.

invert_sigmas (`bool`, padrão é False) : Se deve inverter os sigmas.

shift_terminal (`float`, padrão None) : O valor final do cronograma de timesteps deslocados.

use_karras_sigmas (`bool`, padrão é False) : Se deve usar sigmas de Karras para os tamanhos de passo no agendamento de ruído durante a amostragem.

use_exponential_sigmas (`bool`, padrão é False) : Se deve usar sigmas exponenciais para os tamanhos de passo no agendamento de ruído durante a amostragem.

use_beta_sigmas (`bool`, padrão é False) : Se deve usar betas sigmas para os tamanhos de passo no agendamento de ruído durante a amostragem.

time_shift_type (`str`, padrão "exponential") : O tipo de deslocamento de passo de tempo dependente da resolução dinâmica a ser aplicado. Pode ser "exponential" ou "linear".

stochastic_sampling (`bool`, padrão é False) : Se deve usar amostragem estocástica.

Euler scheduler.

Este modelo herda de [SchedulerMixin](/docs/diffusers/main/pt/api/schedulers/overview#diffusers.SchedulerMixin) e [ConfigMixin](/docs/diffusers/main/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.

#### index_for_timestep[[diffusers.FlowMatchEulerDiscreteScheduler.index_for_timestep]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L393)

**Parâmetros:**

timestep (`float` ou `torch.FloatTensor`) : O timestep para o qual encontrar o índice.

schedule_timesteps (`torch.FloatTensor`, *opcional*) : Os timesteps de agendamento para validação. Se `None`, os timesteps do agendador são usados.

**Retorna:** `int`

O índice do passo de tempo.

Obtenha o índice para o timestep dado.

#### scale_noise[[diffusers.FlowMatchEulerDiscreteScheduler.scale_noise]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L188)

**Parâmetros:**

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

timestep (`torch.FloatTensor`) : O timestep atual na cadeia de difusão.

noise (`torch.FloatTensor`) : O tensor de ruído.

**Retorna:** `torch.FloatTensor`

Uma amostra de entrada escalada.

Processo de propagação no flow-matching

#### set_begin_index[[diffusers.FlowMatchEulerDiscreteScheduler.set_begin_index]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L168)

**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_shift[[diffusers.FlowMatchEulerDiscreteScheduler.set_shift]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L178)

**Parâmetros:**

shift (`float`) : O valor de deslocamento a ser definido.

Define o valor de deslocamento para o agendador.

#### set_timesteps[[diffusers.FlowMatchEulerDiscreteScheduler.set_timesteps]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L283)

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

sigmas (`list[float]`, *opcional*) : Valores personalizados para sigmas a serem usados em cada etapa de difusão. Se `None`, os sigmas são calculados automaticamente.

mu (`float`, *opcional*) : Determina a quantidade de deslocamento aplicada aos sigmas ao executar o deslocamento de passo de tempo dependente da resolução.

timesteps (`list[float]`, *opcional*) : Valores personalizados para os timesteps a serem usados em cada etapa de difusão. Se `None`, os timesteps são calculados automaticamente.

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

#### etapa[[diffusers.FlowMatchEulerDiscreteScheduler.step]]

```python
step(model_output: FloatTensor, timestep: typing.Union[float, torch.FloatTensor], sample: FloatTensor, s_churn: float = 0.0, s_tmin: float = 0.0, s_tmax: float = inf, s_noise: float = 1.0, generator: typing.Optional[torch.Generator] = None, per_token_timesteps: typing.Optional[torch.Tensor] = None, return_dict: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L432)

**Parâmetros:**

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

timestep (`float`) : O passo de tempo discreto atual na cadeia de difusão.

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

s_churn (`float`) --

s_tmin  (`float`) --

s_tmax  (`float`) --

s_noise (`float`, padrão 1.0) : Fator de escala para o ruído adicionado à amostra.

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

per_token_timesteps (`torch.Tensor`, *opcional*) : Os timesteps para cada token na amostra.

return_dict (`bool`, padrão `True`) : Se deve ou não retornar um `FlowMatchEulerDiscreteSchedulerOutput` ou uma tupla.

**Retorna:** `FlowMatchEulerDiscreteSchedulerOutput` ou `tuple`

If return_dict is `True`, `FlowMatchEulerDiscreteSchedulerOutput` 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).

#### stretch_shift_to_terminal[[diffusers.FlowMatchEulerDiscreteScheduler.stretch_shift_to_terminal]]

```python
stretch_shift_to_terminal(t: Tensor)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L262)

**Parâmetros:**

t (`torch.Tensor`) : Um tensor de timesteps a serem esticados e deslocados.

**Retorna:** `torch.Tensor`

Um tensor de timesteps ajustados de modo que o valor final seja igual a `self.config.shift_terminal`.

Estica e desloca o cronograma de timesteps para garantir que ele termine no valor de configuração `shift_terminal` configurado.

Referência: https://github.com/Lightricks/LTX-Video/blob/a01a171f8fe3d99dce2728d60a73fecf4d4238ae/ltx_video/schedulers/rf.py#L51

#### time_shift[[diffusers.FlowMatchEulerDiscreteScheduler.time_shift]]

```python
time_shift(mu: float, sigma: float, t: Tensor)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_flow_match_euler_discrete.py#L241)

**Parâmetros:**

mu (`float`) : O parâmetro mu para o deslocamento de tempo.

sigma (`float`) : O parâmetro sigma para o deslocamento de tempo.

t (`torch.Tensor`) : Os timesteps de entrada.

**Retorna:** `torch.Tensor`

Os timesteps deslocados no tempo.

Aplicar o deslocamento temporal aos sigmas.