# AnyFlow

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

> **Resumen:** AnyFlow es el primer marco de difusión de video de pasos arbitrarios basado en mapas de flujo, que permite a un único modelo (bidireccional o causal) adaptarse a presupuestos de inferencia arbitrarios.

*La generación de video en pocos pasos ha avanzado significativamente gracias a los modelos de consistencia. Sin embargo, su rendimiento suele degradarse en los modelos de difusión de video de cualquier paso debido a la formulación de punto fijo. Para abordar esta limitación, presentamos AnyFlow, el primer marco de destilación de difusión de video de cualquier paso basado en mapas de flujo. En lugar de aprender solo el mapeo z_t → z_0, AnyFlow aprende transiciones z_t → z_r en intervalos de tiempo arbitrarios, lo que permite que un solo modelo se adapte a diferentes presupuestos de inferencia. Diseñamos una receta mejorada de entrenamiento de mapas de flujo hacia adelante que ajusta modelos de difusión de video preentrenados en modelos de mapas de flujo, e introducimos la Simulación hacia Atrás de Mapas de Flujo para habilitar la destilación en política para modelos de mapas de flujo. Experimentos extensos en arquitecturas bidireccionales y causales, a escalas que van desde 1.3B hasta 14B, en tareas de texto a video e imagen a video, demuestran que AnyFlow supera a las líneas base basadas en consistencia mientras preserva una alta fidelidad y una muestreo flexible bajo presupuestos de pasos variables.*

Los pipelines de AnyFlow fueron aportados por el equipo de AnyFlow. El código original está disponible en [GitHub](https://github.com/NVlabs/AnyFlow), la página del proyecto se encuentra en [nvlabs.github.io/AnyFlow](https://nvlabs.github.io/AnyFlow) y los modelos preentrenados pueden encontrarse en la colección [nvidia/anyflow](https://huggingface.co/collections/nvidia/anyflow) de Hugging Face.

Modelos disponibles:

| Checkpoint | Backbone | Descripción |
|---|---|---|
| [`nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers`](https://huggingface.co/nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers) | Wan2.1 1.3B | T2V bidireccional |
| [`nvidia/AnyFlow-Wan2.1-T2V-14B-Diffusers`](https://huggingface.co/nvidia/AnyFlow-Wan2.1-T2V-14B-Diffusers) | Wan2.1 14B | T2V bidireccional |
| [`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` está diseñado para modelos de difusión bidireccionales en la generación de texto a video (T2V). `AnyFlowFARPipeline` es un modelo de difusión causal por bloques que admite la generación de texto a video (T2V), la generación de imagen a video (I2V) y la continuación de video (V2V).

### Generación con AnyFlow (T2V bidireccional)

```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)
```

### Generación con AnyFlow (FAR Causal)

El pipeline causal selecciona entre T2V / I2V / V2V mediante el argumento ``video`` (o ``video_latents``): omita ambos para texto a video simple, o pase ``video=<tensor>`` de forma ``(B, T, C, H, W)`` en ``[0, 1]`` con ``T = 4n + 1`` para condicionar en fotogramas existentes. Use un único fotograma de condicionamiento para I2V y un clip más largo para la continuación V2V. Si ya tiene latentes predecodificados en el layout del modelo, páselos mediante ``video_latents=<tensor>`` para omitir la codificación VAE. ``video`` y ``video_latents`` son mutuamente excluyentes.

> [!IMPORTANT]
> Los puntos de control publicados incluyen `chunk_partition=[1, 3, 3, 3, 3, 3, 3, 2]` (suma 21) en la configuración del transformer, correspondiente a los 81 fotogramas crudos canónicos (21 fotogramas latentes con la distancia temporal del VAE de 4). Al cambiar `num_frames`, debe pasar un `chunk_partition` que sume `(num_frames - 1) // 4 + 1`; de lo contrario, el pipeline lanzará un `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)
```

## Notas

- La guía sin clasificador se fusiona en los puntos de control publicados, por lo que la inferencia no ejecuta una segunda pasada de adelante guiada. Mantenga el valor predeterminado `guidance_scale=1.0` a menos que su propio punto de control requiera lo contrario.
- `FlowMapEulerDiscreteScheduler` es de uso general. Puedes adjuntarlo a cualquier punto de control destilado de flow-map mediante `from_pretrained(..., scheduler=FlowMapEulerDiscreteScheduler.from_config(...))`.
- `AnyFlowPipeline` utiliza [`AnyFlowTransformer3DModel`](../models/anyflow_transformer3d) (bidireccional). `AnyFlowFARPipeline` utiliza [`AnyFlowFARTransformer3DModel`](../models/anyflow_far_transformer3d), que añade un patch embedding de cuadro comprimido y la máscara de bloques causal de FAR.
- La carga de LoRA se admite mediante `WanLoraLoaderMixin`, el mismo mixin utilizado por las pipelines de Wan de origen.
- Para las recetas de entrenamiento (entrenamiento de forward flow-map y destilación on-policy), consulte el marco de entrenamiento original de AnyFlow en [`NVlabs/AnyFlow`](https://github.com/NVlabs/AnyFlow); el entrenamiento está fuera del alcance de diffusers.

## AnyFlowPipeline[[diffusers.AnyFlowPipeline]]

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

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

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

**Parámetros:**

tokenizer ([*AutoTokenizer*]) : Tokenizador 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 flujo bidireccional.

vae ([*AutoencoderKLWan*]) : VAE que codifica y decodifica videos hacia y desde representaciones latentes.

scheduler ([*FlowMapEulerDiscreteScheduler*]) : Muestreador de mapa de flujo. El pipeline ejecuta `scheduler.step(..., timestep, sample, r_timestep)` en cada paso de inferencia.

Pipeline de generación de texto a video bidireccional para puntos de control destilados con flow-map de AnyFlow, introducidos en [AnyFlow](https://huggingface.co/papers/2605.13724).

AnyFlow aprende transiciones de intervalos arbitrarios \\(z_t \to z_r\\) en lugar del mapeo fijo \\(z_t \to z_0\\) de los modelos de consistencia, por lo que un único checkpoint destilado puede evaluarse con 1, 2, 4, 8, 16... NFE sin necesidad de volver a entrenar. Este pipeline opera sobre el tensor de video completo en una sola pasada bidireccional; para la generación autoregresiva (causal) por fragmentos, use `AnyFlowFARPipeline`.

El muestreo es un Euler simple en forma de velocidad media (`z_r = z_t - (t - r) * u`) sin re-ruido. Los puntos de control de NVIDIA publicados integran la guía libre de clasificador en los pesos del modelo, por lo que la configuración predeterminada `guidance_scale=1.0` es la recomendada.

Este modelo hereda de [*DiffusionPipeline*]. Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un 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)
```

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

**Parámetros:**

prompt (`str` o `List[str]`, *opcional*) : El prompt o los prompts para guiar la generación del video. Si no se define, pase `prompt_embeds` en su lugar.

video (`torch.Tensor`, *opcional*) : Marcos de condicionamiento previos al VAE con forma `(B, T, C, H, W)` en `[0, 1]`. Cuando se proporcionan, el pipeline los codifica con el VAE y mantiene fijo el prefijo latente correspondiente durante el muestreo. Es mutuamente excluyente con `video_latents`.

video_latents (`torch.Tensor`, *opcional*) : Latentes VAE precodificados en el formato AnyFlow `(B, T_latent, C, H_latent, W_latent)`. Omite la codificación VAE en el lado de la pipeline. Es mutuamente excluyente con `video`.

negative_prompt (`str` o `List[str]`, *opcional*) : El prompt o los prompts a evitar durante la generación de video. Se ignora cuando no se usa guía (`guidance_scale < 1`).

height (`int`, por defecto `480`) : La altura en píxeles del video generado.

width (`int`, por defecto `832`) : El ancho en píxeles del video generado.

num_frames (`int`, por defecto `81`) : El número de fotogramas en el video generado. Debe cumplir `(num_frames - 1) % vae_scale_factor_temporal == 0`.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Los puntos de control destilados de AnyFlow admiten muestreo de cualquier paso, por lo que valores tan bajos como `1`, `2`, `4` o `8` son habituales. Se ignora cuando se proporciona `sigmas` o `timesteps`.

sigmas (`List[float]`, *opcional*) : Programa de sigmas personalizado para muestreo de cualquier número de pasos, en `[0, 1]` y ordenado de ruidoso a limpio. La longitud determina el `num_inference_steps` efectivo; el programador añade el sigma terminal `0`.

timesteps (`List[float]`, *opcional*) : Programa de pasos de tiempo personalizado para muestreo de cualquier número de pasos, en las mismas unidades que `self.scheduler.timesteps` (es decir, escalado por `num_train_timesteps`). Mutuamente excluyente con `sigmas`.

guidance_scale (`float`, por defecto `1.0`) : Escala de guía libre de clasificador. Los puntos de control de AnyFlow publicados fusionan la CFG en los pesos durante el entrenamiento; manténgala en `1.0` a menos que sepa que su punto de control espera lo contrario.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado `1`) : El número de videos a generar por indicación.

generator (`torch.Generator` o `List[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados para usar como entradas. Si no se proporcionan, los latentes se muestrean del `generator` suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar las entradas de texto (p. ej., ponderación de prompts). Si no se proporcionan, los embeddings se generan a partir de `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados.

output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida. Uno de `"pil"`, `"np"`, `"pt"` o `"latent"`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un `AnyFlowPipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Una función o `PipelineCallback` que se llama al final de cada paso de inferencia. Consulte [`callbacks`](../callbacks) para obtener más detalles.

callback_on_step_end_tensor_inputs (`List[str]`, *opcional*, por defecto `["latents"]`) : Las entradas de tensor que se reenvían a la función de callback. Debe ser un subconjunto de `self._callback_tensor_inputs`.

max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto. Los prompts más largos se truncan.

use_mean_velocity (`bool`, por defecto `True`) : Cuando `True`, el modelo flow-map se condiciona tanto al paso de tiempo de origen `t` como al paso de tiempo de destino `r` para predecir una velocidad media, coincidiendo con el comportamiento durante el entrenamiento. Desactívalo para replicar el paso de Euler sin procesar (`r = t`).

**Devuelve:** `~AnyFlowPipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `AnyFlowPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es el video generado.

La función de llamada para el pipeline de generación.

Ejemplos:
```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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

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

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

Codifica el prompt en estados ocultos del codificador de texto.

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

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

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

Codifica un video en el espacio de píxeles en el diseño latente de AnyFlow.

Refleja la convención de un único helper de otros pipelines de diffusers (cf. `WanImageToVideoPipeline.encode_image`): encapsula el preprocesamiento, la codificación VAE y la normalización de latentes en una sola llamada. El formato de salida es `(B, T_latent, C, H, W)`, que es lo que el transformer de AnyFlow espera para los frames de condicionamiento.

## AnyFlowFARPipeline[[diffusers.AnyFlowFARPipeline]]

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

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

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

**Parámetros:**

tokenizer ([*AutoTokenizer*]) : Tokenizador 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 flujo causal FAR.

vae ([*AutoencoderKLWan*]) : VAE que codifica y decodifica videos hacia y desde representaciones latentes.

scheduler ([*FlowMapEulerDiscreteScheduler*]) : Muestreador de mapa de flujo.

Causal Pipeline (basado en FAR) de texto a video / imagen a video / video a video para puntos de control de AnyFlow, introducido en [AnyFlow](https://huggingface.co/papers/2605.13724).

El pipeline dirige un bucle de muestreo autoregresivo por bloques: cada bloque se desruidifica con pasos de flow-map mientras atiende únicamente a los bloques anteriores mediante atención causal bloque-esparcida, y la caché KV intermedia se reutiliza entre bloques.

El modo de tarea (T2V / I2V / V2V) se selecciona según el argumento de condicionamiento que se pase a `__call__`:

- tanto `video=None` como `video_latents=None` — texto a video puro.
- `video=&amp;lt;tensor of shape (B, T, C, H, W) in [0, 1] with T = 4n + 1>` — fotogramas de condicionamiento previos al VAE; el pipeline los codifica con el VAE. Pasa un video de un solo fotograma para I2V o un clip de varios fotogramas para V2V.
- `video_latents=&amp;lt;latent tensor of shape (B, T_latent, C, H_latent, W_latent)>` — latentes ya codificados en el formato FAR (omite el paso de codificación VAE).

El backbone FAR es la variante causal Wan2.1 introducida por [FAR](https://huggingface.co/papers/2503.19325). La inferencia es un Euler simple en forma de velocidad media por chunk, sin re-ruído. Se admite T2V / I2V / V2V conjunto mediante un único modelo destilado.

Este modelo hereda de [*DiffusionPipeline*]. Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un 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)
```

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

**Parámetros:**

prompt (`str` o `List[str]`, *opcional*) : El prompt o los prompts para guiar la generación del video. Si no se define, pase `prompt_embeds` en su lugar.

video (`torch.Tensor`, *opcional*) : Marcos de condicionamiento previos al VAE con forma `(B, T, C, H, W)` en `[0, 1]` (`T = 4n + 1`). Cuando se proporcionan, el pipeline los codifica con el VAE y mantiene fijo el prefijo latente correspondiente durante el muestreo. Es mutuamente excluyente con `video_latents`.

video_latents (`torch.Tensor`, *opcional*) : Latentes VAE precodificados en el formato FAR `(B, T_latent, C, H_latent, W_latent)`. Omite la codificación VAE en el lado del pipeline. Es mutuamente excluyente con `video`.

negative_prompt (`str` o `List[str]`, *opcional*) : El prompt o los prompts a evitar durante la generación de video. Se ignora cuando no se usa guía (`guidance_scale < 1`).

height (`int`, por defecto `480`) : La altura en píxeles del video generado.

width (`int`, por defecto `832`) : El ancho en píxeles del video generado.

num_frames (`int`, por defecto `81`) : El número de fotogramas en el video generado. Debe cumplir `(num_frames - 1) % vae_scale_factor_temporal == 0`.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido por bloque. Los puntos de control destilados de AnyFlow-FAR admiten muestreo de cualquier número de pasos (1, 2, 4, 8, ...). Se ignora cuando se proporciona `sigmas` o `timesteps`.

sigmas (`List[float]`, *opcional*) : Programa de sigmas personalizado para muestreo de cualquier número de pasos, en `[0, 1]` y ordenado de ruidoso a limpio. La longitud determina el `num_inference_steps` efectivo; el programador añade el sigma terminal `0`.

timesteps (`List[float]`, *opcional*) : Programa de pasos de tiempo personalizado para muestreo de cualquier número de pasos, en las mismas unidades que `self.scheduler.timesteps` (es decir, escalado por `num_train_timesteps`). Mutuamente excluyente con `sigmas`.

guidance_scale (`float`, por defecto `1.0`) : Escala de guía libre de clasificador. Los puntos de control de AnyFlow publicados fusionan la CFG en los pesos durante el entrenamiento; manténgala en `1.0` a menos que el punto de control requiera lo contrario.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado `1`) : El número de videos a generar por indicación.

generator (`torch.Generator` o `List[torch.Generator]`, *opcional*) : Generador utilizado para sembrar el muestreo.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados. Si no se proporcionan, los latentes se muestrean del `generator` suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Si no se proporcionan, los embeddings se generan a partir de `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados.

output_type (`str`, *opcional*, por defecto `"np"`) : Formato de salida. Uno de `"pil"`, `"np"`, `"pt"` o `"latent"`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un `AnyFlowPipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Una función o `PipelineCallback` que se llama al final de cada paso de inferencia.

callback_on_step_end_tensor_inputs (`List[str]`, *opcional*, valor predeterminado `["latents"]`) : Entradas de tensor reenviadas a la función de callback. Debe ser un subconjunto de `self._callback_tensor_inputs`.

max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto.

use_mean_velocity (`bool`, por defecto `True`) : Cuando `True`, condiciona el modelo flow-map tanto en el paso de tiempo de origen `t` como en el paso de tiempo de destino `r` para predecir una velocidad media. Desactívalo para replicar el pasoado bruto de Euler.

use_kv_cache (`bool`, por defecto `True`) : Reutiliza la caché KV de la atención FAR entre los fragmentos causales. Desactívalo solo para depuración.

chunk_partition (`List[int]`, *opcional*) : Número de fotogramas por bloque. El valor predeterminado es `self.transformer.config.chunk_partition` (coincide con los puntos de control de 81 fotogramas publicados). Cuando cambias `num_frames`, proporciona un `chunk_partition` que sume `(num_frames - 1) // vae_scale_factor_temporal + 1`.

**Devuelve:** `~AnyFlowPipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve un `AnyFlowPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es el video generado.

La función de llamada para el pipeline de generación.

Ejemplos:
```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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

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

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

Codifica el prompt en estados ocultos del codificador de texto.

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

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

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

Codifica un video en el espacio de píxeles en el diseño latente de AnyFlow.

Refleja la convención de un único helper de otros pipelines de diffusers (cf. `WanImageToVideoPipeline.encode_image`): encapsula el preprocesamiento, la codificación VAE y la normalización de latentes en una sola llamada. El formato de salida es `(B, T_latent, C, H, W)`, que es lo que el transformer de AnyFlow espera para los frames de condicionamiento.

## 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)
```

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

**Parámetros:**

frames (`torch.Tensor`, `np.ndarray` o list[list[PIL.Image.Image]]) : lista de salidas de video - Puede ser una lista anidada de longitud `batch_size,` donde cada sublista contiene secuencias de imágenes PIL desruidas de longitud `num_frames.` También puede ser un array de NumPy o un tensor de Torch de forma `(batch_size, num_frames, channels, height, width)`.

Clase de salida para las tuberías de AnyFlow.