#
# Licenciado sob a Apache License, Versão 2.0 (a "Licença");
# você não pode usar este arquivo, exceto em conformidade com a Licença.
# Você pode obter uma cópia da Licença em
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que exigido pela lei aplicável ou acordado por escrito, o software
# distribuído sob a Licença é distribuído em uma base "COMO ESTÁ",
# SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas.
# Consulte a Licença para o idioma específico que rege as permissões e
# limitações sob a Licença. -->

  
    
      
    
  

# SkyReels-V2: Modelo generativo de filmes de comprimento infinito

[SkyReels-V2](https://huggingface.co/papers/2504.13074) da equipe SkyReels da Skywork AI.

*Os avanços recentes na geração de vídeo foram impulsionados por modelos de difusão e frameworks autoregressivos, mas desafios críticos persistem na harmonização da aderência ao prompt, da qualidade visual, da dinâmica de movimento e da duração: concessões na dinâmica de movimento para melhorar a qualidade visual temporal, duração de vídeo limitada (5-10 segundos) para priorizar a resolução e geração inadequada consciente de planos, decorrente da incapacidade dos MLLMs de uso geral de interpretar a gramática cinematográfica, como composição de planos, expressões dos atores e movimentos de câmera. Essas limitações interligadas impedem a síntese realista de longa duração e a geração em estilo de filme profissional. Para abordar essas limitações, propomos o SkyReels-V2, um Modelo Generativo de Filme de Comprimento Infinito, que sinergiza Multi-modal Large Language Model (MLLM), Multi-stage Pretraining, Reinforcement Learning e Diffusion Forcing Framework. Primeiramente, projetamos uma representação estrutural abrangente do vídeo que combina as descrições gerais do Multi-modal LLM e a linguagem detalhada de planos por modelos sub-especialistas. Com o auxílio de anotação humana, treinamos então um Video Captioner unificado, chamado SkyCaptioner-V1, para rotular eficientemente os dados de vídeo. Em segundo lugar, estabelecemos pré-treinamento de resolução progressiva para a geração fundamental de vídeo, seguido por um aprimoramento de pós-treinamento em quatro estágios: o Supervised Fine-Tuning (SFT) inicial equilibrado em conceitos melhora a qualidade da linha de base; o treinamento de Reinforcement Learning (RL) específico para movimento com dados de distorção anotados por humanos e sintéticos aborda artefatos dinâmicos; nosso framework de difusão com agendamentos de ruído não decrescentes permite a síntese de vídeos longos em um espaço de busca eficiente; o SFT final de alta qualidade refina a fidelidade visual. Todo o código e os modelos estão disponíveis em [this https URL](https://github.com/SkyworkAI/SkyReels-V2).*

Você pode encontrar todos os checkpoints originais do SkyReels-V2 na organização [Skywork](https://huggingface.co/collections/Skywork/skyreels-v2-6801b1b93df627d441d0d0d9).

Os seguintes modelos SkyReels-V2 são suportados no Diffusers:
- [SkyReels-V2 DF 1.3B - 540P](https://huggingface.co/Skywork/SkyReels-V2-DF-1.3B-540P-Diffusers)
- [SkyReels-V2 DF 14B - 540P](https://huggingface.co/Skywork/SkyReels-V2-DF-14B-540P-Diffusers)
- [SkyReels-V2 DF 14B - 720P](https://huggingface.co/Skywork/SkyReels-V2-DF-14B-720P-Diffusers)
- [SkyReels-V2 T2V 14B - 540P](https://huggingface.co/Skywork/SkyReels-V2-T2V-14B-540P-Diffusers)
- [SkyReels-V2 T2V 14B - 720P](https://huggingface.co/Skywork/SkyReels-V2-T2V-14B-720P-Diffusers)
- [SkyReels-V2 I2V 1.3B - 540P](https://huggingface.co/Skywork/SkyReels-V2-I2V-1.3B-540P-Diffusers)
- [SkyReels-V2 I2V 14B - 540P](https://huggingface.co/Skywork/SkyReels-V2-I2V-14B-540P-Diffusers)
- [SkyReels-V2 I2V 14B - 720P](https://huggingface.co/Skywork/SkyReels-V2-I2V-14B-720P-Diffusers)

Este modelo foi contribuído por [M. Tolga Cangöz](https://github.com/tolgacangoz).

> [!TIP]
> Clique nos modelos SkyReels-V2 na barra lateral à direita para mais exemplos de geração de vídeo.

### Uma demonstração _Visual_

O exemplo abaixo possui os seguintes parâmetros:

- `base_num_frames=97`
- `num_frames=97`
- `num_inference_steps=30`
- `ar_step=5`
- `causal_block_size=5`

Com `vae_scale_factor_temporal=4`, espere `5` blocos de `5` quadros cada, conforme calculado por:

`num_latent_frames: (97-1)//vae_scale_factor_temporal+1 = 25 frames -> 5 blocks of 5 frames each`

E o comprimento máximo do contexto no espaço latente é calculado com `base_num_latent_frames`:

`base_num_latent_frames = (97-1)//vae_scale_factor_temporal+1 = 25 -> 25//5 = 5 blocks`

Linha do tempo do processamento assíncrono:
```text
┌─────────────────────────────────────────────────────────────────┐
│ Steps:    1    6   11   16   21   26   31   36   41   46   50   │
│ Block 1: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■]                       │
│ Block 2:      [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■]                  │
│ Block 3:           [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■]             │
│ Block 4:                [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■]        │
│ Block 5:                     [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■]   │
└─────────────────────────────────────────────────────────────────┘
```

Para vídeos longos (`num_frames` > `base_num_frames`): `base_num_frames` atua como o "tamanho da janela deslizante" para o processamento de vídeos longos.

Exemplo: vídeo de `257` quadros com `base_num_frames=97`, `overlap_history=17`
```text
┌──── Iteration 1 (frames 1-97) ────┐
│ Processing window: 97 frames      │ → 5 blocks,
│ Generates: frames 1-97            │   async processing
└───────────────────────────────────┘
            ┌────── Iteration 2 (frames 81-177) ──────┐
            │ Processing window: 97 frames            │
            │ Overlap: 17 frames (81-97) from prev    │ → 5 blocks,
            │ Generates: frames 98-177                │   async processing
            └─────────────────────────────────────────┘
                        ┌────── Iteration 3 (frames 161-257) ──────┐
                        │ Processing window: 97 frames             │
                        │ Overlap: 17 frames (161-177) from prev   │ → 5 blocks,
                        │ Generates: frames 178-257                │   async processing
                        └──────────────────────────────────────────┘
```

Cada iteração executa independentemente o processamento assíncrono com seus próprios `5` blocos. `base_num_frames` controla:
1. Uso de memória (janela maior = mais VRAM)
2. Comprimento do contexto do modelo (deve corresponder às restrições de treinamento)
3. Número de blocos por iteração (`base_num_latent_frames // causal_block_size`)

Cada bloco leva `30` etapas para concluir o desruido. O bloco N começa na etapa: `1 + (N-1) x ar_step` Etapas totais: `30 + (5-1) x 5 = 50` etapas

O modo síncrono (`ar_step=0`) processaria todos os blocos/frames simultaneamente:
```text
┌──────────────────────────────────────────────┐
│ Steps:       1            ...            30  │
│ All blocks: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] │
└──────────────────────────────────────────────┘
```
Total de etapas: `30` etapas

Um exemplo de como a matriz de etapas é construída para processamento assíncrono: Dado os parâmetros: (`num_inference_steps=30, flow_shift=8, num_frames=97, ar_step=5, causal_block_size=5`)
```
- num_latent_frames = (97 frames - 1) // (4 temporal downsampling) + 1 = 25
- step_template = [999, 995, 991, 986, 980, 975, 969, 963, 956, 948,
                   941, 932, 922, 912, 901, 888, 874, 859, 841, 822,
                   799, 773, 743, 708, 666, 615, 551, 470, 363, 216]
```

O algoritmo cria uma `step_matrix` `50x25` em que:
```
- Row 1:  [999×5, 999×5, 999×5, 999×5, 999×5]
- Row 2:  [995×5, 999×5, 999×5, 999×5, 999×5]
- Row 3:  [991×5, 999×5, 999×5, 999×5, 999×5]
- ...
- Row 7:  [969×5, 995×5, 999×5, 999×5, 999×5]
- ...
- Row 21: [799×5, 888×5, 941×5, 975×5, 999×5]
- ...
- Row 35: [  0×5, 216×5, 666×5, 822×5, 901×5]
- ...
- Row 42: [  0×5,   0×5,   0×5, 551×5, 773×5]
- ...
- Row 50: [  0×5,   0×5,   0×5,   0×5, 216×5]
```

Análise detalhada da linha `6`:
```
- step_matrix[5]:      [ 975×5,  999×5,   999×5,   999×5,   999×5]
- step_index[5]:       [   6×5,    1×5,     0×5,     0×5,     0×5]
- step_update_mask[5]: [True×5, True×5, False×5, False×5, False×5]
- valid_interval[5]:   (0, 25)
```

Padrão principal: o Bloco `i` fica exatamente `ar_step=5` passos temporais atrás do Bloco `i-1`, criando o efeito escalonado de "diffusion forcing", em que blocos posteriores condicionam blocos anteriores mais limpos.

### Geração de Texto para Vídeo

O exemplo abaixo demonstra como gerar um vídeo a partir de texto.

Consulte o guia [Reduzir o uso de memória](../../optimization/memory) para mais detalhes sobre as diversas técnicas de economia de memória.

Do repositório original:
>Você pode usar --ar_step 5 para habilitar a inferência assíncrona. Quando a inferência assíncrona é utilizada, recomenda-se --causal_block_size 5, enquanto para a geração síncrona esse parâmetro não deve ser definido... A inferência assíncrona exigirá mais etapas para difundir a sequência inteira, o que significa que será MAIS LENTA do que o modo síncrono. Em nossos experimentos, a inferência assíncrona pode melhorar o desempenho de seguimento de instruções e a consistência visual.

```py
import torch
from diffusers import AutoModel, SkyReelsV2DiffusionForcingPipeline, UniPCMultistepScheduler
from diffusers.utils import export_to_video

model_id = "Skywork/SkyReels-V2-DF-1.3B-540P-Diffusers"
vae = AutoModel.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)

pipeline = SkyReelsV2DiffusionForcingPipeline.from_pretrained(
    model_id,
    vae=vae,
    dtype=torch.bfloat16,
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"
flow_shift = 8.0  # 8.0 for T2V, 5.0 for I2V
pipeline.scheduler = UniPCMultistepScheduler.from_config(pipeline.scheduler.config, flow_shift=flow_shift)

prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."

output = pipeline(
    prompt=prompt,
    num_inference_steps=30,
    height=544,  # 720 for 720P
    width=960,   # 1280 for 720P
    num_frames=97,
    base_num_frames=97,  # 121 for 720P
    ar_step=5,  # Controls asynchronous inference (0 for synchronous mode)
    causal_block_size=5,  # Number of frames in each block for asynchronous processing
    overlap_history=None,  # Number of frames to overlap for smooth transitions in long videos; 17 for long video generations
    addnoise_condition=20,  # Improves consistency in long video generation
).frames[0]
export_to_video(output, "video.mp4", fps=24, quality=8)
```

### Geração de Vídeo a Partir do Primeiro e Último Quadro

O exemplo abaixo demonstra como usar o pipeline de imagem para vídeo para gerar um vídeo usando uma descrição de texto, um quadro inicial e um quadro final.

```python
import numpy as np
import torch
import torchvision.transforms.functional as TF
from diffusers import AutoencoderKLWan, SkyReelsV2DiffusionForcingImageToVideoPipeline, UniPCMultistepScheduler
from diffusers.utils import export_to_video, load_image

model_id = "Skywork/SkyReels-V2-DF-1.3B-720P-Diffusers"
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
pipeline = SkyReelsV2DiffusionForcingImageToVideoPipeline.from_pretrained(
    model_id, vae=vae, dtype=torch.bfloat16
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"
flow_shift = 5.0  # 8.0 for T2V, 5.0 for I2V
pipeline.scheduler = UniPCMultistepScheduler.from_config(pipeline.scheduler.config, flow_shift=flow_shift)

first_frame = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_first_frame.png")
last_frame = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_last_frame.png")

def aspect_ratio_resize(image, pipeline, max_area=720 * 1280):
    aspect_ratio = image.height / image.width
    mod_value = pipeline.vae_scale_factor_spatial * pipeline.transformer.config.patch_size[1]
    height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
    width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
    image = image.resize((width, height))
    return image, height, width

def center_crop_resize(image, height, width):
    # Calculate resize ratio to match first frame dimensions
    resize_ratio = max(width / image.width, height / image.height)

    # Resize the image
    width = round(image.width * resize_ratio)
    height = round(image.height * resize_ratio)
    size = [width, height]
    image = TF.center_crop(image, size)

    return image, height, width

first_frame, height, width = aspect_ratio_resize(first_frame, pipeline)
if last_frame.size != first_frame.size:
    last_frame, _, _ = center_crop_resize(last_frame, height, width)

prompt = "CG animation style, a small blue bird takes off from the ground, flapping its wings. The bird's feathers are delicate, with a unique pattern on its chest. The background shows a blue sky with white clouds under bright sunshine. The camera follows the bird upward, capturing its flight and the vastness of the sky from a close-up, low-angle perspective."

output = pipeline(
    image=first_frame, last_image=last_frame, prompt=prompt, height=height, width=width, guidance_scale=5.0
).frames[0]
export_to_video(output, "video.mp4", fps=24, quality=8)
```

### Geração de Vídeo para Vídeo

`SkyReelsV2DiffusionForcingVideoToVideoPipeline` estende um vídeo dado.

```python
import numpy as np
import torch
import torchvision.transforms.functional as TF
from diffusers import AutoencoderKLWan, SkyReelsV2DiffusionForcingVideoToVideoPipeline, UniPCMultistepScheduler
from diffusers.utils import export_to_video, load_video

model_id = "Skywork/SkyReels-V2-DF-1.3B-720P-Diffusers"
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
pipeline = SkyReelsV2DiffusionForcingVideoToVideoPipeline.from_pretrained(
    model_id, vae=vae, dtype=torch.bfloat16
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"
flow_shift = 5.0  # 8.0 for T2V, 5.0 for I2V
pipeline.scheduler = UniPCMultistepScheduler.from_config(pipeline.scheduler.config, flow_shift=flow_shift)

video = load_video("input_video.mp4")

prompt = "CG animation style, a small blue bird takes off from the ground, flapping its wings. The bird's feathers are delicate, with a unique pattern on its chest. The background shows a blue sky with white clouds under bright sunshine. The camera follows the bird upward, capturing its flight and the vastness of the sky from a close-up, low-angle perspective."

output = pipeline(
    video=video, prompt=prompt, height=720, width=1280, guidance_scale=5.0, overlap_history=17,
    num_inference_steps=30, num_frames=257, base_num_frames=121#, ar_step=5, causal_block_size=5,
).frames[0]
export_to_video(output, "video.mp4", fps=24, quality=8)
# Total frames will be the number of frames of the given video + 257
```

## Observações

- O SkyReels-V2 suporta LoRAs com [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.SkyReelsV2LoraLoaderMixin.load_lora_weights).

`SkyReelsV2Pipeline` e `SkyReelsV2ImageToVideoPipeline` também estão disponíveis sem o framework Diffusion Forcing aplicado.

## SkyReelsV2DiffusionForcingPipeline[[diffusers.SkyReelsV2DiffusionForcingPipeline]]

#### diffusers.SkyReelsV2DiffusionForcingPipeline[[diffusers.SkyReelsV2DiffusionForcingPipeline]]

```python
diffusers.SkyReelsV2DiffusionForcingPipeline(tokenizer: AutoTokenizer, text_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModel, transformer: SkyReelsV2Transformer3DModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing.py#L128)

**Parâmetros:**

tokenizer (`AutoTokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder (`UMT5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([SkyReelsV2Transformer3DModel](/docs/diffusers/main/pt/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.

Pipeline para geração de Texto-para-Vídeo (t2v) usando SkyReels-V2 com difusão forçada.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.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.SkyReelsV2DiffusionForcingPipeline.__call__]]

```python
__call__(prompt: str | list[str], negative_prompt: str | list[str] = None, height: int = 544, width: int = 960, num_frames: int = 97, num_inference_steps: int = 50, guidance_scale: float = 6.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, 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: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, overlap_history: int | None = None, addnoise_condition: float = 0, base_num_frames: int = 97, ar_step: int = 0, causal_block_size: int | None = None, fps: int = 24)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing.py#L598)

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.

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

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

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

num_frames (`int`, padrão `97`) : O número de quadros no vídeo gerado.

num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

guidance_scale (`float`, padrão `6.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. (**6.0 para T2V**, **5.0 para I2V**)

num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas 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, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `SkyReelsV2PipelineOutput` 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

max_sequence_length (`int`, *opcional*, padrão `512`) : O comprimento máximo da sequência do prompt.

overlap_history (`int`, *opcional*, padrão `None`) : Número de quadros sobrepostos para transições suaves em vídeos longos. Se `None`, o pipeline assume o modo de geração de vídeo curto e nenhum sobreposição é aplicada. Recomenda-se definir 17 ou 37.

addnoise_condition (`float`, *opcional*, padrão `0`) : Isso é usado para ajudar a suavizar a geração de vídeos longos adicionando algum ruído à condição limpa. Ruído muito grande também pode causar inconsistência. 20 é um valor recomendado, e você pode tentar valores maiores, mas é recomendado não exceder 50.

base_num_frames (`int`, *opcional*, padrão `97`) : 97 ou 121 | Número de quadros base (**97 para 540P**, **121 para 720P**)

ar_step (`int`, *opcional*, padrão `0`) : Controla a inferência assíncrona (0 para o modo síncrono) Você pode definir `ar_step=5` para habilitar a inferência assíncrona. Na inferência assíncrona, recomenda-se `causal_block_size=5`, enquanto não se deve definir esse parâmetro para a geração síncrona. A inferência assíncrona levará mais etapas para difundir a sequência inteira, o que significa que será MAIS LENTA do que o modo síncrono. Em nossos experimentos, a inferência assíncrona pode melhorar o desempenho de seguimento de instruções e consistência visual.

causal_block_size (`int`, *opcional*, padrão `None`) : O número de quadros em cada bloco/trecho. Recomendado ao usar inferência assíncrona (quando ar_step > 0)

fps (`int`, *opcional*, padrão `24`) : Taxa de quadros do vídeo gerado

**Retorna:** `~SkyReelsV2PipelineOutput` ou `tuple`

Se `return_dict` for `True`, `SkyReelsV2PipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

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

Exemplos:
```py
>>> import torch
>>> from diffusers import (
...     SkyReelsV2DiffusionForcingPipeline,
...     UniPCMultistepScheduler,
...     AutoencoderKLWan,
... )
>>> from diffusers.utils import export_to_video

>>> # Load the pipeline
>>> # Available models:
>>> # - Skywork/SkyReels-V2-DF-1.3B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-DF-14B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-DF-14B-720P-Diffusers
>>> vae = AutoencoderKLWan.from_pretrained(
...     "Skywork/SkyReels-V2-DF-14B-720P-Diffusers",
...     subfolder="vae",
...     torch_dtype=torch.float32,
... )
>>> pipe = SkyReelsV2DiffusionForcingPipeline.from_pretrained(
...     "Skywork/SkyReels-V2-DF-14B-720P-Diffusers",
...     vae=vae,
...     torch_dtype=torch.bfloat16,
... )
>>> flow_shift = 8.0  # 8.0 for T2V, 5.0 for I2V
>>> pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=flow_shift)
>>> pipe = pipe.to("cuda")

>>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."

>>> output = pipe(
...     prompt=prompt,
...     num_inference_steps=30,
...     height=544,
...     width=960,
...     guidance_scale=6.0,  # 6.0 for T2V, 5.0 for I2V
...     num_frames=97,
...     ar_step=5,  # Controls asynchronous inference (0 for synchronous mode)
...     causal_block_size=5,  # Number of frames processed together in a causal block
...     overlap_history=None,  # Number of frames to overlap for smooth transitions in long videos
...     addnoise_condition=20,  # Improves consistency in long video generation
... ).frames[0]
>>> export_to_video(output, "video.mp4", fps=24, quality=8)
```

#### encode_prompt[[diffusers.SkyReelsV2DiffusionForcingPipeline.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/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing.py#L219)

**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.

#### generate_timestep_matrix[[diffusers.SkyReelsV2DiffusionForcingPipeline.generate_timestep_matrix]]

```python
generate_timestep_matrix(num_latent_frames: int, step_template: Tensor, base_num_latent_frames: int, ar_step: int = 5, num_pre_ready: int = 0, causal_block_size: int = 1, shrink_interval_with_mask: bool = False)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing.py#L418)

**Parâmetros:**

num_latent_frames (int) : Número total de quadros latentes a serem gerados

step_template (torch.Tensor) : Agenda de passos de tempo base (por exemplo, [1000, 800, 600, ..., 0])

base_num_latent_frames (int) : Número máximo de quadros que o modelo pode processar em uma única passagem

ar_step (int, opcional) : Tamanho do passo autoregressivo para defasagem temporal. 0 = síncrono, >0 = assíncrono. Padrão é 5.

num_pre_ready (int, opcional) : Número de quadros já desruídos (por exemplo, de um prefixo em uma tarefa video2video). Padrão é 0.

causal_block_size (int, opcional) : Número de quadros processados como um bloco causal. O valor padrão é 1.

shrink_interval_with_mask (bool, opcional) : Se deve otimizar os intervalos de processamento. O padrão é False.

**Retorna:** `tuple containing`

- step_matrix (torch.Tensor): Matriz de timesteps para cada frame em cada iteração. Formato: [num_iterations, num_latent_frames]
- step_index (torch.Tensor): Matriz de índices para consulta de timestep. Formato: [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor): Máscara booleana indicando quais quadros atualizar. Formato: [num_iterations, num_latent_frames]
- valid_interval (list[tuple]): lista de intervalos (início, fim) para cada iteração

**Exceções:** ``ValueError``

- ``ValueError`` -- Se ar_step for muito pequeno para a configuração fornecida

Esta função implementa o algoritmo central de difusão forçada que cria um agendamento coordenado de remoção de ruído entre os quadros temporais. Ele suporta ambos os modos de geração síncrono e assíncrono:

**Modo síncrono** (ar_step=0, causal_block_size=1):
- Todos os quadros são desruídos simultaneamente em cada passo de tempo
- Cada quadro segue a mesma trajetória de remoção de ruído: [1000, 800, 600, ..., 0]
- Mais simples, mas pode ter menos consistência temporal para vídeos longos

**Modo assíncrono** (ar_step>0, causal_block_size>1):
- Os frames são agrupados em blocos causais e processados bloco a bloco
- Cada bloco é desruído em um padrão escalonado, criando uma "onda de desruído"
- Blocos anteriores são mais desruidados, enquanto blocos posteriores ficam para trás em ar_step passos
- Cria dependências temporais mais fortes e uma melhor consistência

## SkyReelsV2DiffusionForcingImageToVideoPipeline[[diffusers.SkyReelsV2DiffusionForcingImageToVideoPipeline]]

#### diffusers.SkyReelsV2DiffusionForcingImageToVideoPipeline[[diffusers.SkyReelsV2DiffusionForcingImageToVideoPipeline]]

```python
diffusers.SkyReelsV2DiffusionForcingImageToVideoPipeline(tokenizer: AutoTokenizer, text_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModel, transformer: SkyReelsV2Transformer3DModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing_i2v.py#L133)

**Parâmetros:**

tokenizer (`AutoTokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder (`UMT5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([SkyReelsV2Transformer3DModel](/docs/diffusers/main/pt/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.

Pipeline para geração de Imagem-para-Vídeo (i2v) usando SkyReels-V2 com diffusion forcing.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.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.SkyReelsV2DiffusionForcingImageToVideoPipeline.__call__]]

```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 544, width: int = 960, num_frames: int = 97, num_inference_steps: int = 50, guidance_scale: float = 5.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, 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, image_embeds: typing.Optional[torch.Tensor] = None, last_image: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, overlap_history: int | None = None, addnoise_condition: float = 0, base_num_frames: int = 97, ar_step: int = 0, causal_block_size: int | None = None, fps: int = 24)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing_i2v.py#L644)

**Parâmetros:**

image (`PipelineImageInput`) : A imagem de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou um `torch.Tensor`.

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.

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

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

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

num_frames (`int`, padrão `97`) : O número de quadros no vídeo gerado.

num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. (**6.0 para T2V**, **5.0 para I2V**)

num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas 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, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `negative_prompt`.

image_embeds (`torch.Tensor`, *opcional*) : Embebimentos de imagem pré-gerados. Pode ser usado para ajustar facilmente as entradas de imagem (ponderação). Se não for fornecido, os embebimentos de imagem são gerados a partir do argumento de entrada `image`.

last_image (`torch.Tensor`, *opcional*) : Embebimentos de imagem pré-gerados. Pode ser usado para ajustar facilmente as entradas de imagem (ponderação). Se não for fornecido, os embebimentos de imagem são gerados a partir do argumento de entrada `image`.

output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `SkyReelsV2PipelineOutput` 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

max_sequence_length (`int`, *opcional*, padrão `512`) : O comprimento máximo da sequência do prompt.

overlap_history (`int`, *opcional*, padrão `None`) : Número de quadros sobrepostos para transições suaves em vídeos longos. Se `None`, o pipeline assume o modo de geração de vídeo curto e nenhum sobreposição é aplicada. Recomenda-se definir 17 ou 37.

addnoise_condition (`float`, *opcional*, padrão `0`) : Isso é usado para ajudar a suavizar a geração de vídeos longos adicionando algum ruído à condição limpa. Ruído muito grande também pode causar inconsistência. 20 é um valor recomendado, e você pode tentar valores maiores, mas é recomendado não exceder 50.

base_num_frames (`int`, *opcional*, padrão `97`) : 97 ou 121 | Número de quadros base (**97 para 540P**, **121 para 720P**)

ar_step (`int`, *opcional*, padrão `0`) : Controla a inferência assíncrona (0 para o modo síncrono) Você pode definir `ar_step=5` para habilitar a inferência assíncrona. Na inferência assíncrona, recomenda-se `causal_block_size=5`, enquanto não se deve definir esse parâmetro para a geração síncrona. A inferência assíncrona levará mais etapas para difundir a sequência inteira, o que significa que será MAIS LENTA do que o modo síncrono. Em nossos experimentos, a inferência assíncrona pode melhorar o desempenho de seguimento de instruções e consistência visual.

causal_block_size (`int`, *opcional*, padrão `None`) : O número de quadros em cada bloco/trecho. Recomendado ao usar inferência assíncrona (quando ar_step > 0)

fps (`int`, *opcional*, padrão `24`) : Taxa de quadros do vídeo gerado

**Retorna:** `~SkyReelsV2PipelineOutput` ou `tuple`

Se `return_dict` for `True`, `SkyReelsV2PipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

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

Exemplos:
```py
>>> import torch
>>> from diffusers import (
...     SkyReelsV2DiffusionForcingImageToVideoPipeline,
...     UniPCMultistepScheduler,
...     AutoencoderKLWan,
... )
>>> from diffusers.utils import export_to_video
>>> from PIL import Image

>>> # Load the pipeline
>>> # Available models:
>>> # - Skywork/SkyReels-V2-DF-1.3B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-DF-14B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-DF-14B-720P-Diffusers
>>> vae = AutoencoderKLWan.from_pretrained(
...     "Skywork/SkyReels-V2-DF-14B-720P-Diffusers",
...     subfolder="vae",
...     torch_dtype=torch.float32,
... )
>>> pipe = SkyReelsV2DiffusionForcingImageToVideoPipeline.from_pretrained(
...     "Skywork/SkyReels-V2-DF-14B-720P-Diffusers",
...     vae=vae,
...     torch_dtype=torch.bfloat16,
... )
>>> flow_shift = 5.0  # 8.0 for T2V, 5.0 for I2V
>>> pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=flow_shift)
>>> pipe = pipe.to("cuda")

>>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."
>>> image = Image.open("path/to/image.png")

>>> output = pipe(
...     image=image,
...     prompt=prompt,
...     num_inference_steps=50,
...     height=544,
...     width=960,
...     guidance_scale=5.0,  # 6.0 for T2V, 5.0 for I2V
...     num_frames=97,
...     ar_step=0,  # Controls asynchronous inference (0 for synchronous mode)
...     overlap_history=None,  # Number of frames to overlap for smooth transitions in long videos
...     addnoise_condition=20,  # Improves consistency in long video generation
... ).frames[0]
>>> export_to_video(output, "video.mp4", fps=24, quality=8)
```

#### encode_prompt[[diffusers.SkyReelsV2DiffusionForcingImageToVideoPipeline.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/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing_i2v.py#L224)

**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.

#### generate_timestep_matrix[[diffusers.SkyReelsV2DiffusionForcingImageToVideoPipeline.generate_timestep_matrix]]

```python
generate_timestep_matrix(num_latent_frames: int, step_template: Tensor, base_num_latent_frames: int, ar_step: int = 5, num_pre_ready: int = 0, causal_block_size: int = 1, shrink_interval_with_mask: bool = False)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing_i2v.py#L464)

**Parâmetros:**

num_latent_frames (int) : Número total de quadros latentes a serem gerados

step_template (torch.Tensor) : Agenda de passos de tempo base (por exemplo, [1000, 800, 600, ..., 0])

base_num_latent_frames (int) : Número máximo de quadros que o modelo pode processar em uma única passagem

ar_step (int, opcional) : Tamanho do passo autoregressivo para defasagem temporal. 0 = síncrono, >0 = assíncrono. Padrão é 5.

num_pre_ready (int, opcional) : Número de quadros já desruídos (por exemplo, de um prefixo em uma tarefa video2video). Padrão é 0.

causal_block_size (int, opcional) : Número de quadros processados como um bloco causal. O valor padrão é 1.

shrink_interval_with_mask (bool, opcional) : Se deve otimizar os intervalos de processamento. O padrão é False.

**Retorna:** `tuple containing`

- step_matrix (torch.Tensor): Matriz de timesteps para cada frame em cada iteração. Formato: [num_iterations, num_latent_frames]
- step_index (torch.Tensor): Matriz de índices para consulta de timestep. Formato: [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor): Máscara booleana indicando quais quadros atualizar. Formato: [num_iterations, num_latent_frames]
- valid_interval (list[tuple]): lista de intervalos (início, fim) para cada iteração

**Exceções:** ``ValueError``

- ``ValueError`` -- Se ar_step for muito pequeno para a configuração fornecida

Esta função implementa o algoritmo central de difusão forçada que cria um agendamento coordenado de remoção de ruído entre os quadros temporais. Ele suporta ambos os modos de geração síncrono e assíncrono:

**Modo síncrono** (ar_step=0, causal_block_size=1):
- Todos os quadros são desruídos simultaneamente em cada passo de tempo
- Cada quadro segue a mesma trajetória de remoção de ruído: [1000, 800, 600, ..., 0]
- Mais simples, mas pode ter menos consistência temporal para vídeos longos

**Modo assíncrono** (ar_step>0, causal_block_size>1):
- Os frames são agrupados em blocos causais e processados bloco a bloco
- Cada bloco é desruído em um padrão escalonado, criando uma "onda de desruído"
- Blocos anteriores são mais desruidados, enquanto blocos posteriores ficam para trás em ar_step passos
- Cria dependências temporais mais fortes e uma melhor consistência

## SkyReelsV2DiffusionForcingVideoToVideoPipeline[[diffusers.SkyReelsV2DiffusionForcingVideoToVideoPipeline]]

#### diffusers.SkyReelsV2DiffusionForcingVideoToVideoPipeline[[diffusers.SkyReelsV2DiffusionForcingVideoToVideoPipeline]]

```python
diffusers.SkyReelsV2DiffusionForcingVideoToVideoPipeline(tokenizer: AutoTokenizer, text_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModel, transformer: SkyReelsV2Transformer3DModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing_v2v.py#L189)

**Parâmetros:**

tokenizer (`AutoTokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder (`UMT5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([SkyReelsV2Transformer3DModel](/docs/diffusers/main/pt/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.

Pipeline para geração de Vídeo-para-Vídeo (v2v) usando SkyReels-V2 com difusão forçada.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.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.SkyReelsV2DiffusionForcingVideoToVideoPipeline.__call__]]

```python
__call__(video: list[PIL.Image.Image], prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 544, width: int = 960, num_frames: int = 120, num_inference_steps: int = 50, guidance_scale: float = 6.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, 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: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, overlap_history: int | None = None, addnoise_condition: float = 0, base_num_frames: int = 97, ar_step: int = 0, causal_block_size: int | None = None, fps: int = 24)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing_v2v.py#L684)

**Parâmetros:**

video (`list[Image.Image]`) : O vídeo para orientar a geração do vídeo.

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

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração do vídeo. 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`).

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

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

num_frames (`int`, padrão `120`) : O número de quadros no vídeo gerado.

num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

guidance_scale (`float`, padrão `6.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://arxiv.org/pdf/2205.11487.pdf). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. (**6.0 para T2V**, **5.0 para I2V**)

num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas 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, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `SkyReelsV2PipelineOutput` 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

max_sequence_length (`int`, *opcional*, padrão `512`) : O comprimento máximo da sequência do prompt.

overlap_history (`int`, *opcional*, padrão `None`) : Número de quadros sobrepostos para transições suaves em vídeos longos. Se `None`, o pipeline assume o modo de geração de vídeo curto e nenhum sobreposição é aplicada. Recomenda-se definir 17 ou 37.

addnoise_condition (`float`, *opcional*, padrão `0`) : Isso é usado para ajudar a suavizar a geração de vídeos longos adicionando algum ruído à condição limpa. Ruído muito grande também pode causar inconsistência. 20 é um valor recomendado, e você pode tentar valores maiores, mas é recomendado não exceder 50.

base_num_frames (`int`, *opcional*, padrão `97`) : 97 ou 121 | Número de quadros base (**97 para 540P**, **121 para 720P**)

ar_step (`int`, *opcional*, padrão `0`) : Controla a inferência assíncrona (0 para o modo síncrono) Você pode definir `ar_step=5` para habilitar a inferência assíncrona. Na inferência assíncrona, recomenda-se `causal_block_size=5`, enquanto não se deve definir esse parâmetro para a geração síncrona. A inferência assíncrona levará mais etapas para difundir a sequência inteira, o que significa que será MAIS LENTA do que o modo síncrono. Em nossos experimentos, a inferência assíncrona pode melhorar o desempenho de seguimento de instruções e consistência visual.

causal_block_size (`int`, *opcional*, padrão `None`) : O número de quadros em cada bloco/trecho. Recomendado ao usar inferência assíncrona (quando ar_step > 0)

fps (`int`, *opcional*, padrão `24`) : Taxa de quadros do vídeo gerado

**Retorna:** `~SkyReelsV2PipelineOutput` ou `tuple`

Se `return_dict` for `True`, `SkyReelsV2PipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

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

Exemplos:
```py
>>> import torch
>>> from diffusers import (
...     SkyReelsV2DiffusionForcingVideoToVideoPipeline,
...     UniPCMultistepScheduler,
...     AutoencoderKLWan,
... )
>>> from diffusers.utils import export_to_video

>>> # Load the pipeline
>>> # Available models:
>>> # - Skywork/SkyReels-V2-DF-1.3B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-DF-14B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-DF-14B-720P-Diffusers
>>> vae = AutoencoderKLWan.from_pretrained(
...     "Skywork/SkyReels-V2-DF-14B-720P-Diffusers",
...     subfolder="vae",
...     torch_dtype=torch.float32,
... )
>>> pipe = SkyReelsV2DiffusionForcingVideoToVideoPipeline.from_pretrained(
...     "Skywork/SkyReels-V2-DF-14B-720P-Diffusers",
...     vae=vae,
...     torch_dtype=torch.bfloat16,
... )
>>> flow_shift = 8.0  # 8.0 for T2V, 5.0 for I2V
>>> pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=flow_shift)
>>> pipe = pipe.to("cuda")

>>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."

>>> output = pipe(
...     prompt=prompt,
...     num_inference_steps=50,
...     height=544,
...     width=960,
...     guidance_scale=6.0,  # 6.0 for T2V, 5.0 for I2V
...     num_frames=97,
...     ar_step=0,  # Controls asynchronous inference (0 for synchronous mode)
...     overlap_history=None,  # Number of frames to overlap for smooth transitions in long videos
...     addnoise_condition=20,  # Improves consistency in long video generation
... ).frames[0]
>>> export_to_video(output, "video.mp4", fps=24, quality=8)
```

#### encode_prompt[[diffusers.SkyReelsV2DiffusionForcingVideoToVideoPipeline.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/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing_v2v.py#L280)

**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.

#### generate_timestep_matrix[[diffusers.SkyReelsV2DiffusionForcingVideoToVideoPipeline.generate_timestep_matrix]]

```python
generate_timestep_matrix(num_latent_frames: int, step_template: Tensor, base_num_latent_frames: int, ar_step: int = 5, num_pre_ready: int = 0, causal_block_size: int = 1, shrink_interval_with_mask: bool = False)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_diffusion_forcing_v2v.py#L504)

**Parâmetros:**

num_latent_frames (int) : Número total de quadros latentes a serem gerados

step_template (torch.Tensor) : Agenda de passos de tempo base (por exemplo, [1000, 800, 600, ..., 0])

base_num_latent_frames (int) : Número máximo de quadros que o modelo pode processar em uma única passagem

ar_step (int, opcional) : Tamanho do passo autoregressivo para defasagem temporal. 0 = síncrono, >0 = assíncrono. Padrão é 5.

num_pre_ready (int, opcional) : Número de quadros já desruídos (por exemplo, de um prefixo em uma tarefa video2video). Padrão é 0.

causal_block_size (int, opcional) : Número de quadros processados como um bloco causal. O valor padrão é 1.

shrink_interval_with_mask (bool, opcional) : Se deve otimizar os intervalos de processamento. O padrão é False.

**Retorna:** `tuple containing`

- step_matrix (torch.Tensor): Matriz de timesteps para cada frame em cada iteração. Formato: [num_iterations, num_latent_frames]
- step_index (torch.Tensor): Matriz de índices para consulta de timestep. Formato: [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor): Máscara booleana indicando quais quadros atualizar. Formato: [num_iterations, num_latent_frames]
- valid_interval (list[tuple]): lista de intervalos (início, fim) para cada iteração

**Exceções:** ``ValueError``

- ``ValueError`` -- Se ar_step for muito pequeno para a configuração fornecida

Esta função implementa o algoritmo central de difusão forçada que cria um agendamento coordenado de remoção de ruído entre os quadros temporais. Ele suporta ambos os modos de geração síncrono e assíncrono:

**Modo síncrono** (ar_step=0, causal_block_size=1):
- Todos os quadros são desruídos simultaneamente em cada passo de tempo
- Cada quadro segue a mesma trajetória de remoção de ruído: [1000, 800, 600, ..., 0]
- Mais simples, mas pode ter menos consistência temporal para vídeos longos

**Modo assíncrono** (ar_step>0, causal_block_size>1):
- Os frames são agrupados em blocos causais e processados bloco a bloco
- Cada bloco é desruído em um padrão escalonado, criando uma "onda de desruído"
- Blocos anteriores são mais desruidados, enquanto blocos posteriores ficam para trás em ar_step passos
- Cria dependências temporais mais fortes e uma melhor consistência

## SkyReelsV2Pipeline[[diffusers.SkyReelsV2Pipeline]]

#### diffusers.SkyReelsV2Pipeline[[diffusers.SkyReelsV2Pipeline]]

```python
diffusers.SkyReelsV2Pipeline(tokenizer: AutoTokenizer, text_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModel, transformer: SkyReelsV2Transformer3DModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2.py#L107)

**Parâmetros:**

tokenizer (`T5Tokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([SkyReelsV2Transformer3DModel](/docs/diffusers/main/pt/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar os latentes de entrada.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.

Pipeline para geração de Texto-para-Vídeo (t2v) usando SkyReels-V2.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.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.SkyReelsV2Pipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 544, width: int = 960, num_frames: int = 97, num_inference_steps: int = 50, guidance_scale: float = 6.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, 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: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2.py#L377)

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.

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 está usando orientação (`guidance_scale < 1`).

height (`int`, padrão `544`) : A altura em pixels da imagem gerada.

width (`int`, padrão `960`) : A largura em pixels da imagem gerada.

num_frames (`int`, padrão `97`) : O número de quadros no vídeo gerado.

num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

guidance_scale (`float`, padrão `6.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem.

num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas 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, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`.

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

output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `SkyReelsV2PipelineOutput` 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

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

**Retorna:** `~SkyReelsV2PipelineOutput` ou `tuple`

Se `return_dict` for `True`, `SkyReelsV2PipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

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

Exemplos:
```py
>>> import torch
>>> from diffusers import (
...     SkyReelsV2Pipeline,
...     UniPCMultistepScheduler,
...     AutoencoderKLWan,
... )
>>> from diffusers.utils import export_to_video

>>> # Load the pipeline
>>> # Available models:
>>> # - Skywork/SkyReels-V2-T2V-14B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-T2V-14B-720P-Diffusers
>>> vae = AutoencoderKLWan.from_pretrained(
...     "Skywork/SkyReels-V2-T2V-14B-720P-Diffusers",
...     subfolder="vae",
...     torch_dtype=torch.float32,
... )
>>> pipe = SkyReelsV2Pipeline.from_pretrained(
...     "Skywork/SkyReels-V2-T2V-14B-720P-Diffusers",
...     vae=vae,
...     torch_dtype=torch.bfloat16,
... )
>>> flow_shift = 8.0  # 8.0 for T2V, 5.0 for I2V
>>> pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=flow_shift)
>>> pipe = pipe.to("cuda")

>>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."

>>> output = pipe(
...     prompt=prompt,
...     num_inference_steps=50,
...     height=544,
...     width=960,
...     guidance_scale=6.0,  # 6.0 for T2V, 5.0 for I2V
...     num_frames=97,
... ).frames[0]
>>> export_to_video(output, "video.mp4", fps=24, quality=8)
```

#### encode_prompt[[diffusers.SkyReelsV2Pipeline.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/skyreels_v2/pipeline_skyreels_v2.py#L198)

**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.

## SkyReelsV2ImageToVideoPipeline[[diffusers.SkyReelsV2ImageToVideoPipeline]]

#### diffusers.SkyReelsV2ImageToVideoPipeline[[diffusers.SkyReelsV2ImageToVideoPipeline]]

```python
diffusers.SkyReelsV2ImageToVideoPipeline(tokenizer: AutoTokenizer, text_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModel, image_encoder: CLIPVisionModelWithProjection, image_processor: CLIPProcessor, transformer: SkyReelsV2Transformer3DModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_i2v.py#L127)

**Parâmetros:**

tokenizer (`T5Tokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

image_encoder (`CLIPVisionModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPVisionModelWithProjection), especificamente a variante [clip-vit-huge-patch14](https://github.com/mlfoundations/open_clip/blob/main/docs/PRETRAINED.md#vit-h14-xlm-roberta-large).

transformer ([SkyReelsV2Transformer3DModel](/docs/diffusers/main/pt/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar os latentes de entrada.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.

Pipeline para geração de Imagem-para-Vídeo (i2v) usando SkyReels-V2.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.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.SkyReelsV2ImageToVideoPipeline.__call__]]

```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 544, width: int = 960, num_frames: int = 97, num_inference_steps: int = 50, guidance_scale: float = 5.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, 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, image_embeds: typing.Optional[torch.Tensor] = None, last_image: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/skyreels_v2/pipeline_skyreels_v2_i2v.py#L479)

**Parâmetros:**

image (`PipelineImageInput`) : A imagem de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou um `torch.Tensor`.

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.

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

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

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

num_frames (`int`, padrão `97`) : O número de quadros no vídeo gerado.

num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem.

num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas 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, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `negative_prompt`.

image_embeds (`torch.Tensor`, *opcional*) : Embebimentos de imagem pré-gerados. Pode ser usado para ajustar facilmente as entradas de imagem (ponderação). Se não for fornecido, os embebimentos de imagem são gerados a partir do argumento de entrada `image`.

last_image (`torch.Tensor`, *opcional*) : Última imagem opcional para condicionamento de imagem para vídeo, que ancora o final do vídeo gerado.

output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `WanPipelineOutput` 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

max_sequence_length (`int`, *opcional*, padrão `512`) : O comprimento máximo da sequência do prompt.

**Retorna:** `~SkyReelsV2PipelineOutput` ou `tuple`

Se `return_dict` for `True`, `SkyReelsV2PipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

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

Exemplos:
```py
>>> import torch
>>> from diffusers import (
...     SkyReelsV2ImageToVideoPipeline,
...     UniPCMultistepScheduler,
...     AutoencoderKLWan,
... )
>>> from diffusers.utils import export_to_video
>>> from PIL import Image

>>> # Load the pipeline
>>> # Available models:
>>> # - Skywork/SkyReels-V2-I2V-1.3B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-I2V-14B-540P-Diffusers
>>> # - Skywork/SkyReels-V2-I2V-14B-720P-Diffusers
>>> vae = AutoencoderKLWan.from_pretrained(
...     "Skywork/SkyReels-V2-I2V-14B-720P-Diffusers",
...     subfolder="vae",
...     torch_dtype=torch.float32,
... )
>>> pipe = SkyReelsV2ImageToVideoPipeline.from_pretrained(
...     "Skywork/SkyReels-V2-I2V-14B-720P-Diffusers",
...     vae=vae,
...     torch_dtype=torch.bfloat16,
... )
>>> flow_shift = 5.0  # 8.0 for T2V, 5.0 for I2V
>>> pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=flow_shift)
>>> pipe = pipe.to("cuda")

>>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."
>>> image = Image.open("path/to/image.png")

>>> output = pipe(
...     image=image,
...     prompt=prompt,
...     num_inference_steps=50,
...     height=544,
...     width=960,
...     guidance_scale=5.0,  # 6.0 for T2V, 5.0 for I2V
...     num_frames=97,
... ).frames[0]
>>> export_to_video(output, "video.mp4", fps=24, quality=8)
```

#### encode_prompt[[diffusers.SkyReelsV2ImageToVideoPipeline.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/skyreels_v2/pipeline_skyreels_v2_i2v.py#L241)

**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.

## SkyReelsV2PipelineOutput[[diffusers.pipelines.skyreels_v2.pipeline_output.SkyReelsV2PipelineOutput]]

#### diffusers.pipelines.skyreels_v2.pipeline_output.SkyReelsV2PipelineOutput[[diffusers.pipelines.skyreels_v2.pipeline_output.SkyReelsV2PipelineOutput]]

```python
diffusers.pipelines.skyreels_v2.pipeline_output.SkyReelsV2PipelineOutput(frames: Tensor)
```

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

**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 os pipelines do SkyReelsV2.