File size: 7,657 Bytes
157a4c0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | import argparse
from typing import Optional
import torch
from musubi_tuner.dataset import config_utils
from musubi_tuner.dataset.config_utils import BlueprintGenerator, ConfigSanitizer
from musubi_tuner.dataset.image_video_dataset import ARCHITECTURE_HUNYUAN_VIDEO_1_5, ItemInfo, save_latent_cache_hunyuan_video_1_5
from musubi_tuner.frame_pack.clip_vision import hf_clip_vision_encode
from musubi_tuner.frame_pack.framepack_utils import load_image_encoders
from musubi_tuner.hunyuan_video_1_5 import hunyuan_video_1_5_vae
from musubi_tuner.hunyuan_video_1_5.hunyuan_video_1_5_vae import AutoencoderKLConv3D
from musubi_tuner.utils.model_utils import str_to_dtype
import musubi_tuner.cache_latents as cache_latents
import logging
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def encode_and_save_batch(
vae: AutoencoderKLConv3D, image_encoder_assets: Optional[tuple], batch: list[ItemInfo], i2v: bool = False
):
contents = torch.stack([torch.from_numpy(item.content) for item in batch])
if len(contents.shape) == 4:
contents = contents.unsqueeze(1) # B, H, W, C -> B, F, H, W, C
contents = contents.permute(0, 4, 1, 2, 3).contiguous() # B, C, F, H, W
contents = contents.to(vae.device, dtype=vae.dtype)
contents = contents / 127.5 - 1.0 # normalize to [-1, 1]
h, w = contents.shape[3], contents.shape[4]
if h < 16 or w < 16:
item = batch[0] # other items should have the same size
raise ValueError(f"Image or video size too small: {item.item_key} and {len(batch) - 1} more, size: {item.original_size}")
# VAE requires a lot of VRAM, so process one by one.
latents_list = []
for i in range(contents.shape[0]):
content = contents[i : i + 1, :, :, :, :] # 1, C, F, H, W
with torch.autocast(device_type=vae.device.type, dtype=vae.dtype, enabled=True), torch.no_grad():
latent = vae.encode(content)[0].mode()
# latent = latent * vae.scaling_factor # no scaling here, saved in VAE latent space directly
latents_list.append(latent)
latents = torch.cat(latents_list, dim=0) # B, C, F, H, W
cond_latents_list = None
vision_features = None
if i2v:
# extract first frame of contents
images = contents[:, :, 0:1, :, :] # B, C, 1, H, W. normalized.
lat_f, lat_h, lat_w = latents.shape[2], latents.shape[3], latents.shape[4]
# make i2v cond_latents: 1 frame latent + mask channel.
cond_latents_list = []
vision_features = []
for i in range(images.shape[0]):
first_frame = images[i : i + 1, :, 0:1, :, :] # 1, C, 1, H, W. normalized.
with torch.autocast(device_type=vae.device.type, dtype=vae.dtype, enabled=True), torch.no_grad():
cond_latents = vae.encode(first_frame)[0].mode()
# cond_latents = cond_latents * vae.scaling_factor # no scaling here, saved in VAE latent space directly
latents_concat = torch.zeros(
1, hunyuan_video_1_5_vae.VAE_LATENT_CHANNELS, lat_f, lat_h, lat_w, dtype=torch.float32, device=vae.device
)
latents_concat[:, :, 0:1, :, :] = cond_latents
# latent_mask = torch.zeros(lat_f, device=vae.device)
# latent_mask[0] = 1.0
# mask_concat = torch.ones(1, 1, lat_f, lat_h, lat_w, device=vae.device) * latent_mask[None, None, :, None, None]
mask_concat = torch.zeros(1, 1, lat_f, lat_h, lat_w, device=vae.device)
mask_concat[:, :, 0:1, :, :] = 1.0
cond_latents = torch.concat([latents_concat, mask_concat], dim=1) # 1, C+1, F, H, W
cond_latents_list.append(cond_latents[0]) # remove batch dim
# extract vision feature from first frame
first_frame_np = batch[i].content[0] # H, W, C, uint8
feature_extractor, image_encoder = image_encoder_assets
with torch.no_grad():
vision_feature = hf_clip_vision_encode(first_frame_np, feature_extractor, image_encoder)
image_encoder_last_hidden_state = vision_feature.last_hidden_state # float16
vision_features.append(image_encoder_last_hidden_state[0]) # remove batch dim
for i, item in enumerate(batch):
latent = latents[i]
cond_latent = None if cond_latents_list is None else cond_latents_list[i]
vision_feature = None if vision_features is None else vision_features[i]
save_latent_cache_hunyuan_video_1_5(item, latent, cond_latent, vision_feature)
def main():
parser = cache_latents.setup_parser_common()
parser = hv1_5_setup_parser(parser)
args = parser.parse_args()
if args.disable_cudnn_backend:
logger.info("Disabling cuDNN PyTorch backend.")
torch.backends.cudnn.enabled = False
if args.i2v:
assert args.image_encoder is not None, "--i2v requires --image_encoder to be set."
elif args.image_encoder is not None:
logger.info("--image_encoder is set but --i2v is not set. Enabling --i2v.")
args.i2v = True
device = args.device if args.device is not None else "cuda" if torch.cuda.is_available() else "cpu"
device = torch.device(device)
# Load dataset config
blueprint_generator = BlueprintGenerator(ConfigSanitizer())
logger.info(f"Load dataset config from {args.dataset_config}")
user_config = config_utils.load_user_config(args.dataset_config)
blueprint = blueprint_generator.generate(user_config, args, architecture=ARCHITECTURE_HUNYUAN_VIDEO_1_5)
train_dataset_group = config_utils.generate_dataset_group_by_blueprint(blueprint.dataset_group)
datasets = train_dataset_group.datasets
if args.debug_mode is not None:
cache_latents.show_datasets(
datasets, args.debug_mode, args.console_width, args.console_back, args.console_num_images, fps=16
)
return
assert args.vae is not None, "vae checkpoint is required"
logger.info(f"Loading VAE model from {args.vae}")
vae_dtype = torch.float16 if args.vae_dtype is None else str_to_dtype(args.vae_dtype)
vae = hunyuan_video_1_5_vae.load_vae_from_checkpoint(
args.vae, device, vae_dtype, sample_size=args.vae_sample_size, enable_patch_conv=args.vae_enable_patch_conv
)
vae.eval()
if args.i2v:
feature_extractor, image_encoder = load_image_encoders(args)
image_encoder.to(device)
image_encoder_assets = (feature_extractor, image_encoder)
else:
image_encoder_assets = None
def encode(one_batch: list[ItemInfo]):
encode_and_save_batch(vae, image_encoder_assets, one_batch, args.i2v)
cache_latents.encode_datasets(datasets, encode, args)
def hv1_5_setup_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
parser.add_argument(
"--vae_sample_size",
type=int,
default=128,
help="VAE sample size (height/width). Default 128; set 256 if VRAM is sufficient for better quality; set 0 to disable tiling.",
)
parser.add_argument(
"--vae_enable_patch_conv",
action="store_true",
help="Enable patch-based convolution in VAE for memory optimization",
)
parser.add_argument(
"--i2v",
action="store_true",
help="Cache image features and conditional latents for I2V training/inference",
)
parser.add_argument(
"--image_encoder", type=str, default=None, help="Directory/path of SigLIP Image Encoder (required if --i2v is set)"
)
return parser
if __name__ == "__main__":
main()
|