Upload 2 files

predict_i2v.py

@@ -0,0 +1,1170 @@
+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()

run_predict_i2v.sh

@@ -0,0 +1,353 @@
+#!/bin/bash
+
+# CogVideoX-Fun I2V Inference Script
+# Usage: bash run_predict_i2v.sh [OPTIONS]
+
+# =============================================================================
+# 基础设置 (Basic Settings)
+# =============================================================================
+export CUDA_VISIBLE_DEVICES=6
+export PYTHONPATH="/home/xhm001/Desktop/Code/VideoX-Fun-main:${PYTHONPATH}"
+
+# 模型路径 (Model Path)
+MODEL_NAME="/home/xhm001/Desktop/Code/VideoX-Fun-main/models/cogvideoxfun/models--alibaba-pai--CogVideoX-Fun-V1.1-5b-InP"
+
+# =============================================================================
+# LiLoRA 和 HyperNetwork 路径 (LiLoRA & HyperNetwork Paths)
+# =============================================================================
+# LiLoRA 权重路径
+LILORA_PATH="/home/xhm001/Desktop/Code/VideoX-Fun-main/Hyper_150/checkpoint-14800/checkpoint-checkpoint-14800.safetensors"
+
+# HyperNetwork 权重路径
+HYPERNETWORK_PATH="/home/xhm001/Desktop/Code/VideoX-Fun-main/Hyper_150/checkpoint-14800/hypernetwork.safetensors"
+
+# EMG 多模态参考编码器路径
+MULTIMODAL_REF_ENCODER_CKPT_PATH=None
+MULTIMODAL_REF_ENCODER_SCRIPT=None
+EMG2POSE_CKPT_PATH=None
+EMG2POSE_REPO=None
+HYPERNETWORK_INPUT_DIM=None
+EMG_NORMALIZATION_PARTICIPANT=None
+
+# LiLoRA 训练参数 (应与训练配置匹配)
+LORA_RANK=1
+LORA_DOWN_DIM=100
+LORA_UP_DIM=50
+LORA_WEIGHT=1
+
+
+# =============================================================================
+# 输入数据路径 (Input Data Paths)
+# =============================================================================
+# 注意：当使用 --test_json_path 时，以下参数会从 JSON 中读取
+# 单样本推理时，可以手动指定以下参数
+
+# 首帧图像路径 (用于图像到视频生成)
+FIRST_FRAME_PATH=None
+
+# 参考视频路径 (用于 HyperNetwork 生成权重)
+REF_VIDEO_PATH=None
+
+# 测试集 JSON 路径 (可选，批量处理时使用)
+TEST_JSON_PATH=/home/xhm001/Desktop/Code/VideoX-Fun-main/Open_VFX_for_evl/cake.json
+
+# =============================================================================
+# 视频生成参数 (Video Generation Parameters)
+# =============================================================================
+VIDEO_LENGTH=49
+FPS=8
+PARTIAL_VIDEO_LENGTH=None
+OVERLAP_VIDEO_LENGTH=4
+
+# =============================================================================
+# 推理参数 (Inference Parameters)
+# =============================================================================
+# 注意：当使用 --test_json_path 时，以下参数会从 JSON 中读取
+PROMPT=None
+NEGATIVE_PROMPT="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."
+GUIDANCE_SCALE=6.0
+SEED=43
+NUM_INFERENCE_STEPS=50
+
+# =============================================================================
+# GPU 设置 (GPU Settings)
+# =============================================================================
+# GPU 内存模式: model_full_load, model_full_load_and_qfloat8, model_cpu_offload, model_cpu_offload_and_qfloat8, sequential_cpu_offload
+GPU_MEMORY_MODE="model_full_load"
+
+# 多 GPU 设置
+ULYSSES_DEGREE=1
+RING_DEGREE=1
+FSPD_DIT=False
+FSPD_TEXT_ENCODER=False
+COMPILE_DIT=False
+
+# 权重数据类型: bfloat16, float16, float32
+WEIGHT_DTYPE="bfloat16"
+
+# =============================================================================
+# 采样器选择 (Sampler Selection)
+# =============================================================================
+# 可选: Euler, Euler A, DPM++, PNDM, DDIM_Cog, DDIM_Origin
+SAMPLER_NAME="DDIM_Origin"
+
+# =============================================================================
+# 输出路径 (Output Path)
+# =============================================================================
+SAVE_PATH="samples/ALL"
+
+# =============================================================================
+# 解析命令行参数 (Parse Command Line Arguments)
+# =============================================================================
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --model_name)
+            MODEL_NAME="$2"
+            shift 2
+            ;;
+        --lilora_path)
+            LILORA_PATH="$2"
+            shift 2
+            ;;
+        --hypernetwork_path)
+            HYPERNETWORK_PATH="$2"
+            shift 2
+            ;;
+        --multimodal_ref_encoder_ckpt_path)
+            MULTIMODAL_REF_ENCODER_CKPT_PATH="$2"
+            shift 2
+            ;;
+        --multimodal_ref_encoder_script)
+            MULTIMODAL_REF_ENCODER_SCRIPT="$2"
+            shift 2
+            ;;
+        --emg2pose_ckpt_path)
+            EMG2POSE_CKPT_PATH="$2"
+            shift 2
+            ;;
+        --emg2pose_repo)
+            EMG2POSE_REPO="$2"
+            shift 2
+            ;;
+        --hypernetwork_input_dim)
+            HYPERNETWORK_INPUT_DIM="$2"
+            shift 2
+            ;;
+        --emg_normalization_participant)
+            EMG_NORMALIZATION_PARTICIPANT="$2"
+            shift 2
+            ;;
+        --first_frame_path)
+            FIRST_FRAME_PATH="$2"
+            shift 2
+            ;;
+        --ref_video_path)
+            REF_VIDEO_PATH="$2"
+            shift 2
+            ;;
+        --test_json_path)
+            TEST_JSON_PATH="$2"
+            shift 2
+            ;;
+        --video_length)
+            VIDEO_LENGTH="$2"
+            shift 2
+            ;;
+        --fps)
+            FPS="$2"
+            shift 2
+            ;;
+        --prompt)
+            PROMPT="$2"
+            shift 2
+            ;;
+        --negative_prompt)
+            NEGATIVE_PROMPT="$2"
+            shift 2
+            ;;
+        --guidance_scale)
+            GUIDANCE_SCALE="$2"
+            shift 2
+            ;;
+        --seed)
+            SEED="$2"
+            shift 2
+            ;;
+        --num_inference_steps)
+            NUM_INFERENCE_STEPS="$2"
+            shift 2
+            ;;
+        --lora_rank)
+            LORA_RANK="$2"
+            shift 2
+            ;;
+        --lora_down_dim)
+            LORA_DOWN_DIM="$2"
+            shift 2
+            ;;
+        --lora_up_dim)
+            LORA_UP_DIM="$2"
+            shift 2
+            ;;
+        --lora_weight)
+            LORA_WEIGHT="$2"
+            shift 2
+            ;;
+        --save_path)
+            SAVE_PATH="$2"
+            shift 2
+            ;;
+        --gpu_memory_mode)
+            GPU_MEMORY_MODE="$2"
+            shift 2
+            ;;
+        --weight_dtype)
+            WEIGHT_DTYPE="$2"
+            shift 2
+            ;;
+        --sampler_name)
+            SAMPLER_NAME="$2"
+            shift 2
+            ;;
+        --ulysses_degree)
+            ULYSSES_DEGREE="$2"
+            shift 2
+            ;;
+        --ring_degree)
+            RING_DEGREE="$2"
+            shift 2
+            ;;
+        --partial_video_length)
+            PARTIAL_VIDEO_LENGTH="$2"
+            shift 2
+            ;;
+        --overlap_video_length)
+            OVERLAP_VIDEO_LENGTH="$2"
+            shift 2
+            ;;
+        --help|-h)
+            echo "Usage: bash run_predict_i2v.sh [OPTIONS]"
+            echo ""
+            echo "Options:"
+            echo "  --model_name            模型路径 (默认: models/Diffusion_Transformer/CogVideoX-Fun-V1.1-2b-InP)"
+            echo "  --lilora_path           LiLoRA 权重路径"
+            echo "  --hypernetwork_path     HyperNetwork 权重路径"
+            echo "  --multimodal_ref_encoder_ckpt_path EMG 多模态参考编码器 checkpoint"
+            echo "  --multimodal_ref_encoder_script    EMG 多模态参考编码器脚本"
+            echo "  --emg2pose_ckpt_path    EMG2Pose checkpoint"
+            echo "  --emg2pose_repo         EMG2Pose repo 路径"
+            echo "  --hypernetwork_input_dim HyperNetwork 输入维度"
+            echo "  --emg_normalization_participant EMG 归一化参与者目录"
+            echo "  --first_frame_path      首帧图像路径"
+            echo "  --ref_video_path        参考视频路径 (用于 HyperNetwork)"
+            echo "  --test_json_path        测试集 JSON 路径"
+            echo "  --video_length          生成视频帧数 (默认: 49)"
+            echo "  --fps                   输出视频 FPS (默认: 8)"
+            echo "  --prompt                生成提示词"
+            echo "  --negative_prompt       负向提示词"
+            echo "  --guidance_scale        引导 scale (默认: 6.0)"
+            echo "  --seed                  随机种子 (默认: 43)"
+            echo "  --num_inference_steps   推理步数 (默认: 50)"
+            echo "  --lora_rank             LoRA rank (默认: 1)"
+            echo "  --lora_down_dim         LoRA down dimension (默认: 200)"
+            echo "  --lora_up_dim           LoRA up dimension (默认: 100)"
+            echo "  --lora_weight           LoRA 权重 (默认: 0.55)"
+            echo "  --save_path             输出路径 (默认: samples/cogvideox-fun-videos_i2v)"
+            echo "  --gpu_memory_mode       GPU 内存模式"
+            echo "  --weight_dtype          权重数据类型"
+            echo "  --sampler_name          采样器名称"
+            echo "  --help                  显示帮助信息"
+            exit 0
+            ;;
+        *)
+            echo "Unknown option: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# =============================================================================
+# 构建命令行参数 (Build Command Line Arguments)
+# =============================================================================
+PYTHON_ARGS=()
+
+# GPU 设置
+PYTHON_ARGS+=("--gpu_memory_mode" "${GPU_MEMORY_MODE}")
+PYTHON_ARGS+=("--ulysses_degree" "${ULYSSES_DEGREE}")
+PYTHON_ARGS+=("--ring_degree" "${RING_DEGREE}")
+
+[[ "${FSPD_DIT}" == "True" ]] && PYTHON_ARGS+=("--fsdp_dit")
+[[ "${FSPD_TEXT_ENCODER}" == "True" ]] && PYTHON_ARGS+=("--fsdp_text_encoder")
+[[ "${COMPILE_DIT}" == "True" ]] && PYTHON_ARGS+=("--compile_dit")
+
+# 模型设置
+PYTHON_ARGS+=("--model_name" "${MODEL_NAME}")
+PYTHON_ARGS+=("--sampler_name" "${SAMPLER_NAME}")
+
+# LiLoRA 和 HyperNetwork
+[[ -n "${LILORA_PATH}" && "${LILORA_PATH}" != "None" ]] && PYTHON_ARGS+=("--lilora_path" "${LILORA_PATH}")
+[[ -n "${HYPERNETWORK_PATH}" && "${HYPERNETWORK_PATH}" != "None" ]] && PYTHON_ARGS+=("--hypernetwork_path" "${HYPERNETWORK_PATH}")
+[[ -n "${MULTIMODAL_REF_ENCODER_CKPT_PATH}" && "${MULTIMODAL_REF_ENCODER_CKPT_PATH}" != "None" ]] && PYTHON_ARGS+=("--multimodal_ref_encoder_ckpt_path" "${MULTIMODAL_REF_ENCODER_CKPT_PATH}")
+[[ -n "${MULTIMODAL_REF_ENCODER_SCRIPT}" && "${MULTIMODAL_REF_ENCODER_SCRIPT}" != "None" ]] && PYTHON_ARGS+=("--multimodal_ref_encoder_script" "${MULTIMODAL_REF_ENCODER_SCRIPT}")
+[[ -n "${EMG2POSE_CKPT_PATH}" && "${EMG2POSE_CKPT_PATH}" != "None" ]] && PYTHON_ARGS+=("--emg2pose_ckpt_path" "${EMG2POSE_CKPT_PATH}")
+[[ -n "${EMG2POSE_REPO}" && "${EMG2POSE_REPO}" != "None" ]] && PYTHON_ARGS+=("--emg2pose_repo" "${EMG2POSE_REPO}")
+[[ -n "${HYPERNETWORK_INPUT_DIM}" && "${HYPERNETWORK_INPUT_DIM}" != "None" ]] && PYTHON_ARGS+=("--hypernetwork_input_dim" "${HYPERNETWORK_INPUT_DIM}")
+[[ -n "${EMG_NORMALIZATION_PARTICIPANT}" && "${EMG_NORMALIZATION_PARTICIPANT}" != "None" ]] && PYTHON_ARGS+=("--emg_normalization_participant" "${EMG_NORMALIZATION_PARTICIPANT}")
+
+# LiLoRA 参数
+PYTHON_ARGS+=("--lora_rank" "${LORA_RANK}")
+PYTHON_ARGS+=("--lora_down_dim" "${LORA_DOWN_DIM}")
+PYTHON_ARGS+=("--lora_up_dim" "${LORA_UP_DIM}")
+[[ -n "${LORA_WEIGHT}" && "${LORA_WEIGHT}" != "None" ]] && PYTHON_ARGS+=("--lora_weight" "${LORA_WEIGHT}")
+
+# 视频参数
+PYTHON_ARGS+=("--video_length" "${VIDEO_LENGTH}")
+PYTHON_ARGS+=("--fps" "${FPS}")
+[[ -n "${PARTIAL_VIDEO_LENGTH}" && "${PARTIAL_VIDEO_LENGTH}" != "None" ]] && PYTHON_ARGS+=("--partial_video_length" "${PARTIAL_VIDEO_LENGTH}")
+PYTHON_ARGS+=("--overlap_video_length" "${OVERLAP_VIDEO_LENGTH}")
+
+# 权重类型
+PYTHON_ARGS+=("--weight_dtype" "${WEIGHT_DTYPE}")
+
+# 推理参数 (单样本时使用，批量时从 JSON 读取)
+if [[ -z "${TEST_JSON_PATH}" || "${TEST_JSON_PATH}" == "None" ]]; then
+    [[ -n "${FIRST_FRAME_PATH}" && "${FIRST_FRAME_PATH}" != "None" ]] && PYTHON_ARGS+=("--first_frame_path" "${FIRST_FRAME_PATH}")
+    [[ -n "${REF_VIDEO_PATH}" && "${REF_VIDEO_PATH}" != "None" ]] && PYTHON_ARGS+=("--ref_video_path" "${REF_VIDEO_PATH}")
+    [[ -n "${PROMPT}" && "${PROMPT}" != "None" ]] && PYTHON_ARGS+=("--prompt" "${PROMPT}")
+    PYTHON_ARGS+=("--negative_prompt" "${NEGATIVE_PROMPT}")
+    PYTHON_ARGS+=("--guidance_scale" "${GUIDANCE_SCALE}")
+    PYTHON_ARGS+=("--seed" "${SEED}")
+    PYTHON_ARGS+=("--num_inference_steps" "${NUM_INFERENCE_STEPS}")
+else
+    PYTHON_ARGS+=("--test_json_path" "${TEST_JSON_PATH}")
+fi
+
+# 输出路径
+PYTHON_ARGS+=("--save_path" "${SAVE_PATH}")
+
+# =============================================================================
+# 运行推理脚本 (Run Inference Script)
+# =============================================================================
+echo "========================================"
+echo "CogVideoX-Fun I2V Inference"
+echo "========================================"
+echo "Model: ${MODEL_NAME}"
+echo "LiLoRA: ${LILORA_PATH}"
+echo "HyperNetwork: ${HYPERNETWORK_PATH}"
+echo "Multimodal Ref Encoder: ${MULTIMODAL_REF_ENCODER_CKPT_PATH}"
+echo "Video Length: ${VIDEO_LENGTH}"
+if [[ -n "${TEST_JSON_PATH}" && "${TEST_JSON_PATH}" != "None" ]]; then
+    echo "Test Set: ${TEST_JSON_PATH}"
+else
+    echo "First Frame: ${FIRST_FRAME_PATH}"
+    echo "Prompt: ${PROMPT}"
+fi
+echo "========================================"
+
+torchrun --nproc-per-node=1 --master_port=29501\
+    /home/xhm001/Desktop/Code/VideoX-Fun-main/examples/cogvideox_fun/predict_i2v.py \
+    "${PYTHON_ARGS[@]}"
+
+
+echo ""
+echo "Inference completed!"