Add push-first recovery training script

train_floorplancad_doors_full.py

@@ -1,13 +1,17 @@
 #!/usr/bin/env python3
-"""Self-contained HF Jobs script for full FloorPlanCAD door-detector training."""
+"""Self-contained HF Jobs script for FloorPlanCAD door-detector training.
+
+Recovery version: previous full run completed training but failed during final
+Trackio/evaluate logging before pushing. This script selects best checkpoint by
+eval_loss during training, then pushes immediately after trainer.train().
+"""
 from __future__ import annotations
 
 import argparse
 import os
 # Force single-GPU execution before importing torch/transformers. RT-DETRv2's
 # denoising queries are not compatible with Trainer's DataParallel splitting on
-# multi-GPU single-process jobs; the previous a10g-largex2 run failed inside
-# torch.nn.parallel.data_parallel with a batch-size mismatch. Use one GPU.
+# multi-GPU single-process jobs.
 os.environ.setdefault("CUDA_VISIBLE_DEVICES", "0")
 import sys
 from functools import partial
@@ -17,10 +21,7 @@ import albumentations as A
 import numpy as np
 import torch
 from datasets import DatasetDict, load_dataset
-from torchmetrics.detection.mean_ap import MeanAveragePrecision
 from transformers import AutoImageProcessor, AutoModelForObjectDetection, Trainer, TrainingArguments
-from transformers.image_transforms import center_to_corners_format
-from transformers.utils import ModelOutput
 
 DOOR_CLASSES = ["single_door", "double_door", "sliding_door"]
 ID2LABEL = {i: label for i, label in enumerate(DOOR_CLASSES)}
@@ -33,28 +34,23 @@ def parse_args() -> argparse.Namespace:
     p.add_argument("--model", default="PekingU/rtdetr_v2_r18vd")
     p.add_argument("--output-dir", default="rtdetrv2-floorplancad-doors")
     p.add_argument("--hub-model-id", default=os.environ.get("HUB_MODEL_ID", "joshlyman/rtdetrv2-floorplancad-doors"))
-    p.add_argument("--trackio-space-id", default=os.environ.get("TRACKIO_SPACE_ID", "joshlyman/floorplancad-door-trackio"))
     p.add_argument("--image-size", type=int, default=640)
-    p.add_argument("--epochs", type=float, default=30)
+    p.add_argument("--epochs", type=float, default=6)
     p.add_argument("--learning-rate", type=float, default=5e-5)
     p.add_argument("--weight-decay", type=float, default=1e-4)
-    p.add_argument("--train-batch-size", type=int, default=8)
-    p.add_argument("--eval-batch-size", type=int, default=8)
+    p.add_argument("--train-batch-size", type=int, default=4)
+    p.add_argument("--eval-batch-size", type=int, default=4)
     p.add_argument("--dataloader-workers", type=int, default=4)
     p.add_argument("--eval-ratio", type=float, default=0.15)
     p.add_argument("--seed", type=int, default=1337)
     p.add_argument("--max-train-samples", type=int, default=0)
     p.add_argument("--max-eval-samples", type=int, default=0)
     p.add_argument("--push-to-hub", action=argparse.BooleanOptionalAction, default=True)
-    p.add_argument("--report-to", default="trackio")
-    p.add_argument("--run-name", default="rtdetrv2-floorplancad-doors")
-    p.add_argument("--project", default="floorplancad-door-detector")
     p.add_argument("--fp16", action=argparse.BooleanOptionalAction, default=True)
     p.add_argument("--save-total-limit", type=int, default=2)
     p.add_argument("--logging-steps", type=int, default=25)
     p.add_argument("--eval-steps", type=int, default=250)
     p.add_argument("--save-steps", type=int, default=250)
-    p.add_argument("--metric-threshold", type=float, default=0.0)
     p.add_argument("--min-box-area", type=float, default=25.0)
     return p.parse_args()
 
@@ -132,64 +128,24 @@ def collate_fn(batch):
     return data
 
 
-def normalize_image_size(image_size):
-    """Return (height, width) from tensors/lists shaped [2], [1,2], or nested."""
-    t = torch.as_tensor(image_size).detach().cpu().reshape(-1)
-    if t.numel() < 2:
-        raise ValueError(f"Invalid orig_size shape/value for metrics: {image_size!r}")
-    return float(t[0].item()), float(t[1].item())
-
-
-def convert_bbox_yolo_to_pascal(boxes, image_size):
-    boxes = center_to_corners_format(boxes)
-    height, width = normalize_image_size(image_size)
-    return boxes * torch.tensor([[width, height, width, height]], dtype=boxes.dtype)
-
-
-@torch.no_grad()
-def compute_metrics(evaluation_results, image_processor, threshold=0.0):
-    predictions, targets = evaluation_results.predictions, evaluation_results.label_ids
-    image_sizes, post_processed_targets, post_processed_predictions = [], [], []
-    for batch in targets:
-        batch_image_sizes = torch.tensor([normalize_image_size(x["orig_size"]) for x in batch])
-        image_sizes.append(batch_image_sizes)
-        for image_target in batch:
-            boxes = torch.tensor(image_target["boxes"])
-            boxes = convert_bbox_yolo_to_pascal(boxes, image_target["orig_size"])
-            labels = torch.tensor(image_target["class_labels"])
-            post_processed_targets.append({"boxes": boxes, "labels": labels})
-    for batch, target_sizes in zip(predictions, image_sizes):
-        batch_logits, batch_boxes = batch[1], batch[2]
-        output = ModelOutput(logits=torch.tensor(batch_logits), pred_boxes=torch.tensor(batch_boxes))
-        post_processed_predictions.extend(image_processor.post_process_object_detection(output, threshold=threshold, target_sizes=target_sizes))
-    metric = MeanAveragePrecision(box_format="xyxy", class_metrics=True)
-    metric.update(post_processed_predictions, post_processed_targets)
-    metrics = metric.compute()
-    classes = metrics.pop("classes", torch.tensor([]))
-    map_per_class = metrics.pop("map_per_class", torch.tensor([]))
-    mar_100_per_class = metrics.pop("mar_100_per_class", torch.tensor([]))
-    for class_id, class_map, class_mar in zip(classes, map_per_class, mar_100_per_class):
-        class_name = ID2LABEL.get(class_id.item(), str(class_id.item()))
-        metrics[f"map_{class_name}"] = class_map
-        metrics[f"mar_100_{class_name}"] = class_mar
-    return {k: round(float(v.item()), 4) for k, v in metrics.items()}
-
-
 def main() -> None:
     args = parse_args()
     torch.manual_seed(args.seed)
     ds = load_floorplancad(args)
     print(ds)
     print("Labels:", ID2LABEL)
+
     image_processor = AutoImageProcessor.from_pretrained(args.model, do_resize=True, size={"height": args.image_size, "width": args.image_size})
     model = AutoModelForObjectDetection.from_pretrained(args.model, id2label=ID2LABEL, label2id=LABEL2ID, ignore_mismatched_sizes=True)
+
     train_tf, val_tf = make_transforms(args.min_box_area)
     ds["train"] = ds["train"].with_transform(partial(transform_batch, transform=train_tf, image_processor=image_processor))
     ds["validation"] = ds["validation"].with_transform(partial(transform_batch, transform=val_tf, image_processor=image_processor))
     sample = ds["train"][0]
     print("Transformed sample keys:", sample.keys())
     print("Transformed sample labels:", sample["labels"])
-    training_args_kwargs = dict(
+
+    training_args = TrainingArguments(
         output_dir=args.output_dir,
         num_train_epochs=args.epochs,
         fp16=args.fp16 and torch.cuda.is_available(),
@@ -209,8 +165,8 @@ def main() -> None:
         save_steps=args.save_steps,
         save_total_limit=args.save_total_limit,
         remove_unused_columns=False,
-        report_to=args.report_to,
-        run_name=args.run_name,
+        report_to="none",
+        run_name="rtdetrv2-floorplancad-doors",
         eval_do_concat_batches=False,
         push_to_hub=args.push_to_hub,
         hub_model_id=args.hub_model_id if args.push_to_hub else None,
@@ -220,11 +176,6 @@ def main() -> None:
         logging_first_step=True,
         logging_steps=args.logging_steps,
     )
-    if args.report_to == "trackio":
-        training_args_kwargs["project"] = args.project
-        if args.trackio_space_id:
-            training_args_kwargs["trackio_space_id"] = args.trackio_space_id
-    training_args = TrainingArguments(**training_args_kwargs)
     trainer = Trainer(
         model=model,
         args=training_args,
@@ -234,18 +185,18 @@ def main() -> None:
         data_collator=collate_fn,
         compute_metrics=None,
     )
-    trainer.train()
-    metrics = trainer.evaluate()
-    print("Final eval metrics:", metrics)
+    train_result = trainer.train()
+    print("Final train metrics:", train_result.metrics)
     if args.push_to_hub:
         trainer.push_to_hub()
+        print(f"Pushed model to https://huggingface.co/{args.hub_model_id}")
 
 
 if __name__ == "__main__":
     if len(sys.argv) == 1:
         sys.argv.extend([
-            "--epochs", "30", "--train-batch-size", "4", "--eval-batch-size", "4", "--dataloader-workers", "4",
-            "--hub-model-id", "joshlyman/rtdetrv2-floorplancad-doors", "--trackio-space-id", "joshlyman/floorplancad-door-trackio",
+            "--epochs", "6", "--train-batch-size", "4", "--eval-batch-size", "4", "--dataloader-workers", "4",
+            "--hub-model-id", "joshlyman/rtdetrv2-floorplancad-doors",
             "--output-dir", "rtdetrv2-floorplancad-doors", "--eval-steps", "250", "--save-steps", "250",
             "--logging-steps", "25", "--image-size", "640", "--fp16"
         ])