Diffusers documentation
SkyReels-V2: Modelo generativo de filmes de comprimento infinito
SkyReels-V2: Modelo generativo de filmes de comprimento infinito
SkyReels-V2 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 pretraining 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.
Você pode encontrar todos os checkpoints originais do SkyReels-V2 na organização Skywork.
Os seguintes modelos SkyReels-V2 são suportados no Diffusers:
- SkyReels-V2 DF 1.3B - 540P
- SkyReels-V2 DF 14B - 540P
- SkyReels-V2 DF 14B - 720P
- SkyReels-V2 T2V 14B - 540P
- SkyReels-V2 T2V 14B - 720P
- SkyReels-V2 I2V 1.3B - 540P
- SkyReels-V2 I2V 14B - 540P
- SkyReels-V2 I2V 14B - 720P
Este modelo foi contribuído por M. Tolga Cangöz.
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=97num_frames=97num_inference_steps=30ar_step=5causal_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:
┌─────────────────────────────────────────────────────────────────┐ │ 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
┌──── 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:
- Uso de memória (janela maior = mais VRAM)
- Comprimento do contexto do modelo (deve corresponder às restrições de treinamento)
- 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:
┌──────────────────────────────────────────────┐ │ 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 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 esse parâmetro não deve ser definido para a geração síncrona… 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 seguir instruções e a consistência visual.
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.
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.
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 + 257Observações
- O SkyReels-V2 suporta LoRAs com load_lora_weights().
SkyReelsV2Pipeline e SkyReelsV2ImageToVideoPipeline também estão disponíveis sem o framework Diffusion Forcing aplicado.
SkyReelsV2DiffusionForcingPipeline
classe diffusers.SkyReelsV2DiffusionForcingPipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModeltransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Parâmetros
- tokenizer (
AutoTokenizer) — Tokenizer do T5, especificamente a variante google/umt5-xxl. - text_encoder (
UMT5EncoderModel) — T5, especificamente a variante google/umt5-xxl. - transformer (SkyReelsV2Transformer3DModel) — Transformer condicional para desruidar os latentes da imagem codificada.
- scheduler (UniPCMultistepScheduler) —
Um scheduler a ser usado em combinação com
transformerpara desruidar os latentes da imagem codificada. - vae (AutoencoderKLWan) — Modelo de Autoencoder Variacional (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. 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__
< source >( prompt: str | list[str]negative_prompt: str | list[str] = Noneheight: int = 544width: int = 960num_frames: int = 97num_inference_steps: int = 50guidance_scale: float = 6.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'np'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 512overlap_history: int | None = Noneaddnoise_condition: float = 0base_num_frames: int = 97ar_step: int = 0causal_block_size: int | None = Nonefps: int = 24 ) → ~SkyReelsV2PipelineOutput or tuple
Parâmetros
- prompt (
stroulist[str], opcional) — O prompt ou os prompts para orientar a geração da imagem. Se não for definido, é necessário passarprompt_embedsem vez disso. - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - height (
int, padrão544) — A altura do vídeo gerado. - width (
int, padrão960) — A largura do vídeo gerado. - num_frames (
int, padrão97) — O número de quadros no vídeo gerado. - num_inference_steps (
int, padrão50) — O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. - guidance_scale (
float, padrão6.0) — Escala de orientação definida em Classifier-Free Diffusion Guidance.guidance_scaleé definido comowda equação 2 do Imagen Paper. A escala de orientação é ativada ao definirguidance_scale > 1. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas aopromptde 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.Generatoroulist[torch.Generator], opcional) — Umtorch.Generatorpara 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 ogeneratoraleató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 entradaprompt. - 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 entradanegative_prompt. - output_type (
str, opcional, padrão"np") — O formato de saída da imagem gerada. Escolha entrePIL.Imageounp.array. - return_dict (
bool, opcional, padrãoTrue) — Se deve ou não retornar umSkyReelsV2PipelineOutputem vez de uma tupla simples. - attention_kwargs (
dict, opcional) — Um dicionário de kwargs que, se especificado, é passado aoAttentionProcessorconforme definido emself.processorem diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, opcional) — Uma função ou uma subclasse dePipelineCallbackouMultiPipelineCallbacksque é 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_kwargsincluirá uma lista de todos os tensores, conforme especificado porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — A lista de entradas de tensor para a funçãocallback_on_step_end. Os tensores especificados na lista serão passados como argumentocallback_kwargs. Você só poderá incluir variáveis listadas no atributo._callback_tensor_inputsda sua classe de pipeline. - max_sequence_length (
int, opcional, padrão512) — O comprimento máximo da sequência do prompt. - overlap_history (
int, opcional, padrãoNone) — Número de quadros sobrepostos para transições suaves em vídeos longos. SeNone, 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ão0) — 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ão97) — 97 ou 121 | Contagem base de quadros (97 para 540P, 121 para 720P) - ar_step (
int, opcional, padrão0) — Controla a inferência assíncrona (0 para o modo síncrono). Você pode definirar_step=5para habilitar a inferência assíncrona. Na inferência assíncrona, recomenda-secausal_block_size=5, enquanto não se deve definir esse parâmetro para a geração síncrona. 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 consistência visual. - causal_block_size (
int, opcional, padrãoNone) — O número de quadros em cada bloco/trecho. Recomendado ao usar inferência assíncrona (quando ar_step > 0) - fps (
int, opcional, padrão24) — 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 bools
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:
>>> 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
< source >( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 226device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )
Parâmetros
- prompt (
stroulist[str], opcional) — prompt a ser codificado - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - do_classifier_free_guidance (
bool, opcional, padrãoTrue) — 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) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto negativas pré-geradas. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entradanegative_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
< source >( num_latent_frames: intstep_template: Tensorbase_num_latent_frames: intar_step: int = 5num_pre_ready: int = 0causal_block_size: int = 1shrink_interval_with_mask: bool = False ) → tuple containing
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á desruidados (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. Padrão é 1.
- shrink_interval_with_mask (bool, opcional) — Se otimizar os intervalos de processamento. Padrão é False.
Retorna
tupla contendo
- step_matrix (torch.Tensor): Matriz de timesteps para cada quadro 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
classe diffusers.SkyReelsV2DiffusionForcingImageToVideoPipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModeltransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Parâmetros
- tokenizer (
AutoTokenizer) — Tokenizer do T5, especificamente a variante google/umt5-xxl. - text_encoder (
UMT5EncoderModel) — T5, especificamente a variante google/umt5-xxl. - transformer (SkyReelsV2Transformer3DModel) — Transformer condicional para desruidar os latentes da imagem codificada.
- scheduler (UniPCMultistepScheduler) —
Um scheduler a ser usado em combinação com
transformerpara desruidar os latentes da imagem codificada. - vae (AutoencoderKLWan) — Modelo de Autoencoder Variacional (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. 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__
< source >( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]prompt: str | list[str] = Nonenegative_prompt: str | list[str] = Noneheight: int = 544width: int = 960num_frames: int = 97num_inference_steps: int = 50guidance_scale: float = 5.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneimage_embeds: typing.Optional[torch.Tensor] = Nonelast_image: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'np'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 512overlap_history: int | None = Noneaddnoise_condition: float = 0base_num_frames: int = 97ar_step: int = 0causal_block_size: int | None = Nonefps: int = 24 ) → ~SkyReelsV2PipelineOutput or tuple
Parâmetros
- image (
PipelineImageInput) — A imagem de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou umtorch.Tensor. - prompt (
stroulist[str], opcional) — O prompt ou os prompts para orientar a geração da imagem. Se não for definido, é necessário passarprompt_embedsem vez disso. - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - height (
int, padrão544) — A altura do vídeo gerado. - width (
int, padrão960) — A largura do vídeo gerado. - num_frames (
int, padrão97) — O número de quadros no vídeo gerado. - num_inference_steps (
int, padrão50) — O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. - guidance_scale (
float, padrão5.0) — Escala de orientação definida em Classifier-Free Diffusion Guidance.guidance_scaleé definido comowda equação 2 do Imagen Paper. A escala de orientação é ativada ao definirguidance_scale > 1. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas aopromptde 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.Generatoroulist[torch.Generator], opcional) — Umtorch.Generatorpara 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 ogeneratoraleató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 entradaprompt. - 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 entradanegative_prompt. - image_embeds (
torch.Tensor, opcional) — Incorporações de imagem pré-geradas. Podem ser usadas para ajustar facilmente as entradas de imagem (ponderação). Se não forem fornecidas, as incorporações de imagem são geradas a partir do argumento de entradaimage. - last_image (
torch.Tensor, opcional) — Embutidos de imagem pré-gerados. Pode ser usado para ajustar facilmente as entradas de imagem (ponderação). Se não for fornecido, os embutidos de imagem são gerados a partir do argumento de entradaimage. - output_type (
str, opcional, padrão"np") — O formato de saída da imagem gerada. Escolha entrePIL.Imageounp.array. - return_dict (
bool, opcional, padrãoTrue) — Se deve ou não retornar umSkyReelsV2PipelineOutputem vez de uma tupla simples. - attention_kwargs (
dict, opcional) — Um dicionário de kwargs que, se especificado, é passado aoAttentionProcessorconforme definido emself.processorem diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, opcional) — Uma função ou uma subclasse dePipelineCallbackouMultiPipelineCallbacksque é 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_kwargsincluirá uma lista de todos os tensores, conforme especificado porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — A lista de entradas de tensor para a funçãocallback_on_step_end. Os tensores especificados na lista serão passados como argumentocallback_kwargs. Você só poderá incluir variáveis listadas no atributo._callback_tensor_inputsda sua classe de pipeline. - max_sequence_length (
int, opcional, padrão512) — O comprimento máximo da sequência do prompt. - overlap_history (
int, opcional, padrãoNone) — Número de quadros sobrepostos para transições suaves em vídeos longos. SeNone, 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ão0) — 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ão97) — 97 ou 121 | Contagem base de quadros (97 para 540P, 121 para 720P) - ar_step (
int, opcional, padrão0) — Controla a inferência assíncrona (0 para o modo síncrono). Você pode definirar_step=5para habilitar a inferência assíncrona. Na inferência assíncrona, recomenda-secausal_block_size=5, enquanto não se deve definir esse parâmetro para a geração síncrona. 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 consistência visual. - causal_block_size (
int, opcional, padrãoNone) — O número de quadros em cada bloco/trecho. Recomendado ao usar inferência assíncrona (quando ar_step > 0) - fps (
int, opcional, padrão24) — 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 bools
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:
>>> 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
< source >( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 226device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )
Parâmetros
- prompt (
stroulist[str], opcional) — prompt a ser codificado - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - do_classifier_free_guidance (
bool, opcional, padrãoTrue) — 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) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto negativas pré-geradas. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entradanegative_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
< source >( num_latent_frames: intstep_template: Tensorbase_num_latent_frames: intar_step: int = 5num_pre_ready: int = 0causal_block_size: int = 1shrink_interval_with_mask: bool = False ) → tuple containing
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á desruidados (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. Padrão é 1.
- shrink_interval_with_mask (bool, opcional) — Se otimizar os intervalos de processamento. Padrão é False.
Retorna
tupla contendo
- step_matrix (torch.Tensor): Matriz de timesteps para cada quadro 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
classe diffusers.SkyReelsV2DiffusionForcingVideoToVideoPipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModeltransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Parâmetros
- tokenizer (
AutoTokenizer) — Tokenizer do T5, especificamente a variante google/umt5-xxl. - text_encoder (
UMT5EncoderModel) — T5, especificamente a variante google/umt5-xxl. - transformer (SkyReelsV2Transformer3DModel) — Transformer condicional para desruidar os latentes da imagem codificada.
- scheduler (UniPCMultistepScheduler) —
Um scheduler a ser usado em combinação com
transformerpara desruidar os latentes da imagem codificada. - vae (AutoencoderKLWan) — Modelo de Autoencoder Variacional (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. 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__
< source >( video: listprompt: str | list[str] = Nonenegative_prompt: str | list[str] = Noneheight: int = 544width: int = 960num_frames: int = 120num_inference_steps: int = 50guidance_scale: float = 6.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'np'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 512overlap_history: int | None = Noneaddnoise_condition: float = 0base_num_frames: int = 97ar_step: int = 0causal_block_size: int | None = Nonefps: int = 24 ) → ~SkyReelsV2PipelineOutput or tuple
Parâmetros
- video (
list[Image.Image]) — O vídeo para orientar a geração do vídeo. - prompt (
stroulist[str], opcional) — O prompt ou os prompts para orientar a geração do vídeo. Se não definido, é necessário passarprompt_embedsem vez disso. - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração do vídeo. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - height (
int, padrão544) — A altura do vídeo gerado. - width (
int, padrão960) — A largura do vídeo gerado. - num_frames (
int, padrão120) — O número de quadros no vídeo gerado. - num_inference_steps (
int, padrão50) — O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. - guidance_scale (
float, padrão6.0) — Escala de orientação definida em Classifier-Free Diffusion Guidance.guidance_scaleé definido comowda equação 2. de Imagen Paper. A escala de orientação é ativada ao definirguidance_scale > 1. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas aopromptde texto, geralmente às custas 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.Generatoroulist[torch.Generator], opcional) — Umtorch.Generatorpara 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 ogeneratoraleató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 entradaprompt. - 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 entradanegative_prompt. - output_type (
str, opcional, padrão"np") — O formato de saída da imagem gerada. Escolha entrePIL.Imageounp.array. - return_dict (
bool, opcional, padrãoTrue) — Se deve ou não retornar umSkyReelsV2PipelineOutputem vez de uma tupla simples. - attention_kwargs (
dict, opcional) — Um dicionário de kwargs que, se especificado, é passado aoAttentionProcessorconforme definido emself.processorem diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, opcional) — Uma função ou uma subclasse dePipelineCallbackouMultiPipelineCallbacksque é 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_kwargsincluirá uma lista de todos os tensores, conforme especificado porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — A lista de entradas de tensor para a funçãocallback_on_step_end. Os tensores especificados na lista serão passados como argumentocallback_kwargs. Você só poderá incluir variáveis listadas no atributo._callback_tensor_inputsda sua classe de pipeline. - max_sequence_length (
int, opcional, padrão512) — O comprimento máximo da sequência do prompt. - overlap_history (
int, opcional, padrãoNone) — Número de quadros sobrepostos para transições suaves em vídeos longos. SeNone, 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ão0) — 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ão97) — 97 ou 121 | Contagem base de quadros (97 para 540P, 121 para 720P) - ar_step (
int, opcional, padrão0) — Controla a inferência assíncrona (0 para o modo síncrono). Você pode definirar_step=5para habilitar a inferência assíncrona. Na inferência assíncrona, recomenda-secausal_block_size=5, enquanto não se deve definir esse parâmetro para a geração síncrona. 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 consistência visual. - causal_block_size (
int, opcional, padrãoNone) — O número de quadros em cada bloco/trecho. Recomendado ao usar inferência assíncrona (quando ar_step > 0) - fps (
int, opcional, padrão24) — 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 bools
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:
>>> 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
< source >( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 226device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )
Parâmetros
- prompt (
stroulist[str], opcional) — prompt a ser codificado - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - do_classifier_free_guidance (
bool, opcional, padrãoTrue) — 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) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto negativas pré-geradas. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entradanegative_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
< source >( num_latent_frames: intstep_template: Tensorbase_num_latent_frames: intar_step: int = 5num_pre_ready: int = 0causal_block_size: int = 1shrink_interval_with_mask: bool = False ) → tuple containing
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á desruidados (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. Padrão é 1.
- shrink_interval_with_mask (bool, opcional) — Se otimizar os intervalos de processamento. Padrão é False.
Retorna
tupla contendo
- step_matrix (torch.Tensor): Matriz de timesteps para cada quadro 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
classe diffusers.SkyReelsV2Pipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModeltransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Parâmetros
- tokenizer (
T5Tokenizer) — Tokenizer do T5, especificamente a variante google/umt5-xxl. - text_encoder (
T5EncoderModel) — T5, especificamente a variante google/umt5-xxl. - transformer (SkyReelsV2Transformer3DModel) — Transformer condicional para desruidar os latentes de entrada.
- scheduler (UniPCMultistepScheduler) —
Um scheduler a ser usado em combinação com
transformerpara desruidar os latentes da imagem codificada. - vae (AutoencoderKLWan) — Modelo de Autoencoder Variacional (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. 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__
< source >( prompt: str | list[str] = Nonenegative_prompt: str | list[str] = Noneheight: int = 544width: int = 960num_frames: int = 97num_inference_steps: int = 50guidance_scale: float = 6.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'np'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 512 ) → ~SkyReelsV2PipelineOutput or tuple
Parâmetros
- prompt (
stroulist[str], opcional) — O prompt ou os prompts para orientar a geração da imagem. Se não for definido, é necessário passarprompt_embedsem vez disso. - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não está usando orientação (guidance_scale < 1). - height (
int, padrão544) — A altura da imagem gerada, em pixels. - width (
int, padrão960) — A largura em pixels da imagem gerada. - num_frames (
int, padrão97) — O número de quadros no vídeo gerado. - num_inference_steps (
int, padrão50) — O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. - guidance_scale (
float, padrão6.0) — Escala de orientação definida em Classifier-Free Diffusion Guidance.guidance_scaleé definido comowda equação 2 do Imagen Paper. A escala de orientação é ativada ao definirguidance_scale > 1. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas aopromptde 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.Generatoroulist[torch.Generator], opcional) — Umtorch.Generatorpara 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 ogeneratoraleató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 entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Embeddings de texto negativos pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto (ponderação do prompt). Se não for fornecido, osnegative_prompt_embedssão gerados a partir do argumento de entradanegative_prompt. - output_type (
str, opcional, padrão"np") — O formato de saída da imagem gerada. Escolha entrePIL.Imageounp.array. - return_dict (
bool, opcional, padrãoTrue) — Se deve ou não retornar umSkyReelsV2PipelineOutputem vez de uma tupla simples. - attention_kwargs (
dict, opcional) — Um dicionário de kwargs que, se especificado, é passado aoAttentionProcessorconforme definido emself.processorem diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, opcional) — Uma função ou uma subclasse dePipelineCallbackouMultiPipelineCallbacksque é 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_kwargsincluirá uma lista de todos os tensores, conforme especificado porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — A lista de entradas de tensor para a funçãocallback_on_step_end. Os tensores especificados na lista serão passados como argumentocallback_kwargs. Você só poderá incluir variáveis listadas no atributo._callback_tensor_inputsda sua classe de pipeline. - max_sequence_length (
int, opcional, padrão512) — 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 bools
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:
>>> 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
< source >( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 226device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )
Parâmetros
- prompt (
stroulist[str], opcional) — prompt a ser codificado - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - do_classifier_free_guidance (
bool, opcional, padrãoTrue) — 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) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto negativas pré-geradas. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entradanegative_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
classe diffusers.SkyReelsV2ImageToVideoPipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModelimage_encoder: CLIPVisionModelWithProjectionimage_processor: CLIPProcessortransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Parâmetros
- tokenizer (
T5Tokenizer) — Tokenizer do T5, especificamente a variante google/umt5-xxl. - text_encoder (
T5EncoderModel) — T5, especificamente a variante google/umt5-xxl. - image_encoder (
CLIPVisionModelWithProjection) — CLIP, especificamente a variante clip-vit-huge-patch14. - transformer (SkyReelsV2Transformer3DModel) — Transformer condicional para desruidar os latentes de entrada.
- scheduler (UniPCMultistepScheduler) —
Um scheduler a ser usado em combinação com
transformerpara desruidar os latentes da imagem codificada. - vae (AutoencoderKLWan) — Modelo de Autoencoder Variacional (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. 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__
< source >( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]prompt: str | list[str] = Nonenegative_prompt: str | list[str] = Noneheight: int = 544width: int = 960num_frames: int = 97num_inference_steps: int = 50guidance_scale: float = 5.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneimage_embeds: typing.Optional[torch.Tensor] = Nonelast_image: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'np'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 512 ) → ~SkyReelsV2PipelineOutput or tuple
Parâmetros
- image (
PipelineImageInput) — A imagem de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou umtorch.Tensor. - prompt (
stroulist[str], opcional) — O prompt ou os prompts para orientar a geração da imagem. Se não for definido, é necessário passarprompt_embedsem vez disso. - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - height (
int, padrão544) — A altura do vídeo gerado. - width (
int, padrão960) — A largura do vídeo gerado. - num_frames (
int, padrão97) — O número de quadros no vídeo gerado. - num_inference_steps (
int, padrão50) — O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. - guidance_scale (
float, padrão5.0) — Escala de orientação definida em Classifier-Free Diffusion Guidance.guidance_scaleé definido comowda equação 2 do Imagen Paper. A escala de orientação é ativada ao definirguidance_scale > 1. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas aopromptde 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.Generatoroulist[torch.Generator], opcional) — Umtorch.Generatorpara 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 ogeneratoraleató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 entradaprompt. - 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 entradanegative_prompt. - image_embeds (
torch.Tensor, opcional) — Incorporações de imagem pré-geradas. Podem ser usadas para ajustar facilmente as entradas de imagem (ponderação). Se não forem fornecidas, as incorporações de imagem são geradas a partir do argumento de entradaimage. - 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 entrePIL.Imageounp.array. - return_dict (
bool, opcional, padrãoTrue) — Se deve retornar umWanPipelineOutputem vez de uma tupla simples. - attention_kwargs (
dict, opcional) — Um dicionário de kwargs que, se especificado, é passado aoAttentionProcessorconforme definido emself.processorem diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, opcional) — Uma função ou uma subclasse dePipelineCallbackouMultiPipelineCallbacksque é 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_kwargsincluirá uma lista de todos os tensores, conforme especificado porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — A lista de entradas de tensor para a funçãocallback_on_step_end. Os tensores especificados na lista serão passados como argumentocallback_kwargs. Você só poderá incluir variáveis listadas no atributo._callback_tensor_inputsda sua classe de pipeline. - max_sequence_length (
int, opcional, padrão512) — 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 bools
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:
>>> 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
< source >( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 226device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )
Parâmetros
- prompt (
stroulist[str], opcional) — prompt a ser codificado - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - do_classifier_free_guidance (
bool, opcional, padrãoTrue) — 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) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto negativas pré-geradas. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entradanegative_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
classe diffusers.pipelines.skyreels_v2.pipeline_output.SkyReelsV2PipelineOutput
< source >( frames: Tensor )
Parâmetros
- frames (
torch.Tensor,np.ndarrayou list[list[PIL.Image.Image]]) — lista de saídas de vídeo - Pode ser uma lista aninhada de comprimentobatch_size,com cada sublista contendo sequências de imagens PIL desruidas de comprimentonum_frames.Também pode ser um array NumPy ou tensor Torch de forma(batch_size, num_frames, channels, height, width).
Classe de saída para os pipelines do SkyReelsV2.