Download scripts/wan2.1_fun/test_control_dataloader_emg.py from edessa/EMG: direct link, hf CLI and curl.
- Browser
- Download file 13.2 kB
-
https://huggingface.co/datasets/edessa/EMG/resolve/main/scripts/wan2.1_fun/test_control_dataloader_emg.py
- Command line
-
hf download hf://datasets/edessa/EMG/scripts/wan2.1_fun/test_control_dataloader_emg.py
-
curl -L -o test_control_dataloader_emg.py https://huggingface.co/datasets/edessa/EMG/resolve/main/scripts/wan2.1_fun/test_control_dataloader_emg.py
13.2 kB
| #!/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() |