Blame for predict_i2v.py

import os
import sys
import argparse
import importlib.util
from pathlib import Path

import numpy as np
import torch
from diffusers import (CogVideoXDDIMScheduler, DDIMScheduler,
                       DPMSolverMultistepScheduler,
                       EulerAncestralDiscreteScheduler, EulerDiscreteScheduler,
                       PNDMScheduler)
from PIL import Image

current_file_path = os.path.abspath(__file__)
project_roots = [os.path.dirname(current_file_path), os.path.dirname(os.path.dirname(current_file_path)), os.path.dirname(os.path.dirname(os.path.dirname(current_file_path)))]
for project_root in project_roots:
    sys.path.insert(0, project_root) if project_root not in sys.path else None

from videox_fun.dist import set_multi_gpus_devices, shard_model
from videox_fun.models import (AutoencoderKLCogVideoX,
                              CogVideoXTransformer3DModel, T5EncoderModel,
                              T5Tokenizer)
from videox_fun.pipeline import (CogVideoXFunInpaintPipeline,
                                CogVideoXFunPipeline)
from videox_fun.data.dataset_image_video import (
    CAMERA_POSES_CSV_NAME,
    EMG_CONTEXT_SEC,
    compute_normalization_stats_from_participant,
    extract_emg_bbox_rows,
    frame_name_to_idx,
    list_frame_files,
    load_bimanual_signal_df,
    load_camera_pose_feature_df,
    load_camera_pose_time_dict,
    load_participant_bbox_df,
    relative_pose_to_features,
    resample_feature_window,
    zero_emg_bbox_rows,
    zero_head_pose_rows,
)
from videox_fun.utils.fp8_optimization import (convert_model_weight_to_float8, replace_parameters_by_name,
                                              convert_weight_dtype_wrapper)
from videox_fun.utils.lora_utils import create_network
from videox_fun.utils.utils import get_image_to_video_latent, save_videos_grid
from videox_fun.utils.hypernet import VideoHyperDream
import json


def load_module_from_path(module_name: str, module_path: str):
    spec = importlib.util.spec_from_file_location(module_name, module_path)
    module = importlib.util.module_from_spec(spec)
    assert spec.loader is not None
    spec.loader.exec_module(module)
    return module


class MultimodalReferenceEncoder(torch.nn.Module):
    def __init__(self, encoder_model: torch.nn.Module):
        super().__init__()
        self.encoder_model = encoder_model

    def forward(self, ref_values):
        emg_x = ref_values["emg_values"].float()
        hand_bbox_x = ref_values["hand_bbox_values"].float()
        head_pose_x = ref_values["head_pose_values"].float()

        hand_camera_x = torch.cat([hand_bbox_x, head_pose_x], dim=-1)
        emg_features = self.encoder_model.emg_encoder(emg_x)
        hand_camera_features = self.encoder_model.hand_camera_encoder(hand_camera_x)
        emg_features = torch.nn.functional.adaptive_avg_pool1d(
            emg_features.transpose(1, 2),
            hand_camera_features.shape[1],
        ).transpose(1, 2)
        fused = torch.cat([emg_features, hand_camera_features], dim=-2)
        return fused


def parse_args():
    parser = argparse.ArgumentParser(description="CogVideoX-Fun I2V Inference with LiLoRA and HyperNetwork")
    
    # GPU memory mode
    parser.add_argument("--gpu_memory_mode", type=str, default="model_full_load",
                       choices=["model_full_load", "model_full_load_and_qfloat8", "model_cpu_offload", 
                               "model_cpu_offload_and_qfloat8", "sequential_cpu_offload"],
                       help="GPU memory mode")
    
    # Multi GPUs config
    parser.add_argument("--ulysses_degree", type=int, default=1, help="Ulysses degree for multi-GPU inference")
    parser.add_argument("--ring_degree", type=int, default=1, help="Ring degree for multi-GPU inference")
    parser.add_argument("--fsdp_dit", action="store_true", help="Use FSDP for transformer")
    parser.add_argument("--fsdp_text_encoder", action="store_true", default=True, help="Use FSDP for text encoder")
    parser.add_argument("--compile_dit", action="store_true", help="Compile transformer for speedup")
    
    # Model paths
    parser.add_argument("--model_name", type=str, default="models/Diffusion_Transformer/CogVideoX-Fun-V1.1-2b-InP",
                       help="Path to pretrained model")
    parser.add_argument("--sampler_name", type=str, default="DDIM_Origin",
                       choices=["Euler", "Euler A", "DPM++", "PNDM", "DDIM_Cog", "DDIM_Origin"],
                       help="Sampler name")
    parser.add_argument("--transformer_path", type=str, default=None, help="Path to transformer checkpoint")
    parser.add_argument("--vae_path", type=str, default=None, help="Path to VAE checkpoint")
    
    # LiLoRA and HyperNetwork paths
    parser.add_argument("--lilora_path", type=str, default=None, help="Path to LiLoRA weights (.safetensors)")
    parser.add_argument("--hypernetwork_path", type=str, default=None, help="Path to HyperNetwork weights (.safetensors)")
    parser.add_argument("--hypernetwork_input_dim", type=int, default=None,
                       help="Override HyperNetwork input feature dimension. If unset, infer from checkpoint or multimodal encoder.")
    parser.add_argument("--multimodal_ref_encoder_ckpt_path", type=str, default=None,
                       help="Checkpoint for the EMG multimodal reference encoder used during training.")
    parser.add_argument("--multimodal_ref_encoder_script", type=str, default=None,
                       help="Python script that defines MultimodalEMGMaskedAutoencoder and load_emg2pose_backbone.")
    parser.add_argument("--emg2pose_ckpt_path", type=str, default=None,
                       help="Path to the EMG2Pose backbone checkpoint required by the multimodal reference encoder.")
    parser.add_argument("--emg2pose_repo", type=str, default=None,
                       help="Path to the EMG2Pose repository required by the multimodal reference encoder.")
    parser.add_argument("--emg_normalization_participant", type=str, default=None,
                       help="Participant directory used to compute EMG normalization stats when building ref_values from raw CSVs.")
    parser.add_argument("--emg_camera_pose_csv_name", type=str, default=CAMERA_POSES_CSV_NAME,
                       help="Camera pose CSV filename under each participant directory.")
    parser.add_argument("--emg_bbox_csv_name", type=str, default="hand_bboxes.csv",
                       help="Hand bbox CSV filename under each participant directory.")
    parser.add_argument("--emg_context_sec", type=float, default=EMG_CONTEXT_SEC,
                       help="Extra sensor context before/after the selected video clip.")
    
    # LiLoRA params (should match training config)
    parser.add_argument("--lora_rank", type=int, default=1, help="LiLoRA rank")
    parser.add_argument("--lora_down_dim", type=int, default=200, help="LiLoRA down dimension")
    parser.add_argument("--lora_up_dim", type=int, default=100, help="LiLoRA up dimension")
    parser.add_argument("--lora_weight", type=float, default=0.55, help="LiLoRA weight multiplier")
    
    # Input data paths
    parser.add_argument("--first_frame_path", type=str, default=None, help="Path to first frame image")
    parser.add_argument("--ref_video_path", type=str, default=None, help="Path to reference video for HyperNetwork")
    
    # Video generation params
    parser.add_argument("--video_length", type=int, default=49, help="Number of frames to generate")
    parser.add_argument("--fps", type=int, default=8, help="FPS for output video")
    parser.add_argument("--partial_video_length", type=int, default=None, 
                       help="Length of each sub video segment for ultra long video generation")
    parser.add_argument("--overlap_video_length", type=int, default=4, 
                       help="Overlap length between segments for ultra long video generation")
    
    # Weight dtype
    parser.add_argument("--weight_dtype", type=str, default="bfloat16", choices=["bfloat16", "float16", "float32"],
                       help="Weight dtype")
    
    # Prompts
    parser.add_argument("--prompt", type=str, default=None, help="Prompt for video generation")
    parser.add_argument("--negative_prompt", type=str, 
                       default="The video is not of a high quality, it has a low resolution. "
                               "Watermark present in each frame. The background is solid. "
                               "Strange body and strange trajectory. Distortion.",
                       help="Negative prompt")
    
    # Inference params
    parser.add_argument("--guidance_scale", type=float, default=6.0, help="Guidance scale")
    parser.add_argument("--seed", type=int, default=43, help="Random seed")
    parser.add_argument("--num_inference_steps", type=int, default=50, help="Number of inference steps")
    
    # Output
    parser.add_argument("--save_path", type=str, default="samples/cogvideox-fun-videos_i2v", 
                       help="Path to save generated videos")
    
    # Test set (JSON)
    parser.add_argument("--test_json_path", type=str, default=None, 
                       help="Path to JSON file containing test samples")
    
    return parser.parse_args()


def _resolve_path(path_value, base_dir=None):
    if path_value is None:
        return None
    if os.path.isabs(path_value):
        return path_value
    if base_dir is not None:
        candidate = os.path.join(base_dir, path_value)
        if os.path.exists(candidate):
            return candidate
    return os.path.abspath(path_value)


def _as_numpy_float32(value):
    if value is None:
        return None
    if torch.is_tensor(value):
        value = value.detach().cpu().numpy()
    return np.asarray(value, dtype=np.float32)


def _coerce_ref_values_dict(ref_values):
    if ref_values is None:
        return None

    required = ("emg_values", "hand_bbox_values", "head_pose_values")
    if not all(key in ref_values for key in required):
        missing = [key for key in required if key not in ref_values]
        raise ValueError(f"ref_values is missing required keys: {missing}")

    out = {}
    for key in required:
        out[key] = _as_numpy_float32(ref_values[key])
    return out


def _infer_participant_path(sample_info, first_frame_path):
    participant_path = sample_info.get("participant_path")
    if participant_path is not None:
        return participant_path

    if first_frame_path is None:
        return None

    frame_dir = os.path.dirname(first_frame_path)
    if os.path.basename(frame_dir) == "frames":
        return os.path.dirname(frame_dir)
    return os.path.dirname(first_frame_path)


def _infer_frame_indices(sample_info, first_frame_path, video_length):
    frame_indices = sample_info.get("frame_indices")
    if frame_indices is not None:
        return [int(x) for x in frame_indices]

    frame_dir = sample_info.get("frames_dir")
    if frame_dir is None and first_frame_path is not None:
        frame_dir = os.path.dirname(first_frame_path)

    if first_frame_path is None:
        return None

    try:
        start_idx = frame_name_to_idx(first_frame_path)
    except Exception:
        start_idx = None

    if frame_dir is not None and os.path.isdir(frame_dir):
        try:
            frame_paths = list_frame_files(frame_dir)
            filename_to_pos = {os.path.basename(path): idx for idx, path in enumerate(frame_paths)}
            start_pos = filename_to_pos.get(os.path.basename(first_frame_path))
            if start_pos is not None:
                selected = frame_paths[start_pos:start_pos + video_length]
                if len(selected) == video_length:
                    return [frame_name_to_idx(path) for path in selected]
        except Exception:
            pass

    if start_idx is not None:
        return [start_idx + i for i in range(video_length)]
    return None


def build_emg_ref_values(sample_info, first_frame_path, video_length, args):
    direct_ref_values = sample_info.get("ref_values")
    if direct_ref_values is not None:
        return _coerce_ref_values_dict(direct_ref_values)

    if all(key in sample_info for key in ("emg_values", "hand_bbox_values", "head_pose_values")):
        return _coerce_ref_values_dict(sample_info)

    participant_path = _infer_participant_path(sample_info, first_frame_path)
    frame_indices = _infer_frame_indices(sample_info, first_frame_path, video_length)
    if participant_path is None or frame_indices is None:
        return None

    participant_path = os.path.abspath(participant_path)
    pose_time_dict = load_camera_pose_time_dict(participant_path, args.emg_camera_pose_csv_name)
    hand_data, signal_cols = load_bimanual_signal_df(participant_path)

    clip_times = []
    for frame_idx in frame_indices:
        if frame_idx not in pose_time_dict:
            raise ValueError(f"Missing pose timestamp for frame_idx={frame_idx} in {participant_path}")
        clip_times.append(float(pose_time_dict[frame_idx]))

    sensor_start_t = min(clip_times) - args.emg_context_sec
    sensor_end_t = max(clip_times) + args.emg_context_sec

    emg_signal_length = int(sample_info.get("emg_fixed_signal_length") or sample_info.get("signal_length") or 1883)
    left_emg = resample_feature_window(
        hand_data["left_time"],
        hand_data["left_data"],
        sensor_start_t,
        sensor_end_t,
        emg_signal_length,
    )
    right_emg = resample_feature_window(
        hand_data["right_time"],
        hand_data["right_data"],
        sensor_start_t,
        sensor_end_t,
        emg_signal_length,
    )
    emg_values = np.concatenate([left_emg, right_emg], axis=1).astype(np.float32)

    norm_participant = args.emg_normalization_participant
    if norm_participant is not None:
        norm_participant = os.path.abspath(norm_participant)
        norm_mean, norm_std, _ = compute_normalization_stats_from_participant(norm_participant)
        emg_values = ((emg_values - norm_mean) / norm_std).astype(np.float32)

    try:
        bbox_df = load_participant_bbox_df(participant_path, args.emg_bbox_csv_name).set_index("frame_idx")
        bbox_values, _ = extract_emg_bbox_rows(bbox_df, frame_indices)
    except Exception:
        bbox_values, _ = zero_emg_bbox_rows(frame_indices)

    try:
        pose_df = load_camera_pose_feature_df(participant_path, args.emg_camera_pose_csv_name).set_index("frame_idx")
        if frame_indices[0] not in pose_df.index:
            raise ValueError(f"Reference frame {frame_indices[0]} missing from pose CSV")
        ref_row = pose_df.loc[frame_indices[0]]
        from videox_fun.data.dataset_image_video import pose_row_to_T

        T_ref = pose_row_to_T(ref_row["tx"], ref_row["ty"], ref_row["tz"], ref_row["qx"], ref_row["qy"], ref_row["qz"], ref_row["qw"])
        pose_rows = []
        for frame_idx in frame_indices:
            if frame_idx not in pose_df.index:
                raise ValueError(f"Frame {frame_idx} missing from pose CSV")
            row = pose_df.loc[frame_idx]
            T_curr = pose_row_to_T(row["tx"], row["ty"], row["tz"], row["qx"], row["qy"], row["qz"], row["qw"])
            pose_rows.append(relative_pose_to_features(T_ref, T_curr))
        head_pose_values = np.asarray(pose_rows, dtype=np.float32)
    except Exception:
        head_pose_values, _ = zero_head_pose_rows(frame_indices)

    return {
        "emg_values": emg_values.astype(np.float32),
        "hand_bbox_values": bbox_values.astype(np.float32),
        "head_pose_values": head_pose_values.astype(np.float32),
    }


def build_multimodal_ref_encoder(args, sample_ref_values, weight_dtype):
    missing = []
    if args.multimodal_ref_encoder_ckpt_path is None:
        missing.append("--multimodal_ref_encoder_ckpt_path")
    if args.multimodal_ref_encoder_script is None:
        missing.append("--multimodal_ref_encoder_script")
    if args.emg2pose_ckpt_path is None:
        missing.append("--emg2pose_ckpt_path")
    if args.emg2pose_repo is None:
        missing.append("--emg2pose_repo")
    if missing:
        raise ValueError(f"EMG-conditioned inference requires: {', '.join(missing)}")

    videox_module = load_module_from_path(
        "videox_emg_multimodal_infer",
        args.multimodal_ref_encoder_script,
    )
    checkpoint = torch.load(args.multimodal_ref_encoder_ckpt_path, map_location="cpu")
    checkpoint_config = checkpoint.get("config", {})

    emg_channels = int(sample_ref_values["emg_values"].shape[-1])
    bbox_channels = int(sample_ref_values["hand_bbox_values"].shape[-1])
    pose_channels = int(sample_ref_values["head_pose_values"].shape[-1])
    hand_camera_channels = bbox_channels + pose_channels
    seq_len = int(sample_ref_values["emg_values"].shape[0])

    emg_backbone = videox_module.load_emg2pose_backbone(
        str(args.emg2pose_ckpt_path),
        str(args.emg2pose_repo),
    )
    encoder_model = videox_module.MultimodalEMGMaskedAutoencoder(
        emg_channels=emg_channels,
        hand_camera_channels=hand_camera_channels,
        bbox_channels=bbox_channels,
        pose_channels=pose_channels,
        emg_backbone=emg_backbone,
        seq_len=seq_len,
        hidden_dim=checkpoint_config.get("hidden_dim", 256),
        latent_dim=checkpoint_config.get("latent_dim", 256),
        kernel_size=checkpoint_config.get("kernel_size", 3),
        dilation_rates=checkpoint_config.get("dilation_rates", [1, 2, 4, 8, 16, 32]),
        encoder_stacks=checkpoint_config.get("encoder_stacks", 3),
        decoder_stacks=checkpoint_config.get("decoder_stacks", 2),
        dropout=checkpoint_config.get("dropout", 0.1),
        derivative_loss_weight=checkpoint_config.get("derivative_loss_weight", 0.1),
        frequency_loss_weight=checkpoint_config.get("frequency_loss_weight", 0.05),
        high_freq_weight=checkpoint_config.get("high_freq_weight", 2.0),
    )
    encoder_model.load_state_dict(checkpoint["model"], strict=True)
    encoder_model.eval()
    encoder_model.requires_grad_(False)
    encoder_model = encoder_model.to(dtype=weight_dtype)
    return MultimodalReferenceEncoder(encoder_model), int(checkpoint_config.get("latent_dim", 256))


def get_hypernetwork_input_dim(args, hyper_state_dict, multimodal_input_dim=None):
    if args.hypernetwork_input_dim is not None:
        return int(args.hypernetwork_input_dim)
    if multimodal_input_dim is not None:
        return int(multimodal_input_dim)
    feature_proj_weight = hyper_state_dict.get("img_weight_generator.feature_proj.weight")
    if feature_proj_weight is None:
        raise ValueError("Could not infer HyperNetwork input dim from checkpoint. Please pass --hypernetwork_input_dim.")
    return int(feature_proj_weight.shape[1])


def apply_hypernetwork_weights(hypernetwork, lilora_network, ref_features):
    _, weight_list = hypernetwork(ref_features)
    for weight, lora_layer in zip(weight_list, lilora_network.unet_loras):
        if weight.dim() == 3:
            weight = weight.view(weight.size(0), -1)
        elif weight.dim() == 2:
            if weight.size(0) == 1:
                weight = weight.view(-1)
            else:
                weight = weight.view(weight.size(0), -1)
        elif weight.dim() == 1:
            weight = weight.view(-1)
        lora_layer.update_weight(weight)
        lora_layer.down_aux.data = lora_layer.down_aux.data.to(dtype=weight.dtype)
        lora_layer.up_aux.data = lora_layer.up_aux.data.to(dtype=weight.dtype)
    return len(weight_list)

def load_ref_video_frames(ref_video_path, target_size, num_frames=None):
    """
    Load reference video frames from video file or image directory
    
    Args:
        ref_video_path: Path to video file or directory containing image frames
        target_size: Target size [height, width] for resizing
        num_frames: Number of frames to load (if None, load all available)
    
    Returns:
        ref_pixel_values: Tensor of shape [B, F, C, H, W] in 0~1 range
    """
    import cv2
    
    target_h, target_w = target_size
    
    ref_frames = []
    
    if os.path.isfile(ref_video_path):
        cap = cv2.VideoCapture(ref_video_path)
        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        
        if num_frames is None:
            num_frames = frame_count
        
        for i in range(num_frames):
            ret, frame = cap.read()
            if not ret:
                break
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            frame = Image.fromarray(frame)
            frame = frame.resize((target_w, target_h))
            ref_frames.append(np.array(frame))
        
        cap.release()
    elif os.path.isdir(ref_video_path):
        image_files = sorted([f for f in os.listdir(ref_video_path) if f.endswith(('.png', '.jpg', '.jpeg'))])
        
        if num_frames is None:
            num_frames = len(image_files)
        
        for i in range(num_frames):
            if i >= len(image_files):
                break
            frame = Image.open(os.path.join(ref_video_path, image_files[i])).convert('RGB')
            frame = frame.resize((target_w, target_h))
            ref_frames.append(np.array(frame))
    
    if len(ref_frames) == 0:
        raise ValueError(f"No frames loaded from {ref_video_path}")
    
    ref_frames_np = np.array(ref_frames)
    ref_frames_tensor = torch.from_numpy(ref_frames_np).float()
    ref_frames_tensor = ref_frames_tensor / 255.0
    
    ref_frames_tensor = ref_frames_tensor.unsqueeze(0)
    
    print(f"DEBUG: ref_frames_tensor shape after unsqueeze(0): {ref_frames_tensor.shape}")
    
    return ref_frames_tensor


def get_model_device(model):
    """安全获取模型实际设备，处理 CPU offload 模式"""
    try:
        params = list(model.parameters())
        if len(params) > 0:
            return params[0].device
        buffers = list(model.buffers())
        if len(buffers) > 0:
            return buffers[0].device
    except Exception:
        pass
    return torch.device("cpu")


def process_sample(
    pipeline,
    vae,
    device,
    weight_dtype,
    hypernetwork,
    lilora_network,
    multimodal_ref_encoder,
    sample_info,
    sample_size,
    args,
):
    """
    Process a single test sample
    
    Args:
        pipeline: CogVideoX pipeline
        vae: VAE model
        device: device
        weight_dtype: weight dtype
        hypernetwork: VideoHyperDream model (or None)
        lilora_network: LoRANetwork model (or None)
        sample_info: dict with first_frame_path, ref_video_path, text, video_name
        sample_size: [height, width]
        args: other arguments
    
    Returns:
        sample: generated video tensor
    """
    first_frame_path = sample_info.get('first_frame_path')
    ref_video_path = sample_info.get('ref_video_path')
    prompt = sample_info.get('text', '')
    video_name = sample_info.get('video_name', 'sample')
    
    # 如果 JSON 中没有提供 prompt，使用命令行参数中的默认值
    if not prompt or not prompt.strip():
        prompt = args.get('prompt', '')
        if prompt:
            print(f"Using prompt from command line: {prompt[:50]}...")
        else:
            print(f"Warning: No prompt provided for sample {video_name}")
            return None
    
    if first_frame_path is None or not os.path.exists(first_frame_path):
        print(f"Warning: first_frame_path not found: {first_frame_path}")
        return None
    
    input_video, input_video_mask, clip_image = get_image_to_video_latent(
        first_frame_path, None, video_length=args['video_length'], sample_size=sample_size
    )
    
    original_image = Image.open(first_frame_path).convert('RGB')
    original_width, original_height = original_image.size
    print(f"\n[Debug Input Video Processing]")
    print(f"[Debug Input] first_frame_path: {first_frame_path}")
    print(f"[Debug Input] Original image size: ({original_width}, {original_height})")
    print(f"[Debug Input] sample_size (after resize): {sample_size}")
    print(f"[Debug Input] input_video type: {type(input_video)}")
    if isinstance(input_video, torch.Tensor):
        print(f"[Debug Input] input_video shape: {input_video.shape}")
        if input_video.dim() == 5:
            B, C, F, H, W = input_video.shape
            print(f"[Debug Input] Input tensor: B={B}, C={C}, F={F}, H={H}, W={W}")
            print(f"[Debug Input] Height matches sample_size[0]: {H == sample_size[0]}, Width matches sample_size[1]: {W == sample_size[1]}")
    if input_video_mask is not None and isinstance(input_video_mask, torch.Tensor):
        print(f"[Debug Input] input_video_mask shape: {input_video_mask.shape}")
    print("-" * 40)
    
    if hypernetwork is not None and lilora_network is not None:
        emg_ref_values = build_emg_ref_values(sample_info, first_frame_path, args['video_length'], args['cli_args'])

        if emg_ref_values is not None:
            if multimodal_ref_encoder is None:
                multimodal_ref_encoder, _ = build_multimodal_ref_encoder(
                    args["cli_args"],
                    emg_ref_values,
                    weight_dtype,
                )
                multimodal_ref_encoder = multimodal_ref_encoder.to(device=device, dtype=weight_dtype)
                multimodal_ref_encoder.eval()

            ref_inputs = {
                key: torch.from_numpy(value).unsqueeze(0).to(device=device, dtype=weight_dtype)
                for key, value in emg_ref_values.items()
            }
            with torch.no_grad():
                ref_features = multimodal_ref_encoder(ref_inputs)
            updated_layers = apply_hypernetwork_weights(hypernetwork, lilora_network, ref_features)
            print(
                f"Updated {updated_layers} LiLoRA layers with multimodal EMG reference features "
                f"from sample {video_name}."
            )
        elif ref_video_path is not None and os.path.exists(ref_video_path):
            print(f"Generating weights from reference video: {ref_video_path}")
            ref_frames_tensor = load_ref_video_frames(ref_video_path, sample_size)
            _, F, _, _, _ = ref_frames_tensor.shape
            ref_pixel_values = ref_frames_tensor.permute(0, 4, 1, 2, 3).contiguous()
            ref_pixel_values = ref_pixel_values.to(dtype=weight_dtype)

            with torch.no_grad():
                vae_device = get_model_device(vae)
                ref_pixel_values = ref_pixel_values.to(device=vae_device, dtype=weight_dtype)
                ref_features = vae.encode(ref_pixel_values).latent_dist.sample()
                ref_features = ref_features * vae.config.scaling_factor

            updated_layers = apply_hypernetwork_weights(hypernetwork, lilora_network, ref_features)
            print(f"Updated {updated_layers} LiLoRA layers with hypernetwork weights from {F} reference frames.")
    
    generator = torch.Generator(device=device).manual_seed(args.get('seed', 43))
    
    with torch.no_grad():
        sample = pipeline(
            prompt,
            num_frames=args['video_length'],
            negative_prompt=args.get('negative_prompt', ''),
            height=sample_size[0],
            width=sample_size[1],
            generator=generator,
            guidance_scale=args.get('guidance_scale', 6.0),
            num_inference_steps=args.get('num_inference_steps', 50),
            video=input_video,
            mask_video=input_video_mask
        ).videos

    print(f"\n[Debug Pipeline Output @ Inference]")
    print(f"[Debug Pipeline] Original image size: ({original_width}, {original_height})")
    print(f"[Debug Pipeline] Sample size requested: ({sample_size[0]}, {sample_size[1]})")
    print(f"[Debug Pipeline] Pipeline output shape: {sample.shape}")
    
    if isinstance(sample, torch.Tensor):
        if sample.dim() == 5:
            B, C, F, H, W = sample.shape
            print(f"[Debug Pipeline] Output tensor shape: B={B}, C={C}, F={F}, H={H}, W={W}")
            
            expected_H = original_height
            expected_W = original_width
            print(f"\n[Debug Size Verification]")
            print(f"[Debug] Comparing: Original image ({original_height}, {original_width}) vs Output video ({H}, {W})")
            
            if H == expected_H and W == expected_W:
                print(f"[Debug] ✓ Size MATCH! Output matches original image size")
            else:
                print(f"[Debug] ✗ Size MISMATCH!")
                print(f"[Debug]   Expected: ({expected_H}, {expected_W})")
                print(f"[Debug]   Got:      ({H}, {W})")
                print(f"[Debug]   Difference: H={H-expected_H} ({((H-expected_H)/expected_H*100):.1f}%), W={W-expected_W} ({((W-expected_W)/expected_W*100):.1f}%)")
            
            if H != expected_H or W != expected_W:
                print(f"\n[Debug Analysis]")
                print(f"[Debug] VAE config - scaling_factor: {vae.config.scaling_factor}")
                print(f"[Debug] VAE config - latent_channels: {vae.config.latent_channels}")
                if hasattr(vae, 'config') and hasattr(vae.config, 'decoder'):
                    print(f"[Debug] VAE decoder will upsample by factor of 4x or 8x")
        else:
            print(f"[Debug Pipeline] Unexpected tensor dimensions: {sample.dim()}")
    
    print("-" * 80)
    
    return sample

def main():
    args = parse_args()
    
    # Convert weight dtype string to torch dtype
    weight_dtype_map = {
        "bfloat16": torch.bfloat16,
        "float16": torch.float16,
        "float32": torch.float32
    }
    weight_dtype = weight_dtype_map.get(args.weight_dtype, torch.bfloat16)
    
    # GPU memory mode, which can be chosen in [model_full_load, model_full_load_and_qfloat8, model_cpu_offload, model_cpu_offload_and_qfloat8, sequential_cpu_offload].
    # model_full_load means that the entire model will be moved to the GPU.
    # 
    # model_full_load_and_qfloat8 means that the entire model will be moved to the GPU,
    # and the transformer model has been quantized to float8, which can save more GPU memory. 
    # 
    # model_cpu_offload means that the entire model will be moved to the CPU after use, which can save some GPU memory.
    # 
    # model_cpu_offload_and_qfloat8 indicates that the entire model will be moved to the CPU after use, 
    # and the transformer model has been quantized to float8, which can save more GPU memory. 
    # 
    # sequential_cpu_offload means that each layer of the model will be moved to the CPU after use, 
    # resulting in slower speeds but saving a large amount of GPU memory.
    GPU_memory_mode     = args.gpu_memory_mode
    # Multi GPUs config
    # Please ensure that the product of ulysses_degree and ring_degree equals the number of GPUs used. 
    # For example, if you are using 8 GPUs, you can set ulysses_degree = 2 and ring_degree = 4.
    # If you are using 1 GPU, you can set ulysses_degree = 1 and ring_degree = 1.
    ulysses_degree      = args.ulysses_degree
    ring_degree         = args.ring_degree
    # Use FSDP to save more GPU memory in multi gpus.
    fsdp_dit            = args.fsdp_dit
    fsdp_text_encoder   = args.fsdp_text_encoder
    # Compile will give a speedup in fixed resolution and need a little GPU memory. 
    # The compile_dit is not compatible with the fsdp_dit and sequential_cpu_offload.
    compile_dit         = args.compile_dit
    
    # Config and model path
    model_name          = args.model_name
    
    # Choose the sampler in "Euler" "Euler A" "DPM++" "PNDM" "DDIM_Cog" and "DDIM_Origin"
    sampler_name        = args.sampler_name
    
    # Load pretrained model if need
    transformer_path    = args.transformer_path
    vae_path            = args.vae_path
    
    # LiLoRA and HyperNetwork paths
    lilora_path         = args.lilora_path
    hypernetwork_path   = args.hypernetwork_path
    
    # Input data paths
    first_frame_path    = args.first_frame_path
    ref_video_path      = args.ref_video_path
    
    # LiLoRA params (should match training config)
    lora_rank           = args.lora_rank
    lora_down_dim       = args.lora_down_dim
    lora_up_dim         = args.lora_up_dim
    lora_weight         = args.lora_weight
    
    # Other params
    sample_size         = [384, 672]
    # V1.0 and V1.1 support up to 49 frames of video generation,
    # while V1.5 supports up to 85 frames.  
    video_length        = args.video_length
    fps                 = args.fps
    
    # If you want to generate ultra long videos, please set partial_video_length as the length of each sub video segment
    partial_video_length = args.partial_video_length
    overlap_video_length = args.overlap_video_length
    
    # If you want to generate from text, please set the validation_image_start = None and validation_image_end = None
    validation_image_start  = None  # Will be set from first_frame_path below
    validation_image_end    = None
    
    # Use first_frame_path for image-to-video generation
    # If first_frame_path is provided, it will be used as the starting frame
    # and sample_size will be set to match the first frame dimensions
    # Note: If test_json_path is provided, first_frame_path will be read from JSON
    if args.test_json_path is None:  # Only check when NOT using test JSON
        if first_frame_path is not None and os.path.exists(first_frame_path):
            first_frame = Image.open(first_frame_path).convert('RGB')
            W, H = first_frame.size
            sample_size = [H, W]  # PIL image.size is (W, H), sample_size should be [H, W]
            validation_image_start = first_frame_path
            validation_image_end = None
            print(f"Using first frame from: {first_frame_path}, sample_size: {sample_size}")
        else:
            raise ValueError("first_frame_path must be provided and exist for direct I2V inference")
    
    # HyperNetwork reference video path (required when using hypernetwork)
    # Reference video should be a video file path or a list of image frames
    # The reference video will be encoded by VAE and used by HyperNetwork to generate LiLoRA weights
    ref_video_path      = args.ref_video_path
    
    # prompts
    prompt                  = args.prompt
    negative_prompt         = args.negative_prompt
    guidance_scale          = args.guidance_scale
    seed                    = args.seed
    num_inference_steps     = args.num_inference_steps
    lora_weight             = args.lora_weight
    save_path               = args.save_path

    # 初始化多 GPU 设备
    device = set_multi_gpus_devices(ulysses_degree, ring_degree)

    transformer = CogVideoXTransformer3DModel.from_pretrained(
        model_name, 
        subfolder="transformer",
        low_cpu_mem_usage=True,
        torch_dtype=weight_dtype,
    ).to(weight_dtype)

    if transformer_path is not None:
        print(f"From checkpoint: {transformer_path}")
        if transformer_path.endswith("safetensors"):
            from safetensors.torch import load_file, safe_open
            state_dict = load_file(transformer_path)
        else:
            state_dict = torch.load(transformer_path, map_location="cpu")
        state_dict = state_dict["state_dict"] if "state_dict" in state_dict else state_dict

        m, u = transformer.load_state_dict(state_dict, strict=False)
        print(f"missing keys: {len(m)}, unexpected keys: {len(u)}")

    # Get Vae
    vae = AutoencoderKLCogVideoX.from_pretrained(
        model_name, 
        subfolder="vae"
    ).to(weight_dtype)
    
    vae.enable_tiling()

    if vae_path is not None:
        print(f"From checkpoint: {vae_path}")
        if vae_path.endswith("safetensors"):
            from safetensors.torch import load_file, safe_open
            state_dict = load_file(vae_path)
        else:
            state_dict = torch.load(vae_path, map_location="cpu")
        state_dict = state_dict["state_dict"] if "state_dict" in state_dict else state_dict

        m, u = vae.load_state_dict(state_dict, strict=False)
        print(f"missing keys: {len(m)}, unexpected keys: {len(u)}")

    # Get tokenizer and text_encoder
    tokenizer = T5Tokenizer.from_pretrained(
        model_name, subfolder="tokenizer"
    )
    text_encoder = T5EncoderModel.from_pretrained(
        model_name, subfolder="text_encoder", torch_dtype=weight_dtype
    )

    # Get Scheduler
    Chosen_Scheduler = scheduler_dict = {
        "Euler": EulerDiscreteScheduler,
        "Euler A": EulerAncestralDiscreteScheduler,
        "DPM++": DPMSolverMultistepScheduler, 
        "PNDM": PNDMScheduler,
        "DDIM_Cog": CogVideoXDDIMScheduler,
        "DDIM_Origin": DDIMScheduler,
    }[sampler_name]
    scheduler = Chosen_Scheduler.from_pretrained(
        model_name, 
        subfolder="scheduler"
    )

    if transformer.config.in_channels != vae.config.latent_channels:
        pipeline = CogVideoXFunInpaintPipeline(
            vae=vae,
            tokenizer=tokenizer,
            text_encoder=text_encoder,
            transformer=transformer,
            scheduler=scheduler,
        )
    else:
        pipeline = CogVideoXFunPipeline(
            vae=vae,
            tokenizer=tokenizer,
            text_encoder=text_encoder,
            transformer=transformer,
            scheduler=scheduler,
        )
    if ulysses_degree > 1 or ring_degree > 1:
        from functools import partial
        transformer.enable_multi_gpus_inference()
        if fsdp_dit:
            shard_fn = partial(shard_model, device_id=device, param_dtype=weight_dtype)
            pipeline.transformer = shard_fn(pipeline.transformer)
            print("Add FSDP DIT")
        if fsdp_text_encoder:
            shard_fn = partial(shard_model, device_id=device, param_dtype=weight_dtype)
            pipeline.text_encoder = shard_fn(pipeline.text_encoder)
            print("Add FSDP TEXT ENCODER")

    if compile_dit:
        for i in range(len(pipeline.transformer.transformer_blocks)):
            pipeline.transformer.transformer_blocks[i] = torch.compile(pipeline.transformer.transformer_blocks[i])
        print("Add Compile")

    if GPU_memory_mode == "sequential_cpu_offload":
        pipeline.enable_sequential_cpu_offload(device=device)
    elif GPU_memory_mode == "model_cpu_offload_and_qfloat8":
        convert_model_weight_to_float8(transformer, exclude_module_name=[], device=device)
        convert_weight_dtype_wrapper(transformer, weight_dtype)
        pipeline.enable_model_cpu_offload(device=device)
    elif GPU_memory_mode == "model_cpu_offload":
        pipeline.enable_model_cpu_offload(device=device)
    elif GPU_memory_mode == "model_full_load_and_qfloat8":
        convert_model_weight_to_float8(transformer, exclude_module_name=[], device=device)
        convert_weight_dtype_wrapper(transformer, weight_dtype)
        pipeline.to(device=device)
    else:
        pipeline.to(device=device)

    generator = torch.Generator(device=device).manual_seed(seed)

    lilora_network = None
    if lilora_path is not None:
        lora_weight_dim = (lora_down_dim + lora_up_dim) * lora_rank
        
        lilora_network = create_network(
            multiplier=lora_weight,
            network_dim=lora_rank,
            network_alpha=lora_weight,
            text_encoder=pipeline.text_encoder,
            transformer=pipeline.transformer,
            down_dim=lora_down_dim,
            up_dim=lora_up_dim,
            is_train=False,
        )
        lilora_network.apply_to(pipeline.text_encoder, pipeline.transformer, apply_text_encoder=False, apply_unet=True)
        
        from safetensors.torch import load_file
        lora_state_dict = load_file(lilora_path)
        info = lilora_network.load_weights(lilora_path)
        print(f"LiLoRA weights loaded from {lilora_path} (missing: {len(info.missing_keys)}, unexpected: {len(info.unexpected_keys)})")
        
        print(f"Total LoRA modules in UNet: {len(lilora_network.unet_loras)}")

    hypernetwork = None
    multimodal_ref_encoder = None
    if hypernetwork_path is not None and lilora_network is not None:
        from safetensors.torch import load_file
        
        lora_weight_dim = (lora_down_dim + lora_up_dim) * lora_rank
        weight_num = len(lilora_network.unet_loras)
        hyper_state_dict = load_file(hypernetwork_path)
        hypernetwork_input_dim = get_hypernetwork_input_dim(args, hyper_state_dict, None)
        
        print(
            f"Creating VideoHyperDream with weight_num={weight_num}, "
            f"weight_dim={lora_weight_dim}, video_feat_dim={hypernetwork_input_dim}"
        )
        
        hypernetwork = VideoHyperDream(
            video_feat_dim=hypernetwork_input_dim,
            weight_num=weight_num,
            weight_dim=lora_weight_dim,
        ).to(device=device, dtype=weight_dtype)
        
        hypernetwork.load_state_dict(hyper_state_dict, strict=False)
        hypernetwork.eval()
        
        if lilora_network is not None and len(lilora_network.unet_loras) > 0:
            hypernetwork.set_lilora(lilora_network.unet_loras)
            hypernetwork.set_device(device)
            print(f"HyperNetwork loaded. Connected to {len(lilora_network.unet_loras)} LiLoRA layers from create_network.")
        else:
            print("Warning: No LiLoRA layers found from create_network!")
            hypernetwork = None

    def save_results(sample, video_length, video_name=None):
        if not os.path.exists(save_path):
            os.makedirs(save_path, exist_ok=True)

        if video_name is None:
            index = len([path for path in os.listdir(save_path)]) + 1
            prefix = str(index).zfill(8)
            video_name = prefix

        if video_length == 1:
            video_path = os.path.join(save_path, video_name + ".png")

            image = sample[0, :, 0]
            image = image.transpose(0, 1).transpose(1, 2)
            image = (image * 255).numpy().astype(np.uint8)
            image = Image.fromarray(image)
            image.save(video_path)
        else:
            video_path = os.path.join(save_path, video_name + ".mp4")
            save_videos_grid(sample, video_path, fps=fps)
        
        print(f"Results saved to: {video_path}")
        return video_path

    def process_test_set():
        if args.test_json_path is None or not os.path.exists(args.test_json_path):
            print("No test JSON path provided or file not found.")
            return
        
        json_dir = os.path.dirname(os.path.abspath(args.test_json_path))
        
        with open(args.test_json_path, 'r') as f:
            test_data = json.load(f)
        
        if isinstance(test_data, list):
            samples = test_data
        elif isinstance(test_data, dict):
            samples = test_data.get('samples', [])
        else:
            print(f"Unknown test data format in {args.test_json_path}")
            return
        
        print(f"Processing {len(samples)} test samples...")
        
        for idx, sample_info in enumerate(samples):
            print(f"\n{'='*60}")
            print(f"Processing sample {idx + 1}/{len(samples)}: {sample_info.get('video_name', f'sample_{idx}')}")
            print(f"{'='*60}")
            
            try:
                sample_info_copy = sample_info.copy()
                sample_first_frame = _resolve_path(sample_info.get('first_frame_path'), json_dir)
                sample_ref_video_path = _resolve_path(sample_info.get('ref_video_path'), json_dir)
                sample_participant_path = _resolve_path(sample_info.get('participant_path'), json_dir)

                if sample_first_frame:
                    if os.path.exists(sample_first_frame):
                        first_frame = Image.open(sample_first_frame).convert('RGB')
                        W, H = first_frame.size
                        current_sample_size = [H, W]  # PIL image.size is (W, H), sample_size should be [H, W]
                        print(f"Dynamic sample_size: {current_sample_size}")
                        
                        sample_info_copy['first_frame_path'] = sample_first_frame
                    else:
                        raise FileNotFoundError(f"first_frame_path not found: {sample_first_frame}")
                else:
                    raise ValueError("first_frame_path must be provided for I2V inference")
                
                if sample_ref_video_path is not None:
                    sample_info_copy['ref_video_path'] = sample_ref_video_path
                if sample_participant_path is not None:
                    sample_info_copy['participant_path'] = sample_participant_path
                
                sample_args = {
                    'video_length': args.video_length,
                    'seed': args.seed + idx,
                    'negative_prompt': args.negative_prompt,
                    'guidance_scale': args.guidance_scale,
                    'num_inference_steps': args.num_inference_steps,
                    'prompt': args.prompt,
                    'cli_args': args,
                }
                
                sample = process_sample(
                    pipeline=pipeline,
                    vae=vae,
                    device=device,
                    weight_dtype=weight_dtype,
                    hypernetwork=hypernetwork,
                    lilora_network=lilora_network,
                    multimodal_ref_encoder=multimodal_ref_encoder,
                    sample_info=sample_info_copy,
                    sample_size=current_sample_size,
                    args=sample_args
                )
                
                if sample is not None:
                    video_name = sample_info.get('video_name', f'sample_{idx}')
                    save_results(sample, sample_args['video_length'], video_name)
                else:
                    print(f"Skipping sample {idx + 1} due to missing first frame.")
                
            except Exception as e:
                print(f"Error processing sample {idx + 1}: {str(e)}")
                import traceback
                traceback.print_exc()
        
        print(f"\nAll {len(samples)} samples processed.")

    if args.test_json_path is not None:
        process_test_set()
    else:
        if partial_video_length is not None:
            partial_video_length = int((partial_video_length - 1) // vae.config.temporal_compression_ratio * vae.config.temporal_compression_ratio) + 1 if video_length != 1 else 1
            latent_frames = (partial_video_length - 1) // vae.config.temporal_compression_ratio + 1
            if partial_video_length != 1 and transformer.config.patch_size_t is not None and latent_frames % transformer.config.patch_size_t != 0:
                additional_frames = transformer.config.patch_size_t - latent_frames % transformer.config.patch_size_t
                partial_video_length += additional_frames * vae.config.temporal_compression_ratio
                
            init_frames = 0
            last_frames = init_frames + partial_video_length
            while init_frames < video_length:
                if last_frames >= video_length:
                    _partial_video_length = video_length - init_frames
                    _partial_video_length = int((_partial_video_length - 1) // vae.config.temporal_compression_ratio * vae.config.temporal_compression_ratio) + 1
                    latent_frames = (_partial_video_length - 1) // vae.config.temporal_compression_ratio + 1
                    if _partial_video_length != 1 and transformer.config.patch_size_t is not None and latent_frames % transformer.config.patch_size_t != 0:
                        additional_frames = transformer.config.patch_size_t - latent_frames % transformer.config.patch_size_t
                        _partial_video_length += additional_frames * vae.config.temporal_compression_ratio

                    if _partial_video_length <= 0:
                        break
                else:
                    _partial_video_length = partial_video_length

                input_video, input_video_mask, clip_image = get_image_to_video_latent(validation_image, None, video_length=_partial_video_length, sample_size=sample_size)
                
                if hypernetwork is not None and ref_video_path is not None and init_frames == 0:
                    print(f"Loading reference video from {ref_video_path}...")
                    ref_frames_tensor = load_ref_video_frames(ref_video_path, sample_size)
                    _, F, _, _, _ = ref_frames_tensor.shape
                    ref_pixel_values = ref_frames_tensor.permute(0, 4, 1, 2, 3).contiguous()

                    with torch.no_grad():
                        vae_device = get_model_device(vae)
                        ref_pixel_values = ref_pixel_values.to(device=vae_device, dtype=weight_dtype)
                        ref_features = vae.encode(ref_pixel_values).latent_dist.sample()
                        ref_features = ref_features * vae.config.scaling_factor

                    updated_layers = apply_hypernetwork_weights(hypernetwork, lilora_network, ref_features)
                    print(f"Updated {updated_layers} LiLoRA layers with hypernetwork weights from {F} reference frames.")
                
                with torch.no_grad():
                    sample = pipeline(
                        args.prompt, 
                        num_frames = _partial_video_length,
                        negative_prompt = negative_prompt,
                        height      = sample_size[0],
                        width       = sample_size[1],
                        generator   = generator,
                        guidance_scale = guidance_scale,
                        num_inference_steps = num_inference_steps,

                        video        = input_video,
                        mask_video   = input_video_mask
                    ).videos
                
                if init_frames != 0:
                    mix_ratio = torch.from_numpy(
                        np.array([float(_index) / float(overlap_video_length) for _index in range(overlap_video_length)], np.float32)
                    ).unsqueeze(0).unsqueeze(0).unsqueeze(-1).unsqueeze(-1)
                    
                    new_sample[:, :, -overlap_video_length:] = new_sample[:, :, -overlap_video_length:] * (1 - mix_ratio) + \
                        sample[:, :, :overlap_video_length] * mix_ratio
                    new_sample = torch.cat([new_sample, sample[:, :, overlap_video_length:]], dim = 2)

                    sample = new_sample
                else:
                    new_sample = sample

                if last_frames >= video_length:
                    break

                validation_image = [
                    Image.fromarray(
                        (sample[0, :, _index].transpose(0, 1).transpose(1, 2) * 255).numpy().astype(np.uint8)
                    ) for _index in range(-overlap_video_length, 0)
                ]

                init_frames = init_frames + _partial_video_length - overlap_video_length
                last_frames = init_frames + _partial_video_length
        else:
            video_length = int((video_length - 1) // vae.config.temporal_compression_ratio * vae.config.temporal_compression_ratio) + 1 if video_length != 1 else 1
        latent_frames = (video_length - 1) // vae.config.temporal_compression_ratio + 1
        if video_length != 1 and transformer.config.patch_size_t is not None and latent_frames % transformer.config.patch_size_t != 0:
            additional_frames = transformer.config.patch_size_t - latent_frames % transformer.config.patch_size_t
            video_length += additional_frames * vae.config.temporal_compression_ratio
        input_video, input_video_mask, clip_image = get_image_to_video_latent(validation_image_start, validation_image_end, video_length=video_length, sample_size=sample_size)

        if hypernetwork is not None and ref_video_path is not None:
            print(f"Loading reference video from {ref_video_path}...")
            ref_frames_tensor = load_ref_video_frames(ref_video_path, sample_size)
            _, F, _, _, _ = ref_frames_tensor.shape
            ref_pixel_values = ref_frames_tensor.permute(0, 4, 1, 2, 3).contiguous()

            with torch.no_grad():
                vae_device = get_model_device(vae)
                ref_pixel_values = ref_pixel_values.to(device=vae_device, dtype=weight_dtype)
                ref_features = vae.encode(ref_pixel_values).latent_dist.sample()
                ref_features = ref_features * vae.config.scaling_factor

            updated_layers = apply_hypernetwork_weights(hypernetwork, lilora_network, ref_features)
            print(f"Updated {updated_layers} LiLoRA layers with hypernetwork weights from {F} reference frames.")

        with torch.no_grad():
            sample = pipeline(
                args.prompt, 
                num_frames = video_length,
                negative_prompt = negative_prompt,
                height      = sample_size[0],
                width       = sample_size[1],
                generator   = generator,
                guidance_scale = guidance_scale,
                num_inference_steps = num_inference_steps,

                video        = input_video,
                mask_video   = input_video_mask
            ).videos

    if args.test_json_path is not None:
        process_test_set()
    else:
        if ulysses_degree * ring_degree > 1:
            import torch.distributed as dist
            if dist.get_rank() == 0:
                save_results(sample, video_length)
        else:
            save_results(sample, video_length)

if __name__ == "__main__":
    main()