| 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") |
| |
| |
| 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") |
| |
| |
| 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") |
| |
| |
| 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") |
| |
| |
| 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.") |
| |
| |
| 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") |
| |
| |
| 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") |
| |
| |
| 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") |
| |
| |
| parser.add_argument("--weight_dtype", type=str, default="bfloat16", choices=["bfloat16", "float16", "float32"], |
| help="Weight dtype") |
| |
| |
| 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") |
| |
| |
| 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") |
| |
| |
| parser.add_argument("--save_path", type=str, default="samples/cogvideox-fun-videos_i2v", |
| help="Path to save generated videos") |
| |
| |
| 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') |
| |
| |
| 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() |
| |
| |
| 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 = args.gpu_memory_mode |
| |
| |
| |
| |
| ulysses_degree = args.ulysses_degree |
| ring_degree = args.ring_degree |
| |
| fsdp_dit = args.fsdp_dit |
| fsdp_text_encoder = args.fsdp_text_encoder |
| |
| |
| compile_dit = args.compile_dit |
| |
| |
| model_name = args.model_name |
| |
| |
| sampler_name = args.sampler_name |
| |
| |
| transformer_path = args.transformer_path |
| vae_path = args.vae_path |
| |
| |
| lilora_path = args.lilora_path |
| hypernetwork_path = args.hypernetwork_path |
| |
| |
| first_frame_path = args.first_frame_path |
| ref_video_path = args.ref_video_path |
| |
| |
| lora_rank = args.lora_rank |
| lora_down_dim = args.lora_down_dim |
| lora_up_dim = args.lora_up_dim |
| lora_weight = args.lora_weight |
| |
| |
| sample_size = [384, 672] |
| |
| |
| video_length = args.video_length |
| fps = args.fps |
| |
| |
| partial_video_length = args.partial_video_length |
| overlap_video_length = args.overlap_video_length |
| |
| |
| validation_image_start = None |
| validation_image_end = None |
| |
| |
| |
| |
| |
| if args.test_json_path is None: |
| 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] |
| 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") |
| |
| |
| |
| |
| ref_video_path = args.ref_video_path |
| |
| |
| 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 |
|
|
| |
| 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)}") |
|
|
| |
| 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)}") |
|
|
| |
| tokenizer = T5Tokenizer.from_pretrained( |
| model_name, subfolder="tokenizer" |
| ) |
| text_encoder = T5EncoderModel.from_pretrained( |
| model_name, subfolder="text_encoder", torch_dtype=weight_dtype |
| ) |
|
|
| |
| 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] |
| 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() |
|
|
