| """Training script: 3D ResNet-101 on air-writing videos. |
| - model selection uses the VALIDATION set only (macro-F1); the test set is never touched here |
| - resumable (last.pt), best checkpoint (best.pt), AMP, gradient accumulation, cosine LR |
| """ |
| import argparse |
| import json |
| import math |
| import os |
| import random |
| import time |
|
|
| import numpy as np |
| import torch |
| import torch.nn as nn |
| from sklearn.metrics import f1_score |
| from torch.utils.data import DataLoader |
| from tqdm import tqdm |
|
|
| from airwriting_common import AirDataset, build_model, class_names, collect_logits |
|
|
|
|
| def set_seed(s): |
| random.seed(s) |
| np.random.seed(s) |
| torch.manual_seed(s) |
| torch.cuda.manual_seed_all(s) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--train-csv", required=True) |
| ap.add_argument("--val-csv", required=True) |
| ap.add_argument("--video-dir", required=True) |
| ap.add_argument("--out-dir", default="runs/exp1") |
| ap.add_argument("--depth", type=int, default=101) |
| ap.add_argument("--frames", type=int, default=16) |
| ap.add_argument("--size", type=int, default=224) |
| ap.add_argument("--epochs", type=int, default=30) |
| ap.add_argument("--batch-size", type=int, default=4) |
| ap.add_argument("--accum-steps", type=int, default=4, help="effective batch = batch-size * accum-steps") |
| ap.add_argument("--lr", type=float, default=1e-4) |
| ap.add_argument("--weight-decay", type=float, default=1e-2) |
| ap.add_argument("--label-smoothing", type=float, default=0.1) |
| ap.add_argument("--warmup-epochs", type=float, default=1.0) |
| ap.add_argument("--patience", type=int, default=6, help="early stop after N epochs without val F1 gain") |
| ap.add_argument("--num-workers", type=int, default=4) |
| ap.add_argument("--separate-contrast", action="store_true", help="38 classes instead of 37") |
| ap.add_argument("--max-train-samples", type=int, default=None, help="smoke test") |
| ap.add_argument("--max-val-samples", type=int, default=None) |
| ap.add_argument("--seed", type=int, default=42) |
| ap.add_argument("--no-resume", action="store_true") |
| a = ap.parse_args() |
|
|
| set_seed(a.seed) |
| os.makedirs(a.out_dir, exist_ok=True) |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| use_amp = device.type == "cuda" |
| names = class_names(a.separate_contrast) |
| print(f"device={device} amp={use_amp} classes={len(names)} frames={a.frames} size={a.size}") |
|
|
| tr = AirDataset(a.train_csv, a.video_dir, a.frames, a.size, True, a.separate_contrast, |
| "resample", a.max_train_samples) |
| va = AirDataset(a.val_csv, a.video_dir, a.frames, a.size, False, a.separate_contrast, |
| "raise", a.max_val_samples) |
| kw = dict(num_workers=a.num_workers, pin_memory=device.type == "cuda", |
| persistent_workers=a.num_workers > 0) |
| tl = DataLoader(tr, batch_size=a.batch_size, shuffle=True, drop_last=True, **kw) |
| vl = DataLoader(va, batch_size=a.batch_size, shuffle=False, **kw) |
|
|
| model = build_model(len(names), a.depth, a.frames, a.size).to(device) |
| opt = torch.optim.AdamW(model.parameters(), lr=a.lr, weight_decay=a.weight_decay) |
| steps_per_epoch = math.ceil(len(tl) / a.accum_steps) |
| total, warm = steps_per_epoch * a.epochs, int(steps_per_epoch * a.warmup_epochs) |
| lr_fn = lambda s: min(1.0, (s + 1) / max(1, warm)) * max(0.01, 0.5 * (1 + math.cos(math.pi * min(1.0, s / total)))) |
| sched = torch.optim.lr_scheduler.LambdaLR(opt, lr_fn) |
| scaler = torch.amp.GradScaler("cuda", enabled=use_amp) if hasattr(torch, "amp") and hasattr(torch.amp, "GradScaler") \ |
| else torch.cuda.amp.GradScaler(enabled=use_amp) |
| crit = nn.CrossEntropyLoss(label_smoothing=a.label_smoothing) |
|
|
| cfg = dict(depth=a.depth, frames=a.frames, size=a.size, separate_contrast=a.separate_contrast, |
| classes=names, args=vars(a)) |
| json.dump(cfg, open(os.path.join(a.out_dir, "config.json"), "w"), indent=2) |
|
|
| start, best, bad, hist = 0, -1.0, 0, [] |
| last = os.path.join(a.out_dir, "last.pt") |
| if os.path.exists(last) and not a.no_resume: |
| ck = torch.load(last, map_location=device) |
| model.load_state_dict(ck["model"]); opt.load_state_dict(ck["opt"]); sched.load_state_dict(ck["sched"]) |
| scaler.load_state_dict(ck["scaler"]) |
| start, best, bad, hist = ck["epoch"], ck["best"], ck["bad"], ck["hist"] |
| print(f"Resumed at epoch {start} (best val macro-F1 {best:.4f})") |
|
|
| for epoch in range(start, a.epochs): |
| model.train() |
| opt.zero_grad(set_to_none=True) |
| run_loss, correct, seen, t0 = 0.0, 0, 0, time.time() |
| for i, (x, y) in enumerate(tqdm(tl, desc=f"epoch {epoch + 1}/{a.epochs}")): |
| x, y = x.to(device, non_blocking=True), y.to(device, non_blocking=True) |
| with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp): |
| out = model(x) |
| loss = crit(out, y) |
| scaler.scale(loss / a.accum_steps).backward() |
| if (i + 1) % a.accum_steps == 0 or (i + 1) == len(tl): |
| scaler.unscale_(opt) |
| nn.utils.clip_grad_norm_(model.parameters(), 1.0) |
| scaler.step(opt); scaler.update() |
| opt.zero_grad(set_to_none=True) |
| sched.step() |
| run_loss += loss.item() * y.size(0) |
| correct += (out.argmax(1) == y).sum().item() |
| seen += y.size(0) |
|
|
| logits, labels = collect_logits(model, vl, device, use_amp) |
| pred = logits.argmax(1) |
| present = sorted(set(labels.tolist())) |
| val_acc = float((pred == labels).mean()) |
| val_f1 = float(f1_score(labels, pred, labels=present, average="macro", zero_division=0)) |
| row = dict(epoch=epoch + 1, train_loss=run_loss / seen, train_acc=correct / seen, |
| val_acc=val_acc, val_macro_f1=val_f1, lr=sched.get_last_lr()[0], |
| minutes=(time.time() - t0) / 60) |
| hist.append(row) |
| print(json.dumps(row)) |
|
|
| if val_f1 > best: |
| best, bad = val_f1, 0 |
| torch.save(dict(model=model.state_dict(), config=cfg, epoch=epoch + 1, val_macro_f1=val_f1), |
| os.path.join(a.out_dir, "best.pt")) |
| else: |
| bad += 1 |
| torch.save(dict(model=model.state_dict(), opt=opt.state_dict(), sched=sched.state_dict(), |
| scaler=scaler.state_dict(), epoch=epoch + 1, best=best, bad=bad, hist=hist), last) |
| json.dump(hist, open(os.path.join(a.out_dir, "history.json"), "w"), indent=2) |
| if bad >= a.patience: |
| print(f"Early stop: no val macro-F1 gain for {a.patience} epochs.") |
| break |
| print(f"Done. Best val macro-F1 = {best:.4f}. Now run test.py on {os.path.join(a.out_dir, 'best.pt')}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
