# PAN 2

PAN2 é um modelo de mundo fundamental que simula como uma cena evolui sob um plano de ações e movimentos de câmera ancorado no tempo. Seu simulador generativo de 29B é um transformador de difusão multimodal de fluxo duplo, integrado aqui; a [espinha dorsal de raciocínio](https://huggingface.co/IFM/PAN2#reasoning-backbone) que escreve seus prompts não é.

O PAN 2 é integrado apenas como blocos de [Modular Diffusers](../../modular_diffusers/overview). O [PAN2Blocks](/docs/diffusers/v0.43.0/pt/api/pipelines/pan2#diffusers.PAN2Blocks) suporta dois fluxos de trabalho:

| Fluxo de trabalho | 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)
```

A orientação sem classificador é configurada no guia (`guidance_scale=2.5` por padrão):

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

Cada chamada recebe um único prompt, que é codificado sem padding. Portanto, o transformer nunca precisa de uma máscara de atenção, e todos os [backends de atenção](../../optimization/attention_backends) estão disponíveis:

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

## Verificador de segurança

O PAN 2 executa guardrails no prompt antes da geração e em cada vídeo gerado depois, e um prompt ou vídeo bloqueado gera um `ValueError`. As verificações estão ativadas por padrão, e `load_components()` carrega os guardrails, que exigem o pacote [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/pt/api/models/pan2_transformer3d#diffusers.PAN2Transformer3DModel) suporta [context parallelism](../../optimization/context_parallelism). Os contagens de tokens de texto e vídeo geralmente não são divisíveis pelo número de dispositivos (o número de tokens de texto depende do prompt), então use `ulysses_anything` ou `ring_anything` para inferência. O `ulysses_degree` / `ring_degree` simples, por exemplo para treinamento, exige que ambas as contagens de tokens sejam divisíveis pelo tamanho do 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)
```

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

Uma ModularPipeline para PAN 2: texto para vídeo e imagem para vídeo a partir de um primeiro quadro.

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

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

Gere uma exceção se as verificações estiverem ativadas, mas a barreira de segurança PAN 2 não estiver carregada.

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

```python
disable_safety_checker()
```

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

Desative as verificações de prompt e vídeo, por sua conta e risco.

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

```python
enable_safety_checker()
```

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

Verifique o prompt e os vídeos gerados com a barreira de proteção PAN 2.

## PAN2Blocks[[diffusers.PAN2Blocks]]

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

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

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

Blocos de pipeline modulares para geração de texto para vídeo e imagem para vídeo com PAN 2.

Fluxos de trabalho suportados:
- `t2v`: requer `prompt`
- `i2v`: requer `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 (padrão: True)

Entradas: prompt (`str`): O prompt para orientar a geração, uma única string. negative_prompt (`str`, *opcional*): O prompt que não deve orientar a geração, uma única string. Quando a orientação precisa de um e nenhum (ou um vazio) é passado, o prompt negativo padrão do PAN 2 é usado, com seus intervalos de tempo definidos para a duração do clipe. max_sequence_length (`int`, *opcional*, padrão 1536): Comprimento máximo da sequência para a codificação do prompt. num_frames (`int`, *opcional*, padrão 313): Número de quadros de vídeo a serem gerados, na forma `4 * n + 1`. fps (`float`, *opcional*, padrão 24.0): A taxa de quadros do vídeo, que define sua duração no prompt negativo padrão. image (`Image`, *opcional*): O primeiro quadro, uma única imagem. height (`int`, *opcional*): A altura em pixels do vídeo gerado, 704 por padrão. width (`int`, *opcional*): A largura em pixels do vídeo gerado, 1248 por padrão. num_videos_per_prompt (`int`, *opcional*, padrão 1): O número de vídeos a serem gerados por prompt. image_latents (`Tensor`, *opcional*): Os latentes normalizados do primeiro quadro. Podem ser gerados a partir da etapa vae_encoder. num_inference_steps (`int`): O número de etapas de remoção de ruído. sigmas (`list`, *opcional*): Sigmas personalizados para o processo de remoção de ruído. latents (`Tensor`): Latentes ruidosos pré-gerados para usar como entradas para a geração de vídeo. generator (`Generator`, *opcional*): Gerador Torch para geração determinística. attention_kwargs (`dict`, *opcional*): Kwargs adicionais para os processadores de atenção. output_type (`str`, *opcional*, padrão np): Formato de saída: 'pil', 'np', 'pt'.

Saídas: vídeos (`list`): Os vídeos gerados.