# AnyFlow

[AnyFlow: Any-Step Video Diffusion Model with On-Policy Flow Map Distillation](https://huggingface.co/papers/2605.13724) da NVIDIA, National University of Singapore e Massachusetts Institute of Technology, por Yuchao Gu, Guian Fang, Yuxin Jiang, Weijia Mao, Song Han, Han Cai, Mike Zheng Shou.

> **Resumo:** AnyFlow é o primeiro framework de difusão de vídeo com qualquer número de etapas construído sobre mapas de fluxo, o que permite que um único modelo (bidirecional ou causal) se adapte a orçamentos de inferência arbitrários.

*A geração de vídeo em poucas etapas foi significativamente avançada pelos modelos de consistência. No entanto, seu desempenho frequentemente se degrada em modelos de difusão de vídeo em qualquer etapa devido à formulação de ponto fixo. Para abordar essa limitação, apresentamos o AnyFlow, o primeiro framework de destilação de difusão de vídeo em qualquer etapa construído sobre mapas de fluxo. Em vez de aprender apenas o mapeamento z_t → z_0, o AnyFlow aprende transições z_t → z_r em intervalos de tempo arbitrários, permitindo que um único modelo se adapte a diferentes orçamentos de inferência. Projetamos uma receita aprimorada de treinamento de mapa de fluxo para frente que ajusta finamente modelos de difusão de vídeo pré-treinados em modelos de mapa de fluxo, e introduzimos a Simulação para Trás de Mapa de Fluxo para permitir a destilação on-policy para modelos de mapa de fluxo. Experimentos extensivos em arquiteturas bidirecionais e causais, em escalas variando de 1,3B a 14B, em tarefas de texto-para-vídeo e imagem-para-vídeo, demonstram que o AnyFlow supera as linhas de base baseadas em consistência, preservando alta fidelidade e amostragem flexível sob orçamentos de etapas variáveis.*

Os pipelines AnyFlow foram contribuídos pela equipe AnyFlow. O código original está disponível no [GitHub](https://github.com/NVlabs/AnyFlow), a página do projeto está em [nvlabs.github.io/AnyFlow](https://nvlabs.github.io/AnyFlow) e os modelos pré-treinados podem ser encontrados na coleção [nvidia/anyflow](https://huggingface.co/collections/nvidia/anyflow) no Hugging Face.

Modelos disponíveis:

| Checkpoint | Backbone | Descrição |
|---|---|---|
| [`nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers`](https://huggingface.co/nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers) | Wan2.1 1.3B | T2V Bidirecional |
| [`nvidia/AnyFlow-Wan2.1-T2V-14B-Diffusers`](https://huggingface.co/nvidia/AnyFlow-Wan2.1-T2V-14B-Diffusers) | Wan2.1 14B | T2V Bidirecional |
| [`nvidia/AnyFlow-FAR-Wan2.1-1.3B-Diffusers`](https://huggingface.co/nvidia/AnyFlow-FAR-Wan2.1-1.3B-Diffusers) | FAR + Wan2.1 1.3B | T2V / I2V / V2V causal |
| [`nvidia/AnyFlow-FAR-Wan2.1-14B-Diffusers`](https://huggingface.co/nvidia/AnyFlow-FAR-Wan2.1-14B-Diffusers) | FAR + Wan2.1 14B | T2V / I2V / V2V causal |

> [!TIP]
> `AnyFlowPipeline` foi projetado para modelos de difusão bidirecionais em geração de texto para vídeo (T2V). `AnyFlowFARPipeline` é um modelo de difusão causal por blocos que suporta geração de texto para vídeo (T2V), geração de imagem para vídeo (I2V) e continuação de vídeo (V2V).

### Geração com AnyFlow (T2V Bidirecional)

```py
import torch
from diffusers import AnyFlowPipeline
from diffusers.utils import export_to_video

pipe = AnyFlowPipeline.from_pretrained(
    "nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = (
    "An astronaut runs smoothly and appears almost weightless on the lunar surface, "
    "as seen from a low-angle shot that highlights the vast, desolate background of the moon. "
    "The moon's craters and rocky terrain are clearly visible, creating a stark contrast against "
    "the running astronaut who moves with graceful, fluid motions."
)
video = pipe(prompt, num_inference_steps=4, num_frames=81).frames[0]
export_to_video(video, "anyflow_t2v.mp4", fps=16)
```

### Geração com AnyFlow (FAR Causal)

O pipeline causal seleciona entre T2V / I2V / V2V por meio do argumento ``video`` (ou ``video_latents``): omita ambos para text-to-video puro, ou passe ``video=<tensor>`` com forma ``(B, T, C, H, W)`` em ``[0, 1]`` e ``T = 4n + 1`` para condicionar em quadros existentes. Use um único quadro de condicionamento para I2V e um clipe mais longo para continuação V2V. Se você já possui latentes pré-codificados no layout do modelo, passe-os via ``video_latents=<tensor>`` para pular a codificação VAE. ``video`` e ``video_latents`` são mutuamente exclusivos.

> [!IMPORTANT]
> Os checkpoints liberados incorporam `chunk_partition=[1, 3, 3, 3, 3, 3, 3, 2]` (soma 21) na configuração do transformer, correspondendo às 81 frames brutas canônicas (21 frames latentes no passo temporal do VAE de 4). Ao alterar `num_frames`, passe um `chunk_partition` correspondente cuja soma seja `(num_frames - 1) // 4 + 1`; caso contrário, o pipeline lança um `ValueError`.

```py
import torch
from diffusers import AnyFlowFARPipeline
from diffusers.utils import export_to_video

pipe = AnyFlowFARPipeline.from_pretrained(
    "nvidia/AnyFlow-FAR-Wan2.1-1.3B-Diffusers", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = (
    "An astronaut runs smoothly and appears almost weightless on the lunar surface, "
    "as seen from a low-angle shot that highlights the vast, desolate background of the moon."
)
video = pipe(prompt, num_inference_steps=4, num_frames=81).frames[0]
export_to_video(video, "anyflow_far_t2v.mp4", fps=16)
```

```py
import numpy as np
import torch
from diffusers import AnyFlowFARPipeline
from diffusers.utils import export_to_video, load_image

pipe = AnyFlowFARPipeline.from_pretrained(
    "nvidia/AnyFlow-FAR-Wan2.1-1.3B-Diffusers", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"

# Example conditioning image from the AnyFlow repo.
first_frame = load_image(
    "https://raw.githubusercontent.com/NVlabs/AnyFlow/main/assets/evaluation/example/images/1.jpg"
).resize((832, 480))
arr = np.asarray(first_frame).astype("float32") / 255.0  # (480, 832, 3)
context_tensor = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0).unsqueeze(1).to("cuda")  # (1, 1, 3, 480, 832)

prompt = (
    "A towering, battle-scarred humanoid robot, reminiscent of a Transformer with powerful, segmented armor "
    "and glowing red optics, walking through the skeletal remains of a city ruin. Twisted metal and shattered "
    "concrete crunch under its heavy steps, as the robot scans the desolate, dust-choked skyline under an dark sky."
)
video = pipe(
    prompt=prompt,
    video=context_tensor,
    num_inference_steps=4,
    num_frames=81,
).frames[0]
export_to_video(video, "anyflow_far_i2v.mp4", fps=16)
```

```py
import numpy as np
import torch
from diffusers import AnyFlowFARPipeline
from diffusers.utils import export_to_video, load_video

pipe = AnyFlowFARPipeline.from_pretrained(
    "nvidia/AnyFlow-FAR-Wan2.1-1.3B-Diffusers", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"

# Example conditioning clip from the AnyFlow repo — take the first 9 frames (3 latent frames at VAE temporal stride 4).
context_frames = load_video(
    "https://raw.githubusercontent.com/NVlabs/AnyFlow/main/assets/evaluation/example/videos/2.mp4"
)[:9]
arr = np.stack([np.asarray(f.resize((832, 480))) for f in context_frames]).astype("float32") / 255.0
context_tensor = torch.from_numpy(arr).permute(0, 3, 1, 2).unsqueeze(0).to("cuda")  # (1, 9, 3, 480, 832)

prompt = (
    "A focused trail runner's powerful strides through a dense, sun-dappled forest. "
    "The camera tracks alongside, highlighting muscular exertion, sweat, and determined facial expression."
)
video = pipe(
    prompt=prompt,
    video=context_tensor,
    num_inference_steps=4,
    num_frames=81,
    # Override chunk_partition so the first chunk covers exactly the 3 latent context frames.
    chunk_partition=[3, 3, 3, 3, 3, 3, 3],
).frames[0]
export_to_video(video, "anyflow_far_v2v.mp4", fps=16)
```

## Observações

- A classifier-free guidance é incorporada nos checkpoints liberados, portanto a inferência não executa uma segunda passagem de encaminhamento guiada. Mantenha o valor padrão `guidance_scale=1.0`, a menos que seu próprio checkpoint exija o contrário.
- `FlowMapEulerDiscreteScheduler` é de uso geral. Você pode conectá-lo a qualquer checkpoint destilado de flow-map por meio de `from_pretrained(..., scheduler=FlowMapEulerDiscreteScheduler.from_config(...))`.
- `AnyFlowPipeline` usa [`AnyFlowTransformer3DModel`](../models/anyflow_transformer3d) (bidirecional). `AnyFlowFARPipeline` usa [`AnyFlowFARTransformer3DModel`](../models/anyflow_far_transformer3d), que adiciona um patch embedding de quadro comprimido e a máscara de bloco causal FAR.
- O carregamento de LoRA é suportado por meio de `WanLoraLoaderMixin`, o mesmo mixin utilizado pelos pipelines Wan upstream.
- Para as receitas de treinamento (treinamento de fluxo de mapa para frente e destilação on-policy), consulte o framework de treinamento original AnyFlow em [`NVlabs/AnyFlow`](https://github.com/NVlabs/AnyFlow); o treinamento está fora do escopo do diffusers.

## AnyFlowPipeline[[diffusers.AnyFlowPipeline]]

#### diffusers.AnyFlowPipeline[[diffusers.AnyFlowPipeline]]

```python
diffusers.AnyFlowPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, transformer: AnyFlowTransformer3DModel, vae: AutoencoderKLWan, scheduler: FlowMapEulerDiscreteScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_anyflow.py#L80)

**Parâmetros:**

tokenizer ([*AutoTokenizer*]) : Tokenizer de [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder ([*UMT5EncoderModel*]) : codificador de texto [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([*AnyFlowTransformer3DModel*]) : Transformer 3D de fluxo-mapa bidirecional.

vae ([*AutoencoderKLWan*]) : VAE que codifica/decodifica vídeos para e a partir de representações latentes.

scheduler ([*FlowMapEulerDiscreteScheduler*]) : Amostrador de mapa de fluxo. O pipeline aciona `scheduler.step(..., timestep, sample, r_timestep)` a cada etapa de inferência.

Pipeline de geração de texto para vídeo bidirecional para checkpoints destilados por mapa de fluxo do AnyFlow, introduzido em [AnyFlow](https://huggingface.co/papers/2605.13724).

AnyFlow aprende 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 em 1, 2, 4, 8, 16... NFE sem re-treinamento. Este pipeline opera sobre o tensor completo do vídeo em uma única passagem bidirecional; para geração autoregressiva (causal) por blocos, use `AnyFlowFARPipeline`.

A amostragem é Euler simples na forma de velocidade média (`z_r = z_t - (t - r) * u`) sem re-ruído. Os checkpoints da NVIDIA liberados incorporam o classifier-free guidance nos pesos do modelo, portanto o valor padrão `guidance_scale=1.0` é a configuração recomendada.

Este modelo herda de [*DiffusionPipeline*]. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

#### __call__[[diffusers.AnyFlowPipeline.__call__]]

```python
__call__(prompt: typing.Union[str, typing.List[str]] = None, video: typing.Optional[torch.Tensor] = None, video_latents: typing.Optional[torch.Tensor] = None, negative_prompt: typing.Union[str, typing.List[str]] = None, height: int = 480, width: int = 832, num_frames: int = 81, num_inference_steps: int = 50, sigmas: typing.Optional[typing.List[float]] = None, timesteps: typing.Optional[typing.List[float]] = None, guidance_scale: float = 1.0, num_videos_per_prompt: typing.Optional[int] = 1, generator: typing.Union[torch.Generator, typing.List[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: typing.Optional[str] = 'np', return_dict: bool = True, attention_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None, callback_on_step_end: typing.Union[typing.Callable[[int, int, typing.Dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: typing.List[str] = ['latents'], max_sequence_length: int = 512, use_mean_velocity: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_anyflow.py#L380)

**Parâmetros:**

prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts para orientar a geração do vídeo. Se não definido, passe `prompt_embeds` em vez disso.

video (`torch.Tensor`, *opcional*) : Quadros de condicionamento pré-VAE com forma `(B, T, C, H, W)` em `[0, 1]`. Quando fornecidos, o pipeline os codifica com o VAE e mantém o prefixo latente correspondente fixo durante a amostragem. Mutuamente exclusivo com `video_latents`.

video_latents (`torch.Tensor`, *opcional*) : Latentes VAE pré-codificados no layout AnyFlow `(B, T_latent, C, H_latent, W_latent)`. Pula a codificação VAE no lado do pipeline. Mutuamente exclusivo com `video`.

negative_prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts a evitar durante a geração de vídeo. Ignorado quando não está usando orientação (`guidance_scale < 1`).

height (`int`, padrão `480`) : A altura em pixels do vídeo gerado.

width (`int`, padrão `832`) : A largura em pixels do vídeo gerado.

num_frames (`int`, padrão `81`) : O número de quadros no vídeo gerado. Deve satisfazer `(num_frames - 1) % vae_scale_factor_temporal == 0`.

num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Os checkpoints distilados do AnyFlow suportam amostragem em qualquer etapa, portanto, valores tão baixos quanto `1`, `2`, `4` ou `8` são típicos. Ignorado quando `sigmas` ou `timesteps` é fornecido.

sigmas (`List[float]`, *opcional*) : Agenda de sigmas personalizada para amostragem em qualquer número de etapas, em `[0, 1]` e ordenada de ruidosa para limpa. O comprimento determina o `num_inference_steps` efetivo; o agendador adiciona o sigma terminal `0`.

timesteps (`List[float]`, *opcional*) : Agenda de passos de tempo personalizada para amostragem em qualquer número de passos, nas mesmas unidades de `self.scheduler.timesteps` (ou seja, escalada por `num_train_timesteps`). Mutuamente exclusiva com `sigmas`.

guidance_scale (`float`, padrão `1.0`) : Escala de orientação sem classificador (classifier-free guidance). Os checkpoints AnyFlow liberados fundem a CFG nos pesos durante o treinamento; mantenha em `1.0` a menos que você saiba que seu checkpoint espera o contrário.

num_videos_per_prompt (`int`, *opcional*, padrão `1`) : O número de vídeos a serem gerados por prompt.

generator (`torch.Generator` ou `List[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados para usar como entradas. Se não fornecidos, os latentes são amostrados a partir do `generator` fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Pode ser usado para ajustar as entradas de texto (por exemplo, ponderação de prompts). Se não for fornecido, os embeddings são gerados a partir de `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados.

output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída. Um dos `"pil"`, `"np"`, `"pt"` ou `"latent"`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um `AnyFlowPipelineOutput` em vez de uma tupla simples.

attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Uma função ou `PipelineCallback` chamada no final de cada etapa de inferência. Consulte [`callbacks`](../callbacks) para mais detalhes.

callback_on_step_end_tensor_inputs (`List[str]`, *opcional*, padrão `["latents"]`) : Os tensores de entrada encaminhados para o callback. Deve ser um subconjunto de `self._callback_tensor_inputs`.

max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência do codificador de texto. Prompts mais longos são truncados.

use_mean_velocity (`bool`, padrão `True`) : Quando `True`, o modelo flow-map é condicionado tanto no timestep de origem `t` quanto no timestep de destino `r` para prever uma velocidade média, correspondendo ao comportamento no momento do treinamento. Desative para espelhar o passo bruto de Euler (`r = t`).

**Retorna:** `~AnyFlowPipelineOutput` ou `tuple`

Se `return_dict` for `True`, `AnyFlowPipelineOutput` é retornado; caso contrário, uma `tuple` cujo primeiro elemento é o vídeo gerado.

A função de chamada do pipeline para geração.

Exemplos:
```python
>>> import torch
>>> from diffusers import AnyFlowPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = AnyFlowPipeline.from_pretrained(
...     "nvidia/AnyFlow-Wan2.1-T2V-14B-Diffusers", torch_dtype=torch.bfloat16
... ).to("cuda")

>>> prompt = "A red panda eating bamboo in a forest, cinematic lighting"
>>> video = pipe(prompt, num_inference_steps=4, num_frames=33).frames[0]
>>> export_to_video(video, "anyflow_t2v.mp4", fps=16)
```

#### encode_prompt[[diffusers.AnyFlowPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 226, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_anyflow.py#L180)

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance.

num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.

device : (`torch.device`, *opcional*): dispositivo torch

dtype : (`torch.dtype`, *opcional*): dtype do torch

Codifica o prompt em estados ocultos do codificador de texto.

#### encode_video[[diffusers.AnyFlowPipeline.encode_video]]

```python
encode_video(video: Tensor, height: int, width: int)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_anyflow.py#L360)

Codifique um vídeo em espaço de pixels para o layout latente do AnyFlow.

Espelha a convenção de um único helper de outros pipelines do diffusers (cf. `WanImageToVideoPipeline.encode_image`): encapsula o pré-processamento, a codificação VAE e a normalização de latentes em uma única chamada. O layout de saída é `(B, T_latent, C, H, W)`, que é o que o transformer AnyFlow espera para os frames de condicionamento.

## AnyFlowFARPipeline[[diffusers.AnyFlowFARPipeline]]

#### diffusers.AnyFlowFARPipeline[[diffusers.AnyFlowFARPipeline]]

```python
diffusers.AnyFlowFARPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, transformer: AnyFlowFARTransformer3DModel, vae: AutoencoderKLWan, scheduler: FlowMapEulerDiscreteScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_anyflow_far.py#L92)

**Parâmetros:**

tokenizer ([*AutoTokenizer*]) : Tokenizer de [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder ([*UMT5EncoderModel*]) : codificador de texto [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([*AnyFlowFARTransformer3DModel*]) : Transformer 3D de fluxo causal FAR.

vae ([*AutoencoderKLWan*]) : VAE que codifica/decodifica vídeos para e a partir de representações latentes.

scheduler ([*FlowMapEulerDiscreteScheduler*]) : Amostrador de mapa de fluxo.

Causal Pipeline (baseado em FAR) de texto-para-vídeo / imagem-para-vídeo / vídeo-para-vídeo para checkpoints do AnyFlow, introduzido em [AnyFlow](https://huggingface.co/papers/2605.13724).

O pipeline dirige um loop de amostragem autoregressiva por blocos: cada bloco é desruído com passos de flow-map, prestando atenção apenas aos blocos anteriores por meio de atenção causal esparsa por blocos, e o cache KV intermediário é reutilizado entre os blocos.

O modo de tarefa (T2V / I2V / V2V) é selecionado pelo argumento de condicionamento passado para `__call__`:

- tanto `video=None` quanto `video_latents=None` — texto-para-vídeo puro.
- `video=&amp;lt;tensor of shape (B, T, C, H, W) in [0, 1] with T = 4n + 1>` — quadros de condicionamento pré-VAE; o pipeline os codifica com o VAE. Passe um vídeo de um único quadro para I2V ou um clipe de múltiplos quadros para V2V.
- `video_latents=&amp;lt;latent tensor of shape (B, T_latent, C, H_latent, W_latent)>` — latentes já codificados no layout FAR (pula a etapa de codificação do VAE).

O backbone FAR é a variante causal Wan2.1 introduzida por [FAR](https://huggingface.co/papers/2503.19325). A inferência é Euler simples na forma de velocidade média por chunk, sem re-noising. O suporte conjunto para T2V / I2V / V2V é feito por um único modelo destilado.

Este modelo herda de [*DiffusionPipeline*]. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

#### __call__[[diffusers.AnyFlowFARPipeline.__call__]]

```python
__call__(prompt: typing.Union[str, typing.List[str]] = None, video: typing.Optional[torch.Tensor] = None, video_latents: typing.Optional[torch.Tensor] = None, negative_prompt: typing.Union[str, typing.List[str]] = None, height: int = 480, width: int = 832, num_frames: int = 81, num_inference_steps: int = 50, sigmas: typing.Optional[typing.List[float]] = None, timesteps: typing.Optional[typing.List[float]] = None, guidance_scale: float = 1.0, num_videos_per_prompt: typing.Optional[int] = 1, generator: typing.Union[torch.Generator, typing.List[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: typing.Optional[str] = 'np', return_dict: bool = True, attention_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None, callback_on_step_end: typing.Union[typing.Callable[[int, int, typing.Dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: typing.List[str] = ['latents'], max_sequence_length: int = 512, use_mean_velocity: bool = True, use_kv_cache: bool = True, chunk_partition: typing.Optional[typing.List[int]] = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_anyflow_far.py#L448)

**Parâmetros:**

prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts para orientar a geração do vídeo. Se não definido, passe `prompt_embeds` em vez disso.

video (`torch.Tensor`, *opcional*) : Quadros de condicionamento pré-VAE com forma `(B, T, C, H, W)` em `[0, 1]` (`T = 4n + 1`). Quando fornecidos, o pipeline os codifica com o VAE e mantém o prefixo latente correspondente fixo durante a amostragem. Mutuamente exclusivo com `video_latents`.

video_latents (`torch.Tensor`, *opcional*) : Latentes VAE pré-codificados no layout FAR `(B, T_latent, C, H_latent, W_latent)`. Pula a codificação VAE no lado do pipeline. Mutuamente exclusivo com `video`.

negative_prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts a evitar durante a geração de vídeo. Ignorado quando não está usando orientação (`guidance_scale < 1`).

height (`int`, padrão `480`) : A altura em pixels do vídeo gerado.

width (`int`, padrão `832`) : A largura em pixels do vídeo gerado.

num_frames (`int`, padrão `81`) : O número de quadros no vídeo gerado. Deve satisfazer `(num_frames - 1) % vae_scale_factor_temporal == 0`.

num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído por bloco. Os checkpoints distilados do AnyFlow-FAR suportam amostragem em qualquer etapa (1, 2, 4, 8, ...). Ignorado quando `sigmas` ou `timesteps` é fornecido.

sigmas (`List[float]`, *opcional*) : Agenda de sigmas personalizada para amostragem em qualquer número de etapas, em `[0, 1]` e ordenada de ruidosa para limpa. O comprimento determina o `num_inference_steps` efetivo; o agendador adiciona o sigma terminal `0`.

timesteps (`List[float]`, *opcional*) : Agenda de passos de tempo personalizada para amostragem em qualquer número de passos, nas mesmas unidades de `self.scheduler.timesteps` (ou seja, escalada por `num_train_timesteps`). Mutuamente exclusiva com `sigmas`.

guidance_scale (`float`, padrão `1.0`) : Escala de orientação sem classificador (classifier-free guidance). Os checkpoints AnyFlow liberados fundem a CFG nos pesos durante o treinamento; mantenha em `1.0` a menos que o checkpoint exija o contrário.

num_videos_per_prompt (`int`, *opcional*, padrão `1`) : O número de vídeos a serem gerados por prompt.

generator (`torch.Generator` ou `List[torch.Generator]`, *opcional*) : Gerador usado para definir a semente da amostragem.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados. Se não fornecidos, os latentes são amostrados a partir do `generator` fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Se não fornecidos, os embeddings são gerados a partir de `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados.

output_type (`str`, *opcional*, padrão `"np"`) : Formato de saída. Um de `"pil"`, `"np"`, `"pt"` ou `"latent"`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um `AnyFlowPipelineOutput` em vez de uma tupla simples.

attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Uma função ou `PipelineCallback` chamada no final de cada etapa de inferência.

callback_on_step_end_tensor_inputs (`List[str]`, *opcional*, padrão `["latents"]`) : Entradas de Tensor encaminhadas para o callback. Deve ser um subconjunto de `self._callback_tensor_inputs`.

max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência do codificador de texto.

use_mean_velocity (`bool`, padrão `True`) : Quando `True`, condiciona o modelo flow-map tanto no timestep de origem `t` quanto no timestep de destino `r` para prever uma velocidade média. Desative para espelhar o passo bruto de Euler.

use_kv_cache (`bool`, padrão `True`) : Reutiliza o cache KV da atenção FAR entre blocos causais. Desative apenas para depuração.

chunk_partition (`List[int]`, *opcional*) : Contagem de quadros por bloco. O padrão é `self.transformer.config.chunk_partition` (correspondente aos checkpoints de 81 quadros liberados). Ao alterar `num_frames`, forneça um `chunk_partition` cuja soma seja `(num_frames - 1) // vae_scale_factor_temporal + 1`.

**Retorna:** `~AnyFlowPipelineOutput` ou `tuple`

Se `return_dict` for `True`, um `AnyFlowPipelineOutput` é retornado; caso contrário, uma `tuple` cujo primeiro elemento é o vídeo gerado.

A função de chamada do pipeline para geração.

Exemplos:
```python
>>> import numpy as np
>>> import torch
>>> from diffusers import AnyFlowFARPipeline
>>> from diffusers.utils import export_to_video, load_image

>>> pipe = AnyFlowFARPipeline.from_pretrained(
...     "nvidia/AnyFlow-FAR-Wan2.1-1.3B-Diffusers", torch_dtype=torch.bfloat16
... ).to("cuda")

>>> # Single-frame I2V: wrap the conditioning image as a (1, 1, 3, H, W) tensor in [0, 1].
>>> first_frame = load_image("path/to/first_frame.png").resize((832, 480))
>>> arr = np.asarray(first_frame).astype("float32") / 255.0
>>> context = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0).unsqueeze(1).to("cuda")

>>> video = pipe(
...     prompt="a cat walks across a sunlit lawn",
...     video=context,
...     num_inference_steps=4,
...     num_frames=81,
... ).frames[0]
>>> export_to_video(video, "anyflow_far.mp4", fps=16)
```

#### encode_prompt[[diffusers.AnyFlowFARPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 226, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_anyflow_far.py#L197)

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance.

num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.

device : (`torch.device`, *opcional*): dispositivo torch

dtype : (`torch.dtype`, *opcional*): dtype do torch

Codifica o prompt em estados ocultos do codificador de texto.

#### encode_video[[diffusers.AnyFlowFARPipeline.encode_video]]

```python
encode_video(video: Tensor, height: int, width: int)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_anyflow_far.py#L380)

Codifique um vídeo em espaço de pixels para o layout latente do AnyFlow.

Espelha a convenção de um único helper de outros pipelines do diffusers (cf. `WanImageToVideoPipeline.encode_image`): encapsula o pré-processamento, a codificação VAE e a normalização de latentes em uma única chamada. O layout de saída é `(B, T_latent, C, H, W)`, que é o que o transformer AnyFlow espera para os frames de condicionamento.

## AnyFlowPipelineOutput[[diffusers.pipelines.anyflow.pipeline_output.AnyFlowPipelineOutput]]

#### diffusers.pipelines.anyflow.pipeline_output.AnyFlowPipelineOutput[[diffusers.pipelines.anyflow.pipeline_output.AnyFlowPipelineOutput]]

```python
diffusers.pipelines.anyflow.pipeline_output.AnyFlowPipelineOutput(frames: Tensor)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/anyflow/pipeline_output.py#L23)

**Parâmetros:**

frames (`torch.Tensor`, `np.ndarray` ou list[list[PIL.Image.Image]]) : lista de saídas de vídeo - Pode ser uma lista aninhada de comprimento `batch_size,` em que cada sublista contém sequências de imagens PIL desruidas de comprimento `num_frames.` Também pode ser um array NumPy ou um tensor Torch de forma `(batch_size, num_frames, channels, height, width)`.

Classe de saída para pipelines do AnyFlow.