src/musubi_tuner/hv_1_5_cache_latents.py

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()