#!/usr/bin/env python3 import argparse import json import os import random import sys from pathlib import Path import matplotlib.pyplot as plt import numpy as np import torch from torch.utils.data import DataLoader, RandomSampler CURRENT_FILE_PATH = os.path.abspath(__file__) PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(CURRENT_FILE_PATH))) if PROJECT_ROOT not in sys.path: sys.path.insert(0, PROJECT_ROOT) from videox_fun.data.dataset_image_video import ImageVideoControlDataset, ImageVideoSampler def set_seed(seed): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) def to_serializable(value): if isinstance(value, torch.Tensor): return value.detach().cpu().tolist() if isinstance(value, np.ndarray): return value.tolist() if isinstance(value, Path): return str(value) if isinstance(value, (list, tuple)): return [to_serializable(v) for v in value] if isinstance(value, dict): return {str(k): to_serializable(v) for k, v in value.items()} return value def parse_args(): parser = argparse.ArgumentParser(description="Inspect EMG control dataloader outputs.") parser.add_argument("--config_path", type=str, default=None) parser.add_argument("--pretrained_model_name_or_path", type=str, default=None) parser.add_argument("--train_data_dir", type=str, default=None) parser.add_argument("--train_data_meta", type=str, required=True) parser.add_argument("--image_sample_size", type=int, default=640) parser.add_argument("--video_sample_size", type=int, default=640) parser.add_argument("--token_sample_size", type=int, default=640) parser.add_argument("--video_sample_stride", type=int, default=1) parser.add_argument("--video_sample_n_frames", type=int, default=81) parser.add_argument("--train_batch_size", type=int, default=1) parser.add_argument("--video_repeat", type=int, default=1) parser.add_argument("--gradient_accumulation_steps", type=int, default=1) parser.add_argument("--dataloader_num_workers", type=int, default=0) parser.add_argument("--num_train_epochs", type=int, default=100) parser.add_argument("--checkpointing_steps", type=int, default=50) parser.add_argument("--learning_rate", type=float, default=2e-5) parser.add_argument("--lr_scheduler", type=str, default="constant_with_warmup") parser.add_argument("--lr_warmup_steps", type=int, default=100) parser.add_argument("--seed", type=int, default=42) parser.add_argument("--output_dir", type=str, required=True) parser.add_argument("--gradient_checkpointing", action="store_true") parser.add_argument("--mixed_precision", type=str, default="bf16") parser.add_argument("--adam_weight_decay", type=float, default=3e-2) parser.add_argument("--adam_epsilon", type=float, default=1e-10) parser.add_argument("--vae_mini_batch", type=int, default=1) parser.add_argument("--max_grad_norm", type=float, default=0.05) parser.add_argument("--random_hw_adapt", action="store_true") parser.add_argument("--training_with_video_token_length", action="store_true") parser.add_argument("--uniform_sampling", action="store_true") parser.add_argument("--low_vram", action="store_true") parser.add_argument("--train_mode", type=str, default="control_ref") parser.add_argument("--control_ref_image", type=str, default="random") parser.add_argument("--add_full_ref_image_in_self_attention", action="store_true") parser.add_argument("--trainable_modules", type=str, default=".") parser.add_argument("--enable_bucket", action="store_true") parser.add_argument("--max_batches", type=int, default=12) parser.add_argument("--fps", type=int, default=12) return parser.parse_args() def worker_init_fn(base_seed): def _worker_init_fn(worker_id): np.random.seed(base_seed * 256 + worker_id) random.seed(base_seed * 256 + worker_id) return _worker_init_fn def save_video_frames(video_tensor, out_dir, prefix="frame"): """ video_tensor: [C, F, H, W] on CPU or numpy saves PNGs: frame_0000.png, frame_0001.png, ... """ os.makedirs(out_dir, exist_ok=True) if isinstance(video_tensor, torch.Tensor): video_tensor = video_tensor.detach().cpu().float().numpy() if video_tensor.ndim != 4: raise ValueError(f"Expected [C, F, H, W], got {video_tensor.shape}") # [C, F, H, W] -> [F, H, W, C] frames = np.transpose(video_tensor, (1, 2, 3, 0)) # Approximate old rescale=True behavior frames = (frames + 1.0) / 2.0 frames = np.clip(frames, 0.0, 1.0) saved_paths = [] for i, frame in enumerate(frames): out_path = os.path.join(out_dir, f"{prefix}_{i:04d}.png") plt.imsave(out_path, frame) saved_paths.append(out_path) return saved_paths def classify_channel(name): """ Infer side and modality from channel name. Returns (side, modality) where side in {left,right,unknown} and modality in {emg,imu,other}. """ s = str(name).strip() su = s.upper() side = "unknown" if any(tok in su for tok in ["LEFT", "L_", "_L", " L ", "L-"]): side = "left" elif any(tok in su for tok in ["RIGHT", "R_", "_R", " R ", "R-"]): side = "right" modality = "other" if "EMG" in su: modality = "emg" elif any(tok in su for tok in ["IMU", "ACC", "GYRO", "MAG"]): modality = "imu" return side, modality def build_channel_groups(signal_cols): """ Build ordered groups so left/right are separate, and EMG/IMU are separate. """ groups = { ("left", "emg"): [], ("right", "emg"): [], ("left", "imu"): [], ("right", "imu"): [], ("unknown", "emg"): [], ("unknown", "imu"): [], ("left", "other"): [], ("right", "other"): [], ("unknown", "other"): [], } for idx, name in enumerate(signal_cols): key = classify_channel(name) groups[key].append(idx) ordered_keys = [ ("left", "emg"), ("right", "emg"), ("left", "imu"), ("right", "imu"), ("unknown", "emg"), ("unknown", "imu"), ("left", "other"), ("right", "other"), ("unknown", "other"), ] return [(key, groups[key]) for key in ordered_keys if len(groups[key]) > 0] def plot_control_sensor(control_array, signal_cols, out_path): """ One subplot per channel. Left/right are separated into different figure sections based on channel names. """ control_array = np.asarray(control_array, dtype=np.float32) # Usually [B, T, C] -> take first sample if control_array.ndim == 3: control_array = control_array[0] if control_array.ndim != 2: raise ValueError(f"Expected control array [T, C], got {control_array.shape}") num_timesteps, num_channels = control_array.shape if signal_cols is None or len(signal_cols) != num_channels: signal_cols = [f"ch_{i}" for i in range(num_channels)] channel_groups = build_channel_groups(signal_cols) # Flatten into ordered channel list with headers ordered_channels = [] for (side, modality), idxs in channel_groups: header = f"{side.upper()} {modality.upper()}" for idx in idxs: ordered_channels.append((header, idx, str(signal_cols[idx]))) nrows = len(ordered_channels) if nrows == 0: raise ValueError("No channels found to plot.") fig_height = max(2.2 * nrows, 6) fig, axes = plt.subplots(nrows, 1, figsize=(16, fig_height), sharex=True) if nrows == 1: axes = [axes] x = np.arange(num_timesteps) prev_header = None for ax, (header, idx, ch_name) in zip(axes, ordered_channels): y = control_array[:, idx] ax.plot(x, y, linewidth=1.0) ax.set_ylabel(ch_name, fontsize=8) ax.grid(True, alpha=0.3) # Put section title when group changes if header != prev_header: ax.set_title(header, loc="left", fontsize=11, fontweight="bold") prev_header = header axes[-1].set_xlabel("Time Index") fig.tight_layout() fig.savefig(out_path, dpi=180) plt.close(fig) def save_batch(batch, batch_idx, output_dir, fps): batch_dir = os.path.join(output_dir, f"batch_{batch_idx:03d}") os.makedirs(batch_dir, exist_ok=True) pixel_values = batch["pixel_values"] if pixel_values.ndim != 5: raise ValueError(f"Expected pixel_values [B, F, C, H, W], got {tuple(pixel_values.shape)}") # [B, F, C, H, W] -> [B, C, F, H, W] rgb_videos = pixel_values.detach().cpu().permute(0, 2, 1, 3, 4).contiguous() rgb_frames_dir = os.path.join(batch_dir, "pixel_values_frames") os.makedirs(rgb_frames_dir, exist_ok=True) pixel_frame_paths = [] for b in range(rgb_videos.shape[0]): sample_dir = os.path.join(rgb_frames_dir, f"sample_{b:03d}") saved = save_video_frames(rgb_videos[b], sample_dir, prefix="frame") pixel_frame_paths.append(saved) ref_frame_paths = None if "ref_pixel_values" in batch: ref_values = batch["ref_pixel_values"].detach().cpu().permute(0, 2, 1, 3, 4).contiguous() ref_frames_dir = os.path.join(batch_dir, "ref_pixel_values_frames") os.makedirs(ref_frames_dir, exist_ok=True) ref_frame_paths = [] for b in range(ref_values.shape[0]): sample_dir = os.path.join(ref_frames_dir, f"sample_{b:03d}") saved = save_video_frames(ref_values[b], sample_dir, prefix="frame") ref_frame_paths.append(saved) control_values = batch["control_pixel_values"] control_np = control_values.detach().cpu().numpy() if isinstance(control_values, torch.Tensor) else np.asarray(control_values) np.save(os.path.join(batch_dir, "control_sensor.npy"), control_np) signal_cols = batch.get("emg_signal_cols") if isinstance(signal_cols, list) and len(signal_cols) > 0 and isinstance(signal_cols[0], list): signal_cols = signal_cols[0] plot_control_sensor( control_np, signal_cols, os.path.join(batch_dir, "control_sensor_plot.png"), ) summary = { "pixel_values_shape": list(pixel_values.shape), "control_pixel_values_shape": list(control_values.shape), "text": to_serializable(batch.get("text")), "data_type": to_serializable(batch.get("data_type")), "idx": to_serializable(batch.get("idx")), "motion_compensation_mode": to_serializable(batch.get("motion_compensation_mode")), "participant_path": to_serializable(batch.get("participant_path")), "frame_ids": to_serializable(batch.get("frame_ids")), "selected_frames": to_serializable(batch.get("selected_frames")), "clip_start_t": to_serializable(batch.get("clip_start_t")), "clip_end_t": to_serializable(batch.get("clip_end_t")), "clip_mid_t": to_serializable(batch.get("clip_mid_t")), "sensor_start_t": to_serializable(batch.get("sensor_start_t")), "sensor_end_t": to_serializable(batch.get("sensor_end_t")), "sensor_num_samples": to_serializable(batch.get("sensor_num_samples")), "emg_signal_cols": to_serializable(batch.get("emg_signal_cols")), "control_signal_mode": to_serializable(batch.get("control_signal_mode")), "pixel_frame_paths": to_serializable(pixel_frame_paths), "ref_frame_paths": to_serializable(ref_frame_paths), } with open(os.path.join(batch_dir, "metadata.json"), "w") as f: json.dump(summary, f, indent=2) print(f"[batch {batch_idx}] pixel_values={tuple(pixel_values.shape)} control={tuple(control_values.shape)} saved to {batch_dir}") def main(): args = parse_args() if args.enable_bucket: raise NotImplementedError("This inspection script currently supports the non-bucket dataloader path only.") os.makedirs(args.output_dir, exist_ok=True) set_seed(args.seed) dataset = ImageVideoControlDataset( args.train_data_meta, args.train_data_dir, video_sample_size=args.video_sample_size, video_sample_stride=args.video_sample_stride, video_sample_n_frames=args.video_sample_n_frames, video_repeat=args.video_repeat, image_sample_size=args.image_sample_size, enable_bucket=args.enable_bucket, enable_camera_info=args.train_mode == "control_camera_ref", control_signal_mode="emg", ) sampler_generator = torch.Generator().manual_seed(args.seed) batch_sampler = ImageVideoSampler( RandomSampler(dataset, generator=sampler_generator), dataset, args.train_batch_size, ) dataloader = DataLoader( dataset, batch_sampler=batch_sampler, persistent_workers=args.dataloader_num_workers != 0, num_workers=args.dataloader_num_workers, worker_init_fn=worker_init_fn(args.seed), ) for batch_idx, batch in enumerate(dataloader): save_batch(batch, batch_idx, args.output_dir, args.fps) if batch_idx + 1 >= args.max_batches: break if __name__ == "__main__": main()