# FlowMapEulerDiscreteScheduler

`FlowMapEulerDiscreteScheduler` é um amostrador no estilo Euler projetado para modelos de difusão destilados por flow-map. Modelos de flow-map aprendem transições de intervalo arbitrário $\mathbf{z}_t \to \mathbf{z}_r$, em vez do mapeamento fixo $\mathbf{z}_t \to \mathbf{z}_0$ dos modelos de consistência. Ambos os extremos do passo são fornecidos pelo chamador, o que permite amostragem em qualquer número de passos: um único checkpoint destilado pode ser avaliado com 1, 2, 4, 8, 16... NFE sem necessidade de re-treinamento.

O scheduler foi introduzido em [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) e é distribuído junto com as integrações `AnyFlowPipeline` e `AnyFlowFARPipeline`, mas não é específico do AnyFlow — qualquer checkpoint destilado por flow-map pode utilizá-lo.

## FlowMapEulerDiscreteScheduler[[diffusers.FlowMapEulerDiscreteScheduler]]

#### diffusers.FlowMapEulerDiscreteScheduler[[diffusers.FlowMapEulerDiscreteScheduler]]

```python
diffusers.FlowMapEulerDiscreteScheduler(num_train_timesteps: int = 1000, shift: float = 1.0)
```

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

**Parâmetros:**

num_train_timesteps (*int*, padrão 1000) : O número de etapas de difusão usadas para treinar o modelo de fluxo-mapa subjacente.

shift (*float*, padrão 1.0) : Deslocamento multiplicativo do passo de tempo aplicado ao agendamento de inferência. `shift=1.0` é a identidade; valores maiores que 1.0 deslocam o agendamento para mais desruidamento nas etapas posteriores (por exemplo, `shift=5` corresponde ao padrão do Wan2.1).

Amostrador estilo Euler para modelos de difusão destilados por mapa de fluxo.

Modelos de flow-map aprendem transições de intervalo arbitrário \\(z_t \to z_r\\), em vez do mapeamento fixo \\(z_t \to z_0\\) dos modelos de consistência, de modo que um único checkpoint destilado pode ser avaliado com 1, 2, 4, 8, ... NFE sem re-treinamento. O método *step* avança a amostra de *timestep* para *r_timestep* ao longo da velocidade prevista.

Introduzido em [AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) por Yuchao Gu, Guian Fang et al.

Este agendador herda de [*SchedulerMixin*] e [*ConfigMixin*]. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os agendadores (carregamento, salvamento, etc.).

#### apply_shift[[diffusers.FlowMapEulerDiscreteScheduler.apply_shift]]

```python
apply_shift(sigmas: Tensor)
```

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

Aplica a transformação de deslocamento configurada a um tensor sigma.

#### index_for_timestep[[diffusers.FlowMapEulerDiscreteScheduler.index_for_timestep]]

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

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

Retorna o índice de `timestep` no agendamento atual, ou `None` se estiver fora do agendamento.

A consulta é feita em relação a `self.timesteps` com uma pequena tolerância de ponto flutuante. É usado para recuperar o sigma correspondente sem assumir a relação linear `timesteps = sigmas * num_train_timesteps` — dessa forma, um agendamento personalizado (por exemplo, deslocamento não linear, timesteps definidos manualmente) ainda é resolvido corretamente.

#### scale_model_input[[diffusers.FlowMapEulerDiscreteScheduler.scale_model_input]]

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

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

Escala de identidade sem operação. Fornecida para compatibilidade de API com outros agendadores do Diffusers.

#### scale_noise[[diffusers.FlowMapEulerDiscreteScheduler.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_map_euler_discrete.py#L103)

Interpole linearmente `sample` em direção a `noise` de acordo com o `timestep` normalizado.

#### set_begin_index[[diffusers.FlowMapEulerDiscreteScheduler.set_begin_index]]

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

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

Defina o índice inicial para o agendador. Pipelines que começam no meio do agendamento (por exemplo, image-to-image) chamam isso entre `set_timesteps` e o primeiro `step` para ancorar o rollout.

#### set_timesteps[[diffusers.FlowMapEulerDiscreteScheduler.set_timesteps]]

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

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

**Parâmetros:**

num_inference_steps (*int*, *opcional*) : Número de etapas de inferência. Se `None`, é necessário passar `sigmas` ou `timesteps`.

device (*str* ou *torch.device*, *opcional*) : Dispositivo de destino para `self.sigmas` / `self.timesteps`.

sigmas (*List[float]*, *opcional*) : Agenda de sigmas personalizada de comprimento `num_inference_steps`. O sigma terminal `0` é adicionado automaticamente. O `shift` configurado é aplicado por cima.

timesteps (*List[float]*, *opcional*) : Agenda de passos de tempo personalizada de comprimento `num_inference_steps`, nas mesmas unidades de `self.timesteps` (ou seja, escalada por `num_train_timesteps`). Convertida para sigmas internamente. Se tanto `sigmas` quanto `timesteps` forem passados, seus comprimentos devem corresponder.

Construa o cronograma de passos de inferência.

Internamente, rastreia `self.sigmas` de comprimento `num_inference_steps + 1` (o shift configurado aplicado a um linspace de `1.0` a `0.0` por padrão); `self.timesteps` expõe os primeiros `num_inference_steps` sigmas escalados por `num_train_timesteps` — ou seja, um timestep por etapa de inferência, correspondendo a [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler). O sigma final (`0`) é o ponto final implícito da última etapa e é adicionado automaticamente quando `sigmas` / `timesteps` são fornecidos pelo usuário.

#### etapa[[diffusers.FlowMapEulerDiscreteScheduler.step]]

```python
step(model_output: FloatTensor, timestep: typing.Union[float, torch.FloatTensor], sample: FloatTensor, r_timestep: typing.Union[float, torch.FloatTensor, NoneType] = None, return_dict: bool = True)
```

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

**Parâmetros:**

model_output (*torch.Tensor*) : Saída direta do modelo flow-map (velocidade média prevista).

timestep (*float* ou *torch.Tensor*) : Timestep de origem `t` nas mesmas unidades de `self.timesteps`.

sample (*torch.Tensor*) : Amostra atual \\(z_t\\).

r_timestep (*float* ou *torch.Tensor*, *opcional*) : Timestep alvo `r`. O padrão é o próximo timestep na agenda quando `None`; passe um valor explícito para amostragem em qualquer passo. `r_timestep == timestep` é uma operação sem efeito.

return_dict (*bool*, padrão *True*) : Se deve retornar um [*FlowMapEulerDiscreteSchedulerOutput*] (o padrão) ou uma tupla simples.

**Retorna:** [*FlowMapEulerDiscreteSchedulerOutput*] ou *tuple*

Quando `return_dict=True`, retorna um [*FlowMapEulerDiscreteSchedulerOutput*] cujo `prev_sample` é \\(z_r\\). Caso contrário, retorna uma 1-tupla `(prev_sample,)`.

Avance `sample` de `timestep` para `r_timestep` usando a velocidade prevista pelo modelo.

Diferentemente de um agendador Euler padrão, ambas as extremidades do intervalo podem ser fornecidas pelo chamador, permitindo amostragem em qualquer passo: uma única chamada ao modelo pode avançar de *t* para qualquer alvo *r* escolhido (incluindo *r=0* para uma geração em um único passo). Quando `r_timestep` é omitido, o valor padrão é o próximo passo de tempo no agendamento (correspondendo à semântica de `FlowMatchEulerDiscreteScheduler`).

Internamente, os sigmas de origem e destino são recuperados indexando `self.sigmas` via `index_for_timestep`, em vez de dividir os timesteps de entrada por `num_train_timesteps`, de modo que qualquer agenda cuja relação timestep / sigma seja não linear (por exemplo, um shift personalizado) permaneça correta. Para um `r_timestep` fora da agenda, o scheduler recorre a `r_timestep / num_train_timesteps`, de modo que a amostragem em qualquer passo fora da agenda continue sendo suportada.