EMG / scripts /wan2.1_fun /test_control_dataloader_emg.py
edessa's picture
Add files using upload-large-folder tool
3157197 verified
Raw History Blame Contribute Delete
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()