Diffusers documentation
SkyReels-V2 : modèle génératif de films de longueur infinie
SkyReels-V2 : modèle génératif de films de longueur infinie
SkyReels-V2 par l'équipe SkyReels de Skywork AI.
Les récentes avancées en génération vidéo ont été portées par les modèles de diffusion et les cadres autorégressifs, mais des défis critiques persistent pour harmoniser le respect du prompt, la qualité visuelle, la dynamique du mouvement et la durée : des compromis sur la dynamique du mouvement pour améliorer la qualité visuelle temporelle, une durée vidéo contrainte (5 à 10 secondes) pour privilégier la résolution, et une génération consciente des plans insuffisante, due à l’incapacité des MLLM généralistes à interpréter la grammaire cinématographique, telle que la composition des plans, les expressions des acteurs et les mouvements de caméra. Ces limites entrelacées entravent la synthèse réaliste de longs formats et la génération de style film professionnel. Pour remédier à ces limites, nous proposons SkyReels-V2, un modèle génératif de films de longueur infinie, qui synergise le Multi-modal Large Language Model (MLLM), le pré-entraînement multi-étapes, l’apprentissage par renforcement et le cadre Diffusion Forcing. Premièrement, nous concevons une représentation structurelle complète de la vidéo qui combine les descriptions générales du MLLM multimodal et le langage détaillé des plans par des modèles sous-experts. Avec l’aide d’annotations humaines, nous entraînons ensuite un Video Captioner unifié, nommé SkyCaptioner-V1, pour étiqueter efficacement les données vidéo. Deuxièmement, nous établissons un pré-entraînement à résolution progressive pour la génération vidéo fondamentale, suivi d’une amélioration post-entraînement en quatre étapes : le Supervised Fine-Tuning (SFT) initial équilibré par concept améliore la qualité de base ; l’entraînement par Reinforcement Learning (RL) spécifique au mouvement, avec des données de distorsion annotées par des humains et synthétiques, traite les artefacts dynamiques ; notre cadre de diffusion forcing avec des calendriers de bruit non décroissants permet la synthèse de vidéos longues dans un espace de recherche efficace ; le SFT final de haute qualité affine la fidélité visuelle. Tout le code et les modèles sont disponibles sur ce lien https URL.
Vous pouvez trouver tous les points de contrôle originaux de SkyReels-V2 sous l'organisation Skywork.
Les modèles SkyReels-V2 suivants sont pris en charge dans 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
Ce modèle a été contribué par M. Tolga Cangöz.
Cliquez sur les modèles SkyReels-V2 dans la barre latérale droite pour plus d’exemples de génération de vidéos.
Une démonstration visuelle
L'exemple ci-dessous possède les paramètres suivants :
base_num_frames=97num_frames=97num_inference_steps=30ar_step=5causal_block_size=5
Avec vae_scale_factor_temporal=4, attendez-vous à 5 blocs de 5 images chacun, calculés comme suit :
num_latent_frames: (97-1)//vae_scale_factor_temporal+1 = 25 frames -> 5 blocks of 5 frames each
Et la longueur de contexte maximale dans l'espace latent est calculée avec base_num_latent_frames :
base_num_latent_frames = (97-1)//vae_scale_factor_temporal+1 = 25 -> 25//5 = 5 blocks
Chronologie du traitement asynchrone :
┌─────────────────────────────────────────────────────────────────┐ │ Steps: 1 6 11 16 21 26 31 36 41 46 50 │ │ Block 1: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] │ │ Block 2: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] │ │ Block 3: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] │ │ Block 4: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] │ │ Block 5: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] │ └─────────────────────────────────────────────────────────────────┘
Pour les vidéos longues (num_frames > base_num_frames) : base_num_frames agit comme la « taille de la fenêtre glissante » pour le traitement des vidéos longues.
Exemple : vidéo de 257 images avec 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
└──────────────────────────────────────────┘Chaque itération exécute indépendamment le traitement asynchrone avec ses propres 5 blocs. base_num_frames contrôle :
- Utilisation de la mémoire (fenêtre plus grande = plus de VRAM)
- Longueur du contexte du modèle (doit correspondre aux contraintes d'entraînement)
- Nombre de blocs par itération (
base_num_latent_frames // causal_block_size)
Chaque bloc nécessite 30 étapes pour terminer le débruitage.
Le bloc N commence à l'étape : 1 + (N-1) x ar_step Nombre total d'étapes : 30 + (5-1) x 5 = 50 étapes
Le mode synchrone (ar_step=0) traite tous les blocs/cadres simultanément :
┌──────────────────────────────────────────────┐ │ Steps: 1 ... 30 │ │ All blocks: [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] │ └──────────────────────────────────────────────┘
Nombre total d'étapes : 30 étapes
Un exemple de la construction de la matrice des étapes pour le traitement asynchrone :
Avec les paramètres : (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]L'algorithme crée une step_matrix de 50x25 où :
- 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]Analyse détaillée de la ligne 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)Motif clé : le bloc i est en retard de exactement ar_step=5 pas de temps par rapport au bloc i-1, ce qui crée l’effet de « diffusion forcée » échelonnée où les blocs ultérieurs conditionnent les blocs antérieurs plus propres.
Génération de texte en vidéo
L'exemple ci-dessous montre comment générer une vidéo à partir d'un texte.
Reportez-vous au guide Réduire l'utilisation de la mémoire pour plus de détails sur les différentes techniques d'économie de mémoire.
Depository original :
Vous pouvez utiliser —ar_step 5 pour activer l'inférence asynchrone. En cas d'inférence asynchrone, —causal_block_size 5 est recommandé, tandis qu'il ne devrait pas être défini pour la génération synchrone… L'inférence asynchrone nécessitera plus d'étapes pour diffuser la séquence entière, ce qui signifie qu'elle sera PLUS LENTE que le mode synchrone. Dans nos expériences, l'inférence asynchrone peut améliorer le suivi des instructions et la cohérence visuelle.
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)Génération de vidéo à partir de la première et de la dernière image
L'exemple ci-dessous montre comment utiliser le pipeline image-verso-vidéo pour générer une vidéo à partir d'une description textuelle, d'une image de départ et d'une image de fin.
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)Génération vidéo-à-vidéo
SkyReelsV2DiffusionForcingVideoToVideoPipeline étend une vidéo donnée.
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 + 257Notes
- SkyReels-V2 prend en charge les LoRA avec load_lora_weights().
SkyReelsV2Pipeline et SkyReelsV2ImageToVideoPipeline sont également disponibles sans le framework Diffusion Forcing.
SkyReelsV2DiffusionForcingPipeline
classe diffusers.SkyReelsV2DiffusionForcingPipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModeltransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Paramètres
- tokenizer (
AutoTokenizer) — Tokenizer de T5, plus précisément la variante google/umt5-xxl. - text_encoder (
UMT5EncoderModel) — T5, plus précisément la variante google/umt5-xxl. - transformer (SkyReelsV2Transformer3DModel) — Transformer conditionnel pour débruyer les latents d'image encodés.
- scheduler (UniPCMultistepScheduler) —
Un planificateur à utiliser en combinaison avec
transformerpour débruyer les latents d'image encodés. - vae (AutoencoderKLWan) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des vidéos vers et depuis des représentations latentes.
Pipeline pour la génération de texte vers vidéo (t2v) à l'aide de SkyReels-V2 avec diffusion forcing.
Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil spécifique, 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[str] = ['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
Paramètres
- prompt (
stroulist[str], facultatif) — Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passerprompt_embedsà la place. - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - height (
int, par défaut544) — La hauteur de la vidéo générée. - width (
int, par défaut960) — La largeur de la vidéo générée. - num_frames (
int, par défaut97) — Le nombre de frames dans la vidéo générée. - num_inference_steps (
int, par défaut50) — Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente. - guidance_scale (
float, par défaut6.0) — Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance.guidance_scaleest défini commewde l'équation 2. de Imagen Paper. L'échelle de guidage est activée en définissantguidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées auprompttexte, généralement au détriment de la qualité de l'image. (6.0 pour T2V, 5.0 pour I2V) - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite. - generator (
torch.Generatoroulist[torch.Generator], facultatif) — Untorch.Generatorpour rendre la génération déterministe. - latents (
torch.Tensor, facultatif) — Latents bruités pré-générés, échantillonnés à partir d’une distribution gaussienne, à utiliser comme entrées pour la génération d’images. Peut servir à ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents est généré par échantillonnage à l’aide dugeneratoraléatoire fourni. - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréenegative_prompt. - output_type (
str, facultatif, par défaut"np") — Le format de sortie de l'image générée. Choisissez entrePIL.Imageounp.array. - return_dict (
bool, facultatif, par défautTrue) — Indique s'il faut retourner unSkyReelsV2PipelineOutputplutôt qu'un simple tuple. - attention_kwargs (
dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessordéfini sousself.processordans diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, facultatif) — Une fonction ou une sous-classe dePipelineCallbackouMultiPipelineCallbacksqui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants :callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargscontiendra une liste de tous les tenseurs spécifiés parcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, facultatif) — La liste des entrées tensorielles pour la fonctioncallback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argumentcallback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut._callback_tensor_inputsde votre classe de pipeline. - max_sequence_length (
int, facultatif, par défaut512) — La longueur maximale de la séquence du prompt. - overlap_history (
int, facultatif, par défautNone) — Nombre de frames à superposer pour des transitions fluides dans les vidéos longues. SiNone, le pipeline suppose un mode de génération de vidéos courtes et n’applique aucune superposition. Les valeurs 17 et 37 sont recommandées. - addnoise_condition (
float, facultatif, valeur par défaut0) — Ce paramètre aide à lisser la génération de vidéos longues en ajoutant un peu de bruit à la condition propre. Un bruit trop important peut également entraîner des incohérences. La valeur 20 est recommandée ; vous pouvez essayer des valeurs plus élevées, mais il est conseillé de ne pas dépasser 50. - base_num_frames (
int, facultatif, valeur par défaut97) — 97 ou 121 | Nombre de base de frames (97 pour 540P, 121 pour 720P) - ar_step (
int, facultatif, par défaut0) — Contrôle l’inférence asynchrone (0 pour le mode synchrone). Vous pouvez définirar_step=5pour activer l’inférence asynchrone. En cas d’inférence asynchrone, il est recommandé de définircausal_block_size=5, tandis que ce paramètre ne doit pas être défini pour la génération synchrone. L’inférence asynchrone nécessite plus d’étapes pour diffuser la séquence entière, ce qui signifie qu’elle sera PLUS LENTE que le mode synchrone. Dans nos expériences, l’inférence asynchrone peut améliorer le suivi des instructions et la cohérence visuelle. - causal_block_size (
int, facultatif, par défautNone) — Le nombre de trames dans chaque bloc/fragment. Recommandé lors de l’utilisation de l’inférence asynchrone (lorsque ar_step > 0) - fps (
int, facultatif, par défaut24) — Fréquence d’images de la vidéo générée
Retourne
~SkyReelsV2PipelineOutput ou tuple
Si return_dict est True, SkyReelsV2PipelineOutput est renvoyé, sinon un tuple est renvoyé
dont le premier élément est une liste des images générées et le deuxième élément est une liste de bool
indiquant si l’image générée correspondante contient du contenu « not-safe-for-work » (nsfw).
La fonction d'appel du pipeline pour la génération.
Exemples :
>>> 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 )
Paramètres
- prompt (
stroulist[str], facultatif) — prompt à encoder - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - do_classifier_free_guidance (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser le classifier free guidance ou non. - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entréenegative_prompt. - device — (
torch.device, facultatif) : torch device - dtype — (
torch.dtype, facultatif) : dtype torch
Encode le prompt dans les états cachés de l'encodeur de texte.
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
Paramètres
- num_latent_frames (int) — Nombre total de trames latentes à générer
- step_template (torch.Tensor) — Plan de pas de base (par exemple, [1000, 800, 600, …, 0])
- base_num_latent_frames (int) — Nombre maximal de frames que le modèle peut traiter lors d'un seul passage avant
- ar_step (int, optionnel) — Taille de pas autorégressive pour le décalage temporel. 0 = synchrone, >0 = asynchrone. Valeur par défaut : 5.
- num_pre_ready (int, optionnel) — Nombre de frames déjà débruitées (par exemple, issues d'un préfixe dans une tâche video2video). Valeur par défaut : 0.
- causal_block_size (int, optionnel) — Nombre de trames traitées en tant que bloc causal. Valeur par défaut : 1.
- shrink_interval_with_mask (bool, optionnel) — Indique s'il faut optimiser les intervalles de traitement. Valeur par défaut : False.
Retourne
tuple contenant
- step_matrix (torch.Tensor) : Matrice des pas de temps pour chaque image à chaque itération. Forme : [num_iterations, num_latent_frames]
- step_index (torch.Tensor) : Matrice d'index pour la recherche de pas de temps. Forme : [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor) : masque booléen indiquant les frames à mettre à jour. Forme : [num_iterations, num_latent_frames]
- valid_interval (list[tuple]) : liste d'intervalles (start, end) pour chaque itération
Lève
ValueError
ValueError— Si ar_step est trop petit pour la configuration donnée
Cette fonction implémente l'algorithme de diffusion forcing qui crée un calendrier de débruitage coordonné sur les frames temporelles. Elle prend en charge les modes de génération synchrones et asynchrones :
Mode synchrone (ar_step=0, causal_block_size=1) :
- Toutes les images sont débruitées simultanément à chaque pas de temps
- Chaque image suit la même trajectoire de débruitage : [1000, 800, 600, …, 0]
- Plus simple, mais peut présenter une moindre cohérence temporelle pour les vidéos longues
Mode asynchrone (ar_step>0, causal_block_size>1) :
- Les images sont regroupées en blocs causaux et traitées par bloc/par tranche
- Chaque bloc est débruité selon un motif décalé, créant une « onde de débruitage ».
- Les blocs antérieurs sont plus débruités, tandis que les blocs ultérieurs accusent un retard de ar_step pas de temps
- Crée des dépendances temporelles plus fortes et une meilleure cohérence
SkyReelsV2DiffusionForcingImageToVideoPipeline
classe diffusers.SkyReelsV2DiffusionForcingImageToVideoPipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModeltransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Paramètres
- tokenizer (
AutoTokenizer) — Tokenizer de T5, plus précisément la variante google/umt5-xxl. - text_encoder (
UMT5EncoderModel) — T5, plus précisément la variante google/umt5-xxl. - transformer (SkyReelsV2Transformer3DModel) — Transformer conditionnel pour débruyer les latents d'image encodés.
- scheduler (UniPCMultistepScheduler) —
Un planificateur à utiliser en combinaison avec
transformerpour débruyer les latents d'image encodés. - vae (AutoencoderKLWan) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des vidéos vers et depuis des représentations latentes.
Pipeline pour la génération d'images en vidéo (i2v) utilisant SkyReels-V2 avec diffusion forcing.
Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil spécifique, 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[str] = ['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
Paramètres
- image (
PipelineImageInput) — L'image d'entrée sur laquelle conditionner la génération. Doit être une image, une liste d'images ou untorch.Tensor. - prompt (
stroulist[str], facultatif) — Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passerprompt_embedsà la place. - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - height (
int, par défaut544) — La hauteur de la vidéo générée. - width (
int, par défaut960) — La largeur de la vidéo générée. - num_frames (
int, par défaut97) — Le nombre de frames dans la vidéo générée. - num_inference_steps (
int, par défaut50) — Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente. - guidance_scale (
float, par défaut5.0) — Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance.guidance_scaleest défini commewde l'équation 2. de Imagen Paper. L'échelle de guidage est activée en définissantguidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées auprompttexte, généralement au détriment de la qualité de l'image. (6.0 pour T2V, 5.0 pour I2V) - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite. - generator (
torch.Generatoroulist[torch.Generator], facultatif) — Untorch.Generatorpour rendre la génération déterministe. - latents (
torch.Tensor, facultatif) — Latents bruités pré-générés, échantillonnés à partir d’une distribution gaussienne, à utiliser comme entrées pour la génération d’images. Peut servir à ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents est généré par échantillonnage à l’aide dugeneratoraléatoire fourni. - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréenegative_prompt. - image_embeds (
torch.Tensor, facultatif) — Embeddings d’image pré-générés. Peut être utilisé pour ajuster facilement les entrées d’image (pondération). S’ils ne sont pas fournis, les embeddings d’image sont générés à partir de l’argument d’entréeimage. - last_image (
torch.Tensor, facultatif) — Embeddings d’images pré-générés. Peut être utilisé pour ajuster facilement les entrées d’image (pondération). S’il n’est pas fourni, les embeddings d’images sont générés à partir de l’argument d’entréeimage. - output_type (
str, facultatif, par défaut"np") — Le format de sortie de l'image générée. Choisissez entrePIL.Imageounp.array. - return_dict (
bool, facultatif, par défautTrue) — Indique s'il faut retourner unSkyReelsV2PipelineOutputplutôt qu'un simple tuple. - attention_kwargs (
dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessordéfini sousself.processordans diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, facultatif) — Une fonction ou une sous-classe dePipelineCallbackouMultiPipelineCallbacksqui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants :callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargscontiendra une liste de tous les tenseurs spécifiés parcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, facultatif) — La liste des entrées tensorielles pour la fonctioncallback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argumentcallback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut._callback_tensor_inputsde votre classe de pipeline. - max_sequence_length (
int, facultatif, par défaut512) — La longueur maximale de la séquence du prompt. - overlap_history (
int, facultatif, par défautNone) — Nombre de frames à superposer pour des transitions fluides dans les vidéos longues. SiNone, le pipeline suppose un mode de génération de vidéos courtes et n’applique aucune superposition. Les valeurs 17 et 37 sont recommandées. - addnoise_condition (
float, facultatif, valeur par défaut0) — Ce paramètre aide à lisser la génération de vidéos longues en ajoutant un peu de bruit à la condition propre. Un bruit trop important peut également entraîner des incohérences. La valeur 20 est recommandée ; vous pouvez essayer des valeurs plus élevées, mais il est conseillé de ne pas dépasser 50. - base_num_frames (
int, facultatif, valeur par défaut97) — 97 ou 121 | Nombre de base de frames (97 pour 540P, 121 pour 720P) - ar_step (
int, facultatif, par défaut0) — Contrôle l’inférence asynchrone (0 pour le mode synchrone). Vous pouvez définirar_step=5pour activer l’inférence asynchrone. En cas d’inférence asynchrone, il est recommandé de définircausal_block_size=5, tandis que ce paramètre ne doit pas être défini pour la génération synchrone. L’inférence asynchrone nécessite plus d’étapes pour diffuser la séquence entière, ce qui signifie qu’elle sera PLUS LENTE que le mode synchrone. Dans nos expériences, l’inférence asynchrone peut améliorer le suivi des instructions et la cohérence visuelle. - causal_block_size (
int, facultatif, par défautNone) — Le nombre de trames dans chaque bloc/fragment. Recommandé lors de l’utilisation de l’inférence asynchrone (lorsque ar_step > 0) - fps (
int, facultatif, par défaut24) — Fréquence d’images de la vidéo générée
Retourne
~SkyReelsV2PipelineOutput ou tuple
Si return_dict est True, SkyReelsV2PipelineOutput est renvoyé, sinon un tuple est renvoyé
dont le premier élément est une liste des images générées et le deuxième élément est une liste de bool
indiquant si l’image générée correspondante contient du contenu « not-safe-for-work » (nsfw).
La fonction d'appel du pipeline pour la génération.
Exemples :
>>> 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 )
Paramètres
- prompt (
stroulist[str], facultatif) — prompt à encoder - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - do_classifier_free_guidance (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser le classifier free guidance ou non. - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entréenegative_prompt. - device — (
torch.device, facultatif) : torch device - dtype — (
torch.dtype, facultatif) : dtype torch
Encode le prompt dans les états cachés de l'encodeur de texte.
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
Paramètres
- num_latent_frames (int) — Nombre total de trames latentes à générer
- step_template (torch.Tensor) — Plan de pas de base (par exemple, [1000, 800, 600, …, 0])
- base_num_latent_frames (int) — Nombre maximal de frames que le modèle peut traiter lors d'un seul passage avant
- ar_step (int, optionnel) — Taille de pas autorégressive pour le décalage temporel. 0 = synchrone, >0 = asynchrone. Valeur par défaut : 5.
- num_pre_ready (int, optionnel) — Nombre de frames déjà débruitées (par exemple, issues d'un préfixe dans une tâche video2video). Valeur par défaut : 0.
- causal_block_size (int, optionnel) — Nombre de trames traitées en tant que bloc causal. Valeur par défaut : 1.
- shrink_interval_with_mask (bool, optionnel) — Indique s'il faut optimiser les intervalles de traitement. Valeur par défaut : False.
Retourne
tuple contenant
- step_matrix (torch.Tensor) : Matrice des pas de temps pour chaque image à chaque itération. Forme : [num_iterations, num_latent_frames]
- step_index (torch.Tensor) : Matrice d'index pour la recherche de pas de temps. Forme : [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor) : masque booléen indiquant les frames à mettre à jour. Forme : [num_iterations, num_latent_frames]
- valid_interval (list[tuple]) : liste d'intervalles (start, end) pour chaque itération
Lève
ValueError
ValueError— Si ar_step est trop petit pour la configuration donnée
Cette fonction implémente l'algorithme de diffusion forcing qui crée un calendrier de débruitage coordonné sur les frames temporelles. Elle prend en charge les modes de génération synchrones et asynchrones :
Mode synchrone (ar_step=0, causal_block_size=1) :
- Toutes les images sont débruitées simultanément à chaque pas de temps
- Chaque image suit la même trajectoire de débruitage : [1000, 800, 600, …, 0]
- Plus simple, mais peut présenter une moindre cohérence temporelle pour les vidéos longues
Mode asynchrone (ar_step>0, causal_block_size>1) :
- Les images sont regroupées en blocs causaux et traitées par bloc/par tranche
- Chaque bloc est débruité selon un motif décalé, créant une « onde de débruitage ».
- Les blocs antérieurs sont plus débruités, tandis que les blocs ultérieurs accusent un retard de ar_step pas de temps
- Crée des dépendances temporelles plus fortes et une meilleure cohérence
SkyReelsV2DiffusionForcingVideoToVideoPipeline
classe diffusers.SkyReelsV2DiffusionForcingVideoToVideoPipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModeltransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Paramètres
- tokenizer (
AutoTokenizer) — Tokenizer de T5, plus précisément la variante google/umt5-xxl. - text_encoder (
UMT5EncoderModel) — T5, plus précisément la variante google/umt5-xxl. - transformer (SkyReelsV2Transformer3DModel) — Transformer conditionnel pour débruyer les latents d'image encodés.
- scheduler (UniPCMultistepScheduler) —
Un planificateur à utiliser en combinaison avec
transformerpour débruyer les latents d'image encodés. - vae (AutoencoderKLWan) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des vidéos vers et depuis des représentations latentes.
Pipeline pour la génération Vidéo-vers-Vidéo (v2v) utilisant SkyReels-V2 avec diffusion forcing.
Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil spécifique, etc.).
__call__
< source >( video: list[PIL.Image.Image]prompt: 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[str] = ['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
Paramètres
- video (
list[Image.Image]) — La vidéo servant de guide pour la génération de la vidéo. - prompt (
stroulist[str], facultatif) — Le prompt ou les prompts pour guider la génération de la vidéo. S'il n'est pas défini, il faut passerprompt_embedsà la place. - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération de la vidéo. S'il n'est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque la guidance n'est pas utilisée (c'est-à-dire ignoré siguidance_scaleest inférieur à1). - height (
int, par défaut544) — La hauteur de la vidéo générée. - width (
int, par défaut960) — La largeur de la vidéo générée. - num_frames (
int, par défaut120) — Le nombre de frames dans la vidéo générée. - num_inference_steps (
int, par défaut50) — Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente. - guidance_scale (
float, par défaut6.0) — Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance.guidance_scaleest défini commewde l'équation 2. de Imagen Paper. L'échelle de guidage est activée en définissantguidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées aupromptde texte, généralement au détriment de la qualité de l'image. (6.0 pour T2V, 5.0 pour I2V) - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite. - generator (
torch.Generatoroulist[torch.Generator], facultatif) — Untorch.Generatorpour rendre la génération déterministe. - latents (
torch.Tensor, facultatif) — Latents bruités pré-générés, échantillonnés à partir d’une distribution gaussienne, à utiliser comme entrées pour la génération d’images. Peut servir à ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents est généré par échantillonnage à l’aide dugeneratoraléatoire fourni. - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréenegative_prompt. - output_type (
str, facultatif, par défaut"np") — Le format de sortie de l'image générée. Choisissez entrePIL.Imageounp.array. - return_dict (
bool, facultatif, par défautTrue) — Indique s'il faut retourner unSkyReelsV2PipelineOutputplutôt qu'un simple tuple. - attention_kwargs (
dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessordéfini sousself.processordans diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, facultatif) — Une fonction ou une sous-classe dePipelineCallbackouMultiPipelineCallbacksqui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants :callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargscontiendra une liste de tous les tenseurs spécifiés parcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, facultatif) — La liste des entrées tensorielles pour la fonctioncallback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argumentcallback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut._callback_tensor_inputsde votre classe de pipeline. - max_sequence_length (
int, facultatif, par défaut512) — La longueur maximale de la séquence du prompt. - overlap_history (
int, facultatif, par défautNone) — Nombre de frames à superposer pour des transitions fluides dans les vidéos longues. SiNone, le pipeline suppose un mode de génération de vidéos courtes et n’applique aucune superposition. Les valeurs 17 et 37 sont recommandées. - addnoise_condition (
float, facultatif, valeur par défaut0) — Ce paramètre aide à lisser la génération de vidéos longues en ajoutant un peu de bruit à la condition propre. Un bruit trop important peut également entraîner des incohérences. La valeur 20 est recommandée ; vous pouvez essayer des valeurs plus élevées, mais il est conseillé de ne pas dépasser 50. - base_num_frames (
int, facultatif, valeur par défaut97) — 97 ou 121 | Nombre de base de frames (97 pour 540P, 121 pour 720P) - ar_step (
int, facultatif, par défaut0) — Contrôle l’inférence asynchrone (0 pour le mode synchrone). Vous pouvez définirar_step=5pour activer l’inférence asynchrone. En cas d’inférence asynchrone, il est recommandé de définircausal_block_size=5, tandis que ce paramètre ne doit pas être défini pour la génération synchrone. L’inférence asynchrone nécessite plus d’étapes pour diffuser la séquence entière, ce qui signifie qu’elle sera PLUS LENTE que le mode synchrone. Dans nos expériences, l’inférence asynchrone peut améliorer le suivi des instructions et la cohérence visuelle. - causal_block_size (
int, facultatif, par défautNone) — Le nombre de trames dans chaque bloc/fragment. Recommandé lors de l’utilisation de l’inférence asynchrone (lorsque ar_step > 0) - fps (
int, facultatif, par défaut24) — Fréquence d’images de la vidéo générée
Retourne
~SkyReelsV2PipelineOutput ou tuple
Si return_dict est True, SkyReelsV2PipelineOutput est renvoyé, sinon un tuple est renvoyé
dont le premier élément est une liste des images générées et le deuxième élément est une liste de bool
indiquant si l’image générée correspondante contient du contenu « not-safe-for-work » (nsfw).
La fonction d'appel du pipeline pour la génération.
Exemples :
>>> 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 )
Paramètres
- prompt (
stroulist[str], facultatif) — prompt à encoder - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - do_classifier_free_guidance (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser le classifier free guidance ou non. - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entréenegative_prompt. - device — (
torch.device, facultatif) : torch device - dtype — (
torch.dtype, facultatif) : dtype torch
Encode le prompt dans les états cachés de l'encodeur de texte.
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
Paramètres
- num_latent_frames (int) — Nombre total de trames latentes à générer
- step_template (torch.Tensor) — Plan de pas de base (par exemple, [1000, 800, 600, …, 0])
- base_num_latent_frames (int) — Nombre maximal de frames que le modèle peut traiter lors d'un seul passage avant
- ar_step (int, optionnel) — Taille de pas autorégressive pour le décalage temporel. 0 = synchrone, >0 = asynchrone. Valeur par défaut : 5.
- num_pre_ready (int, optionnel) — Nombre de frames déjà débruitées (par exemple, issues d'un préfixe dans une tâche video2video). Valeur par défaut : 0.
- causal_block_size (int, optionnel) — Nombre de trames traitées en tant que bloc causal. Valeur par défaut : 1.
- shrink_interval_with_mask (bool, optionnel) — Indique s'il faut optimiser les intervalles de traitement. Valeur par défaut : False.
Retourne
tuple contenant
- step_matrix (torch.Tensor) : Matrice des pas de temps pour chaque image à chaque itération. Forme : [num_iterations, num_latent_frames]
- step_index (torch.Tensor) : Matrice d'index pour la recherche de pas de temps. Forme : [num_iterations, num_latent_frames]
- step_update_mask (torch.Tensor) : masque booléen indiquant les frames à mettre à jour. Forme : [num_iterations, num_latent_frames]
- valid_interval (list[tuple]) : liste d'intervalles (start, end) pour chaque itération
Lève
ValueError
ValueError— Si ar_step est trop petit pour la configuration donnée
Cette fonction implémente l'algorithme de diffusion forcing qui crée un calendrier de débruitage coordonné sur les frames temporelles. Elle prend en charge les modes de génération synchrones et asynchrones :
Mode synchrone (ar_step=0, causal_block_size=1) :
- Toutes les images sont débruitées simultanément à chaque pas de temps
- Chaque image suit la même trajectoire de débruitage : [1000, 800, 600, …, 0]
- Plus simple, mais peut présenter une moindre cohérence temporelle pour les vidéos longues
Mode asynchrone (ar_step>0, causal_block_size>1) :
- Les images sont regroupées en blocs causaux et traitées par bloc/par tranche
- Chaque bloc est débruité selon un motif décalé, créant une « onde de débruitage ».
- Les blocs antérieurs sont plus débruités, tandis que les blocs ultérieurs accusent un retard de ar_step pas de temps
- Crée des dépendances temporelles plus fortes et une meilleure cohérence
SkyReelsV2Pipeline
classe diffusers.SkyReelsV2Pipeline
< source >( tokenizer: AutoTokenizertext_encoder: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.umt5.modeling_umt5.UMT5EncoderModeltransformer: SkyReelsV2Transformer3DModelvae: AutoencoderKLWanscheduler: UniPCMultistepScheduler )
Paramètres
- tokenizer (
T5Tokenizer) — Tokenizer issu de T5, plus précisément la variante google/umt5-xxl. - text_encoder (
T5EncoderModel) — T5, plus précisément la variante google/umt5-xxl. - transformer (SkyReelsV2Transformer3DModel) — Transformer conditionnel pour débruyer les latents d’entrée.
- scheduler (UniPCMultistepScheduler) —
Un planificateur à utiliser en combinaison avec
transformerpour débruyer les latents d'image encodés. - vae (AutoencoderKLWan) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des vidéos vers et depuis des représentations latentes.
Pipeline pour la génération de texte vers vidéo (t2v) à l'aide de SkyReels-V2.
Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, 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[str] = ['latents']max_sequence_length: int = 512 ) → ~SkyReelsV2PipelineOutput or tuple
Paramètres
- prompt (
stroulist[str], facultatif) — Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passerprompt_embedsà la place. - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (guidance_scale < 1). - height (
int, par défaut544) — La hauteur en pixels de l'image générée. - width (
int, par défaut960) — La largeur en pixels de l'image générée. - num_frames (
int, par défaut97) — Le nombre de frames dans la vidéo générée. - num_inference_steps (
int, par défaut50) — Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente. - guidance_scale (
float, par défaut6.0) — Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance.guidance_scaleest défini commewde l’équation 2 de Imagen Paper. L’échelle de guidage est activée en définissantguidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d’images étroitement liées auprompttexte, généralement au détriment de la qualité de l’image. - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite. - generator (
torch.Generatoroulist[torch.Generator], facultatif) — Untorch.Generatorpour rendre la génération déterministe. - latents (
torch.Tensor, facultatif) — Latents bruités pré-générés, échantillonnés à partir d’une distribution gaussienne, à utiliser comme entrées pour la génération d’images. Peut servir à ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents est généré par échantillonnage à l’aide dugeneratoraléatoire fourni. - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'ils ne sont pas fournis, lesnegative_prompt_embedssont générés à partir de l'argument d'entréenegative_prompt. - output_type (
str, facultatif, par défaut"np") — Le format de sortie de l'image générée. Choisissez entrePIL.Imageounp.array. - return_dict (
bool, facultatif, par défautTrue) — Indique s'il faut retourner unSkyReelsV2PipelineOutputplutôt qu'un simple tuple. - attention_kwargs (
dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessordéfini sousself.processordans diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, facultatif) — Une fonction ou une sous-classe dePipelineCallbackouMultiPipelineCallbacksqui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants :callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargscontiendra une liste de tous les tenseurs spécifiés parcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, facultatif) — La liste des entrées tensorielles pour la fonctioncallback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argumentcallback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut._callback_tensor_inputsde votre classe de pipeline. - max_sequence_length (
int, facultatif, par défaut512) — La longueur de séquence maximale pour l'encodeur de texte.
Retourne
~SkyReelsV2PipelineOutput ou tuple
Si return_dict est True, SkyReelsV2PipelineOutput est renvoyé, sinon un tuple est renvoyé
dont le premier élément est une liste des images générées et le deuxième élément est une liste de bool
indiquant si l’image générée correspondante contient du contenu « not-safe-for-work » (nsfw).
La fonction d'appel du pipeline pour la génération.
Exemples :
>>> 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 )
Paramètres
- prompt (
stroulist[str], facultatif) — prompt à encoder - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - do_classifier_free_guidance (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser le classifier free guidance ou non. - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entréenegative_prompt. - device — (
torch.device, facultatif) : torch device - dtype — (
torch.dtype, facultatif) : dtype torch
Encode le prompt dans les états cachés de l'encodeur de texte.
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 )
Paramètres
- tokenizer (
T5Tokenizer) — Tokenizer issu de T5, plus précisément la variante google/umt5-xxl. - text_encoder (
T5EncoderModel) — T5, plus précisément la variante google/umt5-xxl. - image_encoder (
CLIPVisionModelWithProjection) — CLIP, plus précisément la variante clip-vit-huge-patch14. - transformer (SkyReelsV2Transformer3DModel) — Transformer conditionnel pour débruyer les latents d’entrée.
- scheduler (UniPCMultistepScheduler) —
Un planificateur à utiliser en combinaison avec
transformerpour débruyer les latents d'image encodés. - vae (AutoencoderKLWan) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des vidéos vers et depuis des représentations latentes.
Pipeline pour la génération d'images en vidéo (i2v) utilisant SkyReels-V2.
Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, 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[str] = ['latents']max_sequence_length: int = 512 ) → ~SkyReelsV2PipelineOutput or tuple
Paramètres
- image (
PipelineImageInput) — L'image d'entrée sur laquelle conditionner la génération. Doit être une image, une liste d'images ou untorch.Tensor. - prompt (
stroulist[str], facultatif) — Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passerprompt_embedsà la place. - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - height (
int, par défaut544) — La hauteur de la vidéo générée. - width (
int, par défaut960) — La largeur de la vidéo générée. - num_frames (
int, par défaut97) — Le nombre de frames dans la vidéo générée. - num_inference_steps (
int, par défaut50) — Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente. - guidance_scale (
float, par défaut5.0) — Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance.guidance_scaleest défini commewde l’équation 2 de Imagen Paper. L’échelle de guidage est activée en définissantguidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d’images étroitement liées auprompttexte, généralement au détriment de la qualité de l’image. - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite. - generator (
torch.Generatoroulist[torch.Generator], facultatif) — Untorch.Generatorpour rendre la génération déterministe. - latents (
torch.Tensor, facultatif) — Latents bruités pré-générés, échantillonnés à partir d’une distribution gaussienne, à utiliser comme entrées pour la génération d’images. Peut servir à ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents est généré par échantillonnage à l’aide dugeneratoraléatoire fourni. - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréenegative_prompt. - image_embeds (
torch.Tensor, facultatif) — Embeddings d’image pré-générés. Peut être utilisé pour ajuster facilement les entrées d’image (pondération). S’ils ne sont pas fournis, les embeddings d’image sont générés à partir de l’argument d’entréeimage. - last_image (
torch.Tensor, facultatif) — Dernière image facultative pour le conditionnement image-versus-vidéo, qui ancre la fin de la vidéo générée. - output_type (
str, facultatif, par défaut"np") — Le format de sortie de l'image générée. Choisissez entrePIL.Imageounp.array. - return_dict (
bool, facultatif, par défautTrue) — Indique s'il faut retourner unWanPipelineOutputplutôt qu'un simple tuple. - attention_kwargs (
dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessordéfini sousself.processordans diffusers.models.attention_processor. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, facultatif) — Une fonction ou une sous-classe dePipelineCallbackouMultiPipelineCallbacksqui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants :callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargscontiendra une liste de tous les tenseurs spécifiés parcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, facultatif) — La liste des entrées tensorielles pour la fonctioncallback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argumentcallback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut._callback_tensor_inputsde votre classe de pipeline. - max_sequence_length (
int, facultatif, par défaut512) — La longueur maximale de la séquence du prompt.
Retourne
~SkyReelsV2PipelineOutput ou tuple
Si return_dict est True, SkyReelsV2PipelineOutput est renvoyé, sinon un tuple est renvoyé
dont le premier élément est une liste des images générées et le deuxième élément est une liste de bool
indiquant si l’image générée correspondante contient du contenu « not-safe-for-work » (nsfw).
La fonction d'appel du pipeline pour la génération.
Exemples :
>>> 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 )
Paramètres
- prompt (
stroulist[str], facultatif) — prompt à encoder - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - do_classifier_free_guidance (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser le classifier free guidance ou non. - num_videos_per_prompt (
int, facultatif, valeur par défaut 1) — Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entréeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entréenegative_prompt. - device — (
torch.device, facultatif) : torch device - dtype — (
torch.dtype, facultatif) : dtype torch
Encode le prompt dans les états cachés de l'encodeur de texte.
SkyReelsV2PipelineOutput
classe diffusers.pipelines.skyreels_v2.pipeline_output.SkyReelsV2PipelineOutput
< source >( frames: Tensor )
Paramètres
- frames (
torch.Tensor,np.ndarrayou list[list[PIL.Image.Image]]) — liste des sorties vidéo - Il peut s'agir d'une liste imbriquée de longueurbatch_size,où chaque sous-liste contient des séquences d'images PIL débruitées de longueurnum_frames.Il peut également s'agir d'un tableau NumPy ou d'un tenseur Torch de forme(batch_size, num_frames, channels, height, width).
Classe de sortie pour les pipelines SkyReelsV2.