# PAN 2

PAN2 es un modelo de mundo de base que simula cómo evoluciona una escena bajo un plan de acciones y movimientos de cámara fundamentado en el tiempo. Su simulador generativo de 29B es un transformador de difusión multimodal de doble flujo, integrado aquí; el [esqueleto de razonamiento](https://huggingface.co/IFM/PAN2#reasoning-backbone) que escribe sus indicaciones no lo está.

PAN 2 se integra únicamente como bloques de [Modular Diffusers](../../modular_diffusers/overview). [PAN2Blocks](/docs/diffusers/v0.43.0/es/api/pipelines/pan2#diffusers.PAN2Blocks) admite dos flujos de trabajo:

| Flujo de trabajo | Entradas |
|---|---|
| `t2v` | `prompt` |
| `i2v` | `prompt`, `image` |

```py
import torch
from diffusers import ModularPipeline
from diffusers.utils import export_to_video, load_image

pipe = ModularPipeline.from_pretrained("IFM/PAN2")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")

prompt = "A red fox trots through fresh snow in a pine forest at dawn."

video = pipe(prompt=prompt, generator=torch.Generator().manual_seed(0), output="videos")[0]
export_to_video(video, "pan2_t2v.mp4", fps=24)

image = load_image("path/to/first_frame.png")
video = pipe(prompt=prompt, image=image, generator=torch.Generator().manual_seed(0), output="videos")[0]
export_to_video(video, "pan2_i2v.mp4", fps=24)
```

La guía sin clasificador se configura en el guider (`guidance_scale=2.5` por defecto):

```py
pipe.update_components(guider=pipe.guider.new(guidance_scale=5.0))
```

Cada llamada toma un único prompt, que se codifica sin padding. Por lo tanto, el transformer nunca necesita una máscara de atención, y todos los [attention backend](../../optimization/attention_backends) están disponibles:

```py
pipe.transformer.set_attention_backend("flash_hub")  # FlashAttention-2
```

## Verificador de seguridad

PAN 2 ejecuta guardrails en el prompt antes de la generación y en cada video generado después, y un prompt o video bloqueado genera un `ValueError`. Las comprobaciones están activadas de forma predeterminada, y `load_components()` carga los guardrails, que requieren el paquete [PAN 2 guardrail](https://github.com/ifm-ai/pan2-guardrail):

```bash
pip install git+https://github.com/ifm-ai/pan2-guardrail
```

## Paralelismo de contexto

[PAN2Transformer3DModel](/docs/diffusers/v0.43.0/es/api/models/pan2_transformer3d#diffusers.PAN2Transformer3DModel) admite [context parallelism](../../optimization/context_parallelism). El número de tokens de texto y de vídeo normalmente no es divisible por el número de dispositivos (el número de tokens de texto depende del prompt), por lo que se debe usar `ulysses_anything` o `ring_anything` para la inferencia. El uso simple de `ulysses_degree` / `ring_degree`, por ejemplo para el entrenamiento, requiere que ambos recuentos de tokens sean divisibles por el tamaño de paralelismo de contexto.

```py
# torchrun --nproc_per_node=2 pan2_context_parallel.py
import torch
import torch.distributed as dist
from diffusers import ContextParallelConfig, ModularPipeline

dist.init_process_group("nccl")
rank = dist.get_rank()
torch.cuda.set_device(rank)

pipe = ModularPipeline.from_pretrained("IFM/PAN2")
pipe.load_components(dtype=torch.bfloat16)
pipe.to(f"cuda:{rank}")
pipe.transformer.enable_parallelism(config=ContextParallelConfig(ulysses_degree=2, ulysses_anything=True))

video = pipe(prompt="A red fox trots through fresh snow.", generator=torch.Generator().manual_seed(0), output="videos")[0]
dist.destroy_process_group()
```

## PAN2ModularPipeline[[diffusers.PAN2ModularPipeline]]

#### diffusers.PAN2ModularPipeline[[diffusers.PAN2ModularPipeline]]

```python
diffusers.PAN2ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pan2/modular_pipeline.py#L42)

Un ModularPipeline para PAN 2: texto a video e imagen a video a partir de un primer fotograma.

```py
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("IFM/PAN2")
pipe.load_components(dtype=torch.bfloat16)
```

#### check_safety_checker_loaded[[diffusers.PAN2ModularPipeline.check_safety_checker_loaded]]

```python
check_safety_checker_loaded()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pan2/modular_pipeline.py#L103)

Lanza una excepción si las comprobaciones están activas pero la barrera de seguridad PAN 2 no está cargada.

#### disable_safety_checker[[diffusers.PAN2ModularPipeline.disable_safety_checker]]

```python
disable_safety_checker()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pan2/modular_pipeline.py#L118)

Desactiva las comprobaciones de prompt y video, bajo tu propio riesgo.

#### enable_safety_checker[[diffusers.PAN2ModularPipeline.enable_safety_checker]]

```python
enable_safety_checker()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pan2/modular_pipeline.py#L97)

Comprueba el prompt y los videos generados con la barrera de seguridad PAN 2.

## PAN2Blocks[[diffusers.PAN2Blocks]]

#### diffusers.PAN2Blocks[[diffusers.PAN2Blocks]]

```python
diffusers.PAN2Blocks()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/pan2/modular_blocks_pan2.py#L251)

Bloques de pipeline modulares para la generación de texto a video e imagen a video con PAN 2.

Flujos de trabajo admitidos:
- `t2v`: requiere `prompt`
- `i2v`: requiere `prompt`, `image`

Componentes: text_encoder (`Qwen3_5TextModel`) tokenizer (`Qwen2Tokenizer`) safety_checker (`PAN2SafetyChecker`) vae (`AutoencoderKLWan`) video_processor (`VideoProcessor`) scheduler (`FlowMatchEulerDiscreteScheduler`) transformer (`PAN2Transformer3DModel`) guider (`ClassifierFreeGuidance`)

Configs: enable_safety_checker (predeterminado: True)

Entradas: prompt (`str`): El prompt para guiar la generación, una sola cadena de texto. negative_prompt (`str`, *opcional*): El prompt que no debe guiar la generación, una sola cadena de texto. Cuando la guía lo requiere y no se pasa ninguno (o se pasa uno vacío), se utiliza el prompt negativo predeterminado de PAN 2, con sus rangos de tiempo establecidos a la duración del clip. max_sequence_length (`int`, *opcional*, predeterminado 1536): Longitud máxima de la secuencia para la codificación del prompt. num_frames (`int`, *opcional*, predeterminado 313): Número de fotogramas de video a generar, de la forma `4 * n + 1`. fps (`float`, *opcional*, predeterminado 24.0): La tasa de fotogramas del video, que establece su duración en el prompt negativo predeterminado. image (`Image`, *opcional*): El primer fotograma, una sola imagen. height (`int`, *opcional*): La altura en píxeles del video generado, 704 por defecto. width (`int`, *opcional*): El ancho en píxeles del video generado, 1248 por defecto. num_videos_per_prompt (`int`, *opcional*, predeterminado 1): El número de videos a generar por prompt. image_latents (`Tensor`, *opcional*): Los latentes normalizados del primer fotograma. Pueden generarse desde el paso vae_encoder. num_inference_steps (`int`): El número de pasos de desruido. sigmas (`list`, *opcional*): Sigmas personalizados para el proceso de desruido. latents (`Tensor`): Latentes ruidosos pregenerados para usar como entradas para la generación de video. generator (`Generator`, *opcional*): Generador de Torch para una generación determinista. attention_kwargs (`dict`, *opcional*): Kwargs adicionales para los procesadores de atención. output_type (`str`, *opcional*, predeterminado np): Formato de salida: 'pil', 'np', 'pt'.

Salidas: videos (`list`): Los videos generados.