#
# Bajo licencia Apache License, versión 2.0 (la "Licencia");
# no puede usar este archivo excepto en cumplimiento de la Licencia.
# Puede obtener una copia de la Licencia en
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que la ley aplicable lo exija o se haya acordado por escrito, el software
# distribuido bajo la Licencia se distribuye en una base "TAL CUAL",
# SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita.
# Consulte la Licencia para el lenguaje específico que rige los permisos y
# limitaciones de la Licencia. -->

  
    
      
    
  

# SkyReels-V2: Modelo generativo de películas de longitud infinita

[SkyReels-V2](https://huggingface.co/papers/2504.13074) del equipo SkyReels de Skywork AI.

*Los avances recientes en la generación de vídeo han sido impulsados por modelos de difusión y marcos autoregresivos, pero persisten desafíos críticos para armonizar la adherencia al prompt, la calidad visual, la dinámica del movimiento y la duración: concesiones en la dinámica del movimiento para mejorar la calidad visual temporal, duración del vídeo limitada (5-10 segundos) para priorizar la resolución y generación consciente de planos inadecuada, derivada de la incapacidad de los MLLM de propósito general para interpretar la gramática cinematográfica, como la composición de planos, las expresiones de los actores y los movimientos de cámara. Estas limitaciones entrelazadas obstaculizan la síntesis realista de larga duración y la generación de estilo cinematográfico profesional. Para abordar estas limitaciones, proponemos SkyReels-V2, un modelo generativo de películas de longitud infinita, que sinergiza el Multi-modal Large Language Model (MLLM), el Multi-stage Pretraining, el Reinforcement Learning y el Diffusion Forcing Framework. En primer lugar, diseñamos una representación estructural integral del vídeo que combina las descripciones generales del Multi-modal LLM y el lenguaje de planos detallado de los modelos sub-experto. Con la ayuda de anotación humana, luego entrenamos un Video Captioner unificado, llamado SkyCaptioner-V1, para etiquetar eficientemente los datos de vídeo. En segundo lugar, establecemos un preentrenamiento de resolución progresiva para la generación fundamental de vídeo, seguido de una mejora de post-entrenamiento en cuatro etapas: el Supervised Fine-Tuning (SFT) inicial equilibrado en conceptos mejora la calidad de la línea base; el entrenamiento de Reinforcement Learning (RL) específico de movimiento con datos de distorsión anotados por humanos y sintéticos aborda los artefactos dinámicos; nuestro marco de difusión con forzamiento y horarios de ruido no decrecientes permite la síntesis de vídeos largos en un espacio de búsqueda eficiente; el SFT final de alta calidad refina la fidelidad visual. Todo el código y los modelos están disponibles en [this https URL](https://github.com/SkyworkAI/SkyReels-V2).*

Puedes encontrar todos los puntos de control originales de SkyReels-V2 bajo la organización [Skywork](https://huggingface.co/collections/Skywork/skyreels-v2-6801b1b93df627d441d0d0d9).

Los siguientes modelos de SkyReels-V2 son compatibles con 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 fue aportado por [M. Tolga Cangöz](https://github.com/tolgacangoz).

> [!TIP]
> Haz clic en los modelos SkyReels-V2 en la barra lateral derecha para ver más ejemplos de generación de video.

### Una demostración _Visual_

El ejemplo siguiente tiene los siguientes parámetros:

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

Con `vae_scale_factor_temporal=4`, se esperan `5` bloques de `5` fotogramas cada uno, según el cálculo:

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

Y la longitud de contexto máxima en el espacio latente se calcula con `base_num_latent_frames`:

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

Línea de tiempo del procesamiento así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 videos largos (`num_frames` > `base_num_frames`): `base_num_frames` actúa como el "tamaño de la ventana deslizante" para el procesamiento de videos largos.

Ejemplo: video de `257` fotogramas con `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 iteración ejecuta de forma independiente el procesamiento asíncrono con sus propios `5` bloques. `base_num_frames` controla:
1. Uso de memoria (ventana más grande = más VRAM)
2. Longitud del contexto del modelo (debe coincidir con las restricciones de entrenamiento)
3. Número de bloques por iteración (`base_num_latent_frames // causal_block_size`)

Cada bloque tarda `30` pasos para completar el desruido. El bloque N comienza en el paso: `1 + (N-1) x ar_step` Pasos totales: `30 + (5-1) x 5 = 50` pasos

El modo síncrono (`ar_step=0`) procesaría todos los bloques/marcos simultáneamente:
```text
┌──────────────────────────────────────────────┐
│ Steps:       1            ...            30  │
│ All blocks: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] │
└──────────────────────────────────────────────┘
```
Pasos totales: `30` pasos

Un ejemplo de cómo se construye la matriz de pasos para el procesamiento asíncrono: dados los 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]
```

El algoritmo crea una `step_matrix` de `50x25` donde:
```
- 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álisis detallado de la fila `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)
```

Patrón clave: el Bloque `i` se retrasa respecto al Bloque `i-1` exactamente `ar_step=5` pasos de tiempo, creando el efecto escalonado de "diffusion forcing" en el que los bloques posteriores se condicionan en bloques anteriores más limpios.

### Generación de texto a video

El siguiente ejemplo demuestra cómo generar un video a partir de texto.

Consulte la guía [Reduce memory usage](../../optimization/memory) para obtener más detalles sobre las diversas técnicas de ahorro de memoria.

Del repositorio original:
>Puede usar --ar_step 5 para habilitar la inferencia asíncrona. En el caso de la inferencia asíncrona, se recomienda --causal_block_size 5, mientras que no se debe establecer para la generación síncrona... La inferencia asíncrona requerirá más pasos para difundir la secuencia completa, lo que significa que será MÁS LENTA que el modo síncrono. En nuestros experimentos, la inferencia asíncrona puede mejorar el rendimiento en el seguimiento de instrucciones y la consistencia 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)
```

### Generación de video a partir de los primeros y últimos fotogramas

El siguiente ejemplo demuestra cómo usar el pipeline de imagen a video para generar un video utilizando una descripción de texto, un fotograma inicial y un fotograma 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)
```

### Generación de video a video

`SkyReelsV2DiffusionForcingVideoToVideoPipeline` extiende un video 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
```

## Notas

- SkyReels-V2 admite LoRAs con [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.SkyReelsV2LoraLoaderMixin.load_lora_weights).

`SkyReelsV2Pipeline` y `SkyReelsV2ImageToVideoPipeline` también están disponibles sin aplicar el framework Diffusion Forcing.

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

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

**Parámetros:**

tokenizer (`AutoTokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente la 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), específicamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([SkyReelsV2Transformer3DModel](/docs/diffusers/main/es/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar los latentes de imagen codificados.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLWan](/docs/diffusers/main/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

Pipeline para la generación de Texto a Video (t2v) usando SkyReels-V2 con diffusion forcing.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

#### __call__[[diffusers.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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

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

height (`int`, por defecto `544`) : La altura del video generado.

width (`int`, por defecto `960`) : El ancho del video generado.

num_frames (`int`, por defecto `97`) : El número de fotogramas en el video generado.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

guidance_scale (`float`, por defecto `6.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. (**6.0 para T2V**, **5.0 para I2V**)

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

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

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

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

output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

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

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

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de la secuencia del prompt.

overlap_history (`int`, *opcional*, valor predeterminado `None`) : Número de fotogramas que se superponen para transiciones suaves en videos largos. Si es `None`, el pipeline asume el modo de generación de video corto y no se aplica superposición. Se recomienda establecerlo en 17 o 37.

addnoise_condition (`float`, *opcional*, valor predeterminado `0`) : Se utiliza para ayudar a suavizar la generación de videos largos añadiendo algo de ruido a la condición limpia. Un ruido demasiado grande también puede causar inconsistencias. 20 es un valor recomendado, y puede probar valores mayores, pero se recomienda no superar 50.

base_num_frames (`int`, *opcional*, valor predeterminado `97`) : 97 o 121 | Número de fotogramas base (**97 para 540P**, **121 para 720P**)

ar_step (`int`, *opcional*, valor predeterminado `0`) : Controla la inferencia asíncrona (0 para el modo síncrono). Puede establecer `ar_step=5` para habilitar la inferencia asíncrona. En el caso de la inferencia asíncrona, se recomienda `causal_block_size=5`, mientras que no se debe establecer para la generación síncrona. La inferencia asíncrona requiere más pasos para difundir la secuencia completa, lo que significa que será MÁS LENTA que el modo síncrono. En nuestros experimentos, la inferencia asíncrona puede mejorar el rendimiento en el seguimiento de instrucciones y la consistencia visual.

causal_block_size (`int`, *opcional*, valor predeterminado `None`) : El número de fotogramas en cada bloque/trozo. Se recomienda cuando se usa inferencia asíncrona (cuando ar_step > 0)

fps (`int`, *opcional*, valor predeterminado `24`) : Tasa de fotogramas del video generado

**Devuelve:** `~SkyReelsV2PipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `SkyReelsV2PipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

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

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

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

**Parámetros:**

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

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

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

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

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

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

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

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

Codifica el prompt en estados ocultos del codificador de texto.

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

[Fuente](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 fotogramas latentes a generar

step_template (torch.Tensor) : Programa de pasos de tiempo base (p. ej., [1000, 800, 600, ..., 0])

base_num_latent_frames (int) : Número máximo de fotogramas que el modelo puede procesar en una sola pasada hacia adelante

ar_step (int, opcional) : Tamaño del paso autoregresivo para el desfase temporal. 0 = síncrono, >0 = asíncrono. El valor predeterminado es 5.

num_pre_ready (int, opcional) : Número de fotogramas ya desruidados (p. ej., del prefijo en una tarea video2video). El valor predeterminado es 0.

causal_block_size (int, opcional) : Número de fotogramas procesados como un bloque causal. El valor predeterminado es 1.

shrink_interval_with_mask (bool, opcional) : Si se deben optimizar los intervalos de procesamiento. El valor predeterminado es False.

**Devuelve:** `tuple containing`

- step_matrix (torch.Tensor): Matriz de pasos de tiempo para cada fotograma en cada iteración. Forma: [num_iterations, num_latent_frames]
- step_index (torch.Tensor): Matriz de índices para la búsqueda de pasos de tiempo. Forma: [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor): Máscara booleana que indica qué fotogramas actualizar. Forma: [num_iterations, num_latent_frames]
- valid_interval (list[tuple]): lista de intervalos (inicio, fin) para cada iteración

**Excepciones:** ``ValueError``

- ``ValueError`` -- Si ar_step es demasiado pequeño para la configuración dada

Esta función implementa el algoritmo central de difusión forzada que crea un programa de desruido coordinado entre los fotogramas temporales. Admite tanto los modos de generación síncrona como asíncrona:

**Modo síncrono** (ar_step=0, causal_block_size=1):
- Todos los fotogramas se desruidan simultáneamente en cada paso de tiempo
- Cada cuadro sigue la misma trayectoria de desruido: [1000, 800, 600, ..., 0]
- Más simple, pero puede tener menos consistencia temporal en videos largos

**Modo asíncrono** (ar_step>0, causal_block_size>1):
- Los fotogramas se agrupan en bloques causales y se procesan por bloque/trozo
- Cada bloque se desruidifica en un patrón escalonado, creando una "ola de desruidificación".
- Los bloques anteriores están más desruidados, mientras que los posteriores se retrasan por ar_step pasos de tiempo
- Crea dependencias temporales más fuertes y una mejor consistencia

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

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

**Parámetros:**

tokenizer (`AutoTokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente la 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), específicamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([SkyReelsV2Transformer3DModel](/docs/diffusers/main/es/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar los latentes de imagen codificados.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLWan](/docs/diffusers/main/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

Pipeline para la generación de imagen a video (i2v) usando SkyReels-V2 con diffusion forcing.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

#### __call__[[diffusers.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)
```

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

**Parámetros:**

image (`PipelineImageInput`) : La imagen de entrada para condicionar la generación. Debe ser una imagen, una lista de imágenes o un `torch.Tensor`.

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

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

height (`int`, por defecto `544`) : La altura del video generado.

width (`int`, por defecto `960`) : El ancho del video generado.

num_frames (`int`, por defecto `97`) : El número de fotogramas en el video generado.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

guidance_scale (`float`, por defecto `5.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. (**6.0 para T2V**, **5.0 para I2V**)

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

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

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

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

image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen pregeneradas. Se pueden usar para ajustar fácilmente las entradas de imagen (ponderación). Si no se proporcionan, las incrustaciones de imagen se generan a partir del argumento de entrada `image`.

last_image (`torch.Tensor`, *opcional*) : Incrustaciones de imagen pregeneradas. Se pueden usar para ajustar fácilmente las entradas de imagen (ponderación). Si no se proporcionan, las incrustaciones de imagen se generan a partir del argumento de entrada `image`.

output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

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

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

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de la secuencia del prompt.

overlap_history (`int`, *opcional*, valor predeterminado `None`) : Número de fotogramas que se superponen para transiciones suaves en videos largos. Si es `None`, el pipeline asume el modo de generación de video corto y no se aplica superposición. Se recomienda establecerlo en 17 o 37.

addnoise_condition (`float`, *opcional*, valor predeterminado `0`) : Se utiliza para ayudar a suavizar la generación de videos largos añadiendo algo de ruido a la condición limpia. Un ruido demasiado grande también puede causar inconsistencias. 20 es un valor recomendado, y puede probar valores mayores, pero se recomienda no superar 50.

base_num_frames (`int`, *opcional*, valor predeterminado `97`) : 97 o 121 | Número de fotogramas base (**97 para 540P**, **121 para 720P**)

ar_step (`int`, *opcional*, valor predeterminado `0`) : Controla la inferencia asíncrona (0 para el modo síncrono). Puede establecer `ar_step=5` para habilitar la inferencia asíncrona. En el caso de la inferencia asíncrona, se recomienda `causal_block_size=5`, mientras que no se debe establecer para la generación síncrona. La inferencia asíncrona requiere más pasos para difundir la secuencia completa, lo que significa que será MÁS LENTA que el modo síncrono. En nuestros experimentos, la inferencia asíncrona puede mejorar el rendimiento en el seguimiento de instrucciones y la consistencia visual.

causal_block_size (`int`, *opcional*, valor predeterminado `None`) : El número de fotogramas en cada bloque/trozo. Se recomienda cuando se usa inferencia asíncrona (cuando ar_step > 0)

fps (`int`, *opcional*, valor predeterminado `24`) : Tasa de fotogramas del video generado

**Devuelve:** `~SkyReelsV2PipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `SkyReelsV2PipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

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

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

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

**Parámetros:**

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

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

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

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

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

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

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

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

Codifica el prompt en estados ocultos del codificador de texto.

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

[Fuente](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 fotogramas latentes a generar

step_template (torch.Tensor) : Programa de pasos de tiempo base (p. ej., [1000, 800, 600, ..., 0])

base_num_latent_frames (int) : Número máximo de fotogramas que el modelo puede procesar en una sola pasada hacia adelante

ar_step (int, opcional) : Tamaño del paso autoregresivo para el desfase temporal. 0 = síncrono, >0 = asíncrono. El valor predeterminado es 5.

num_pre_ready (int, opcional) : Número de fotogramas ya desruidados (p. ej., del prefijo en una tarea video2video). El valor predeterminado es 0.

causal_block_size (int, opcional) : Número de fotogramas procesados como un bloque causal. El valor predeterminado es 1.

shrink_interval_with_mask (bool, opcional) : Si se deben optimizar los intervalos de procesamiento. El valor predeterminado es False.

**Devuelve:** `tuple containing`

- step_matrix (torch.Tensor): Matriz de pasos de tiempo para cada fotograma en cada iteración. Forma: [num_iterations, num_latent_frames]
- step_index (torch.Tensor): Matriz de índices para la búsqueda de pasos de tiempo. Forma: [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor): Máscara booleana que indica qué fotogramas actualizar. Forma: [num_iterations, num_latent_frames]
- valid_interval (list[tuple]): lista de intervalos (inicio, fin) para cada iteración

**Excepciones:** ``ValueError``

- ``ValueError`` -- Si ar_step es demasiado pequeño para la configuración dada

Esta función implementa el algoritmo central de difusión forzada que crea un programa de desruido coordinado entre los fotogramas temporales. Admite tanto los modos de generación síncrona como asíncrona:

**Modo síncrono** (ar_step=0, causal_block_size=1):
- Todos los fotogramas se desruidan simultáneamente en cada paso de tiempo
- Cada cuadro sigue la misma trayectoria de desruido: [1000, 800, 600, ..., 0]
- Más simple, pero puede tener menos consistencia temporal en videos largos

**Modo asíncrono** (ar_step>0, causal_block_size>1):
- Los fotogramas se agrupan en bloques causales y se procesan por bloque/trozo
- Cada bloque se desruidifica en un patrón escalonado, creando una "ola de desruidificación".
- Los bloques anteriores están más desruidados, mientras que los posteriores se retrasan por ar_step pasos de tiempo
- Crea dependencias temporales más fuertes y una mejor consistencia

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

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

**Parámetros:**

tokenizer (`AutoTokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente la 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), específicamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([SkyReelsV2Transformer3DModel](/docs/diffusers/main/es/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar los latentes de imagen codificados.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLWan](/docs/diffusers/main/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

Pipeline para la generación de Video-a-Video (v2v) usando SkyReels-V2 con diffusion forcing.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

#### __call__[[diffusers.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)
```

[Fuente](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]`) : El video para guiar la generación del video.

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

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

height (`int`, por defecto `544`) : La altura del video generado.

width (`int`, por defecto `960`) : El ancho del video generado.

num_frames (`int`, por defecto `120`) : El número de fotogramas en el video generado.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

guidance_scale (`float`, por defecto `6.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://arxiv.org/pdf/2205.11487.pdf). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. (**6.0 para T2V**, **5.0 para I2V**)

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

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

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

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

output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

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

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

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de la secuencia del prompt.

overlap_history (`int`, *opcional*, valor predeterminado `None`) : Número de fotogramas que se superponen para transiciones suaves en videos largos. Si es `None`, el pipeline asume el modo de generación de video corto y no se aplica superposición. Se recomienda establecerlo en 17 o 37.

addnoise_condition (`float`, *opcional*, valor predeterminado `0`) : Se utiliza para ayudar a suavizar la generación de videos largos añadiendo algo de ruido a la condición limpia. Un ruido demasiado grande también puede causar inconsistencias. 20 es un valor recomendado, y puede probar valores mayores, pero se recomienda no superar 50.

base_num_frames (`int`, *opcional*, valor predeterminado `97`) : 97 o 121 | Número de fotogramas base (**97 para 540P**, **121 para 720P**)

ar_step (`int`, *opcional*, valor predeterminado `0`) : Controla la inferencia asíncrona (0 para el modo síncrono). Puede establecer `ar_step=5` para habilitar la inferencia asíncrona. En el caso de la inferencia asíncrona, se recomienda `causal_block_size=5`, mientras que no se debe establecer para la generación síncrona. La inferencia asíncrona requiere más pasos para difundir la secuencia completa, lo que significa que será MÁS LENTA que el modo síncrono. En nuestros experimentos, la inferencia asíncrona puede mejorar el rendimiento en el seguimiento de instrucciones y la consistencia visual.

causal_block_size (`int`, *opcional*, valor predeterminado `None`) : El número de fotogramas en cada bloque/trozo. Se recomienda cuando se usa inferencia asíncrona (cuando ar_step > 0)

fps (`int`, *opcional*, valor predeterminado `24`) : Tasa de fotogramas del video generado

**Devuelve:** `~SkyReelsV2PipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `SkyReelsV2PipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

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

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

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

**Parámetros:**

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

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

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

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

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

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

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

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

Codifica el prompt en estados ocultos del codificador de texto.

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

[Fuente](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 fotogramas latentes a generar

step_template (torch.Tensor) : Programa de pasos de tiempo base (p. ej., [1000, 800, 600, ..., 0])

base_num_latent_frames (int) : Número máximo de fotogramas que el modelo puede procesar en una sola pasada hacia adelante

ar_step (int, opcional) : Tamaño del paso autoregresivo para el desfase temporal. 0 = síncrono, >0 = asíncrono. El valor predeterminado es 5.

num_pre_ready (int, opcional) : Número de fotogramas ya desruidados (p. ej., del prefijo en una tarea video2video). El valor predeterminado es 0.

causal_block_size (int, opcional) : Número de fotogramas procesados como un bloque causal. El valor predeterminado es 1.

shrink_interval_with_mask (bool, opcional) : Si se deben optimizar los intervalos de procesamiento. El valor predeterminado es False.

**Devuelve:** `tuple containing`

- step_matrix (torch.Tensor): Matriz de pasos de tiempo para cada fotograma en cada iteración. Forma: [num_iterations, num_latent_frames]
- step_index (torch.Tensor): Matriz de índices para la búsqueda de pasos de tiempo. Forma: [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor): Máscara booleana que indica qué fotogramas actualizar. Forma: [num_iterations, num_latent_frames]
- valid_interval (list[tuple]): lista de intervalos (inicio, fin) para cada iteración

**Excepciones:** ``ValueError``

- ``ValueError`` -- Si ar_step es demasiado pequeño para la configuración dada

Esta función implementa el algoritmo central de difusión forzada que crea un programa de desruido coordinado entre los fotogramas temporales. Admite tanto los modos de generación síncrona como asíncrona:

**Modo síncrono** (ar_step=0, causal_block_size=1):
- Todos los fotogramas se desruidan simultáneamente en cada paso de tiempo
- Cada cuadro sigue la misma trayectoria de desruido: [1000, 800, 600, ..., 0]
- Más simple, pero puede tener menos consistencia temporal en videos largos

**Modo asíncrono** (ar_step>0, causal_block_size>1):
- Los fotogramas se agrupan en bloques causales y se procesan por bloque/trozo
- Cada bloque se desruidifica en un patrón escalonado, creando una "ola de desruidificación".
- Los bloques anteriores están más desruidados, mientras que los posteriores se retrasan por ar_step pasos de tiempo
- Crea dependencias temporales más fuertes y una mejor consistencia

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

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

**Parámetros:**

tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente la 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), concretamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

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

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLWan](/docs/diffusers/main/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

Pipeline para la generación de Texto a Video (t2v) usando SkyReels-V2.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

#### __call__[[diffusers.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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

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

height (`int`, por defecto `544`) : La altura en píxeles de la imagen generada.

width (`int`, por defecto `960`) : El ancho en píxeles de la imagen generada.

num_frames (`int`, por defecto `97`) : El número de fotogramas en el video generado.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

guidance_scale (`float`, por defecto `6.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

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

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

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan a partir del argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

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

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

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de la secuencia para el codificador de texto.

**Devuelve:** `~SkyReelsV2PipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `SkyReelsV2PipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

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

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

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

**Parámetros:**

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

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

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

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

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

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

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

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

Codifica el prompt en estados ocultos del codificador de texto.

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

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

**Parámetros:**

tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente la 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), concretamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

image_encoder (`CLIPVisionModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPVisionModelWithProjection), específicamente la 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/es/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel)) : Transformer condicional para desruidar los latentes de entrada.

scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLWan](/docs/diffusers/main/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

Pipeline para la generación de imagen a video (i2v) usando SkyReels-V2.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

#### __call__[[diffusers.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)
```

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

**Parámetros:**

image (`PipelineImageInput`) : La imagen de entrada para condicionar la generación. Debe ser una imagen, una lista de imágenes o un `torch.Tensor`.

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

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

height (`int`, por defecto `544`) : La altura del video generado.

width (`int`, por defecto `960`) : El ancho del video generado.

num_frames (`int`, por defecto `97`) : El número de fotogramas en el video generado.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

guidance_scale (`float`, por defecto `5.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

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

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

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

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

image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen pregeneradas. Se pueden usar para ajustar fácilmente las entradas de imagen (ponderación). Si no se proporcionan, las incrustaciones de imagen se generan a partir del argumento de entrada `image`.

last_image (`torch.Tensor`, *opcional*) : Última imagen opcional para la condición de imagen a video que ancla el final del video generado.

output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un `WanPipelineOutput` en lugar de una tupla simple.

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

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de la secuencia del prompt.

**Devuelve:** `~SkyReelsV2PipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `SkyReelsV2PipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

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

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

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

**Parámetros:**

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

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

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

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

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

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

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

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

Codifica el prompt en estados ocultos del codificador de texto.

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

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

**Parámetros:**

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

Clase de salida para las pipelines de SkyReelsV2.