Datasets:
File size: 5,498 Bytes
74f7b5f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | #!/usr/bin/env python3
"""Train or resume the Cuphead YOLO26 detector with safe 4090 defaults."""
from __future__ import annotations
import argparse
import json
import platform
import sys
from datetime import datetime, timezone
from pathlib import Path
import torch
import ultralytics
from ultralytics import YOLO
def batch_value(text: str) -> int | float:
if "." in text:
value = float(text)
if not 0 < value <= 1:
raise argparse.ArgumentTypeError("fractional --batch must be in (0,1]")
return value
value = int(text)
if value == 0 or value < -1:
raise argparse.ArgumentTypeError("integer --batch must be -1 or positive")
return value
def check_gpu(device: str, min_free_gib: float) -> list[dict]:
if device.lower() == "cpu":
return []
if not torch.cuda.is_available():
raise SystemExit("CUDA is not available; check NVIDIA driver and PyTorch CUDA wheel")
gpu_rows = []
for token in device.split(","):
index = int(token)
with torch.cuda.device(index):
free_bytes, total_bytes = torch.cuda.mem_get_info()
row = {
"index": index,
"name": torch.cuda.get_device_name(index),
"free_gib": free_bytes / 2**30,
"total_gib": total_bytes / 2**30,
}
gpu_rows.append(row)
print(
f"GPU {index}: {row['name']} free={row['free_gib']:.2f} GiB "
f"total={row['total_gib']:.2f} GiB"
)
if row["free_gib"] < min_free_gib:
raise SystemExit(
f"GPU {index} has only {row['free_gib']:.2f} GiB free; "
f"need at least {min_free_gib:.2f} GiB"
)
return gpu_rows
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--model", type=Path, default=Path("models/yolo26s.pt"))
parser.add_argument("--data", type=Path, required=True)
parser.add_argument("--project", type=Path, default=Path("runs"))
parser.add_argument("--name", default="yolo26s_960_cuphead_v2")
parser.add_argument("--device", default="0")
parser.add_argument("--epochs", type=int, default=150)
parser.add_argument("--imgsz", type=int, default=960)
parser.add_argument("--batch", type=batch_value, default=-1)
parser.add_argument("--workers", type=int, default=8)
parser.add_argument("--patience", type=int, default=30)
parser.add_argument("--cache", choices=("false", "ram", "disk"), default="false")
parser.add_argument("--save-period", type=int, default=10)
parser.add_argument("--seed", type=int, default=33)
parser.add_argument("--min-free-gib", type=float, default=18.0)
parser.add_argument(
"--resume",
type=Path,
help="path to last.pt; restores optimizer/scheduler/epoch and ignores --model",
)
args = parser.parse_args()
data = args.data.expanduser().resolve()
if not data.is_file():
raise SystemExit(f"data YAML not found: {data}")
checkpoint = (args.resume or args.model).expanduser().resolve()
if not checkpoint.is_file():
raise SystemExit(f"checkpoint not found: {checkpoint}")
gpu_rows = check_gpu(args.device, args.min_free_gib)
args.project.mkdir(parents=True, exist_ok=True)
run_dir = (args.project / args.name).resolve()
if not args.resume and run_dir.exists():
raise SystemExit(f"run directory already exists; choose another --name: {run_dir}")
metadata = {
"started_at_utc": datetime.now(timezone.utc).isoformat(),
"command": sys.argv,
"python": sys.version,
"platform": platform.platform(),
"torch": torch.__version__,
"torch_cuda": torch.version.cuda,
"ultralytics": ultralytics.__version__,
"gpus": gpu_rows,
"model": str(checkpoint),
"data": str(data),
"settings": vars(args) | {"model": str(args.model), "data": str(args.data), "project": str(args.project), "resume": str(args.resume) if args.resume else None},
}
model = YOLO(str(checkpoint))
if args.resume:
result = model.train(resume=True, device=args.device, workers=args.workers)
else:
result = model.train(
data=str(data),
epochs=args.epochs,
imgsz=args.imgsz,
batch=args.batch,
device=args.device,
workers=args.workers,
patience=args.patience,
project=str(args.project.resolve()),
name=args.name,
exist_ok=False,
seed=args.seed,
deterministic=True,
pretrained=True,
optimizer="auto",
close_mosaic=10,
cache=False if args.cache == "false" else args.cache,
save_period=args.save_period,
amp=True,
plots=True,
verbose=True,
)
save_dir = Path(result.save_dir)
(save_dir / "launch_metadata.json").write_text(
json.dumps(metadata, ensure_ascii=False, indent=2, default=str) + "\n",
encoding="utf-8",
)
best = save_dir / "weights" / "best.pt"
last = save_dir / "weights" / "last.pt"
if not best.is_file() or not last.is_file():
raise SystemExit(f"training finished without expected checkpoints under {save_dir / 'weights'}")
print(f"BEST_CHECKPOINT={best.resolve()}")
print(f"RESUME_CHECKPOINT={last.resolve()}")
if __name__ == "__main__":
main()
|