Upload train.py with huggingface_hub

train.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "torch",
+#     "transformers>=4.45",
+#     "datasets",
+#     "accelerate",
+#     "albumentations>=1.4.16",
+#     "torchmetrics",
+#     "pycocotools",
+#     "Pillow",
+#     "numpy",
+# ]
+# ///
+import os
+import sys
+import logging
+import json
+from functools import partial
+from collections import defaultdict
+
+import numpy as np
+import torch
+from datasets import load_dataset
+
+import transformers
+from transformers import (
+    AutoConfig,
+    AutoImageProcessor,
+    AutoModelForObjectDetection,
+    Trainer,
+    TrainingArguments,
+)
+from transformers.image_processing_utils import BatchFeature
+from transformers.image_transforms import center_to_corners_format
+from transformers.trainer import EvalPrediction
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+                    datefmt="%m/%d/%Y %H:%M:%S", handlers=[logging.StreamHandler(sys.stdout)])
+logger.setLevel(logging.INFO)
+transformers.utils.logging.set_verbosity_info()
+
+MODEL = "PekingU/rtdetr_r50vd"
+DATASET = "biglam/loc_beyond_words"
+SQUARE = int(os.environ.get("SQUARE", "800"))
+RARE_BOOST = {1: 3, 2: 4, 3: 3, 4: 4}  # Illustration, Map, Comics, EditorialCartoon
+
+import albumentations as A
+
+
+class ModelOutput:
+    def __init__(self, logits, pred_boxes):
+        self.logits = logits
+        self.pred_boxes = pred_boxes
+
+
+def format_image_annotations_as_coco(image_id, categories, areas, bboxes):
+    annotations = []
+    for category, area, bbox in zip(categories, areas, bboxes):
+        annotations.append({
+            "image_id": image_id, "category_id": category, "iscrowd": 0,
+            "area": area, "bbox": list(bbox),
+        })
+    return {"image_id": image_id, "annotations": annotations}
+
+
+def convert_bbox_yolo_to_pascal(boxes, image_size):
+    boxes = center_to_corners_format(boxes)
+    height, width = image_size
+    boxes = boxes * torch.tensor([[width, height, width, height]])
+    return boxes
+
+
+def augment_and_transform_batch(examples, transform, image_processor, return_pixel_mask=False):
+    images, annotations = [], []
+    for image_id, image, objects in zip(examples["image_id"], examples["image"], examples["objects"]):
+        image = np.array(image.convert("RGB"))
+        if isinstance(objects, dict):
+            bboxes, categories, areas = objects["bbox"], objects["category"], objects["area"]
+        else:
+            bboxes = [o["bbox"] for o in objects]
+            categories = [o["category_id"] for o in objects]
+            areas = [o["area"] for o in objects]
+        output = transform(image=image, bboxes=bboxes, category=categories)
+        images.append(output["image"])
+        annotations.append(format_image_annotations_as_coco(
+            image_id, output["category"], areas, output["bboxes"]))
+    result = image_processor(images=images, annotations=annotations, return_tensors="pt")
+    if not return_pixel_mask:
+        result.pop("pixel_mask", None)
+    return result
+
+
+def collate_fn(batch):
+    data = {
+        "pixel_values": torch.stack([x["pixel_values"] for x in batch]),
+        "labels": [x["labels"] for x in batch],
+    }
+    if "pixel_mask" in batch[0]:
+        data["pixel_mask"] = torch.stack([x["pixel_mask"] for x in batch])
+    return data
+
+
+def evaluate_model(model, image_processor, ds, device, batch_size=4):
+    from torchmetrics.detection.mean_ap import MeanAveragePrecision
+    metric = MeanAveragePrecision(box_format="xyxy", class_metrics=True)
+    N = len(ds)
+    for start in range(0, N, batch_size):
+        end = min(start + batch_size, N)
+        chunk = ds[start:end]
+        images, anns, origsizes = [], [], []
+        imgouts = chunk["objects"]
+        for k in range(end - start):
+            im = chunk["image"][k].convert("RGB")
+            origsizes.append((im.height, im.width))
+            objects = imgouts[k]
+            if isinstance(objects, dict):
+                bboxes, categories, areas = objects["bbox"], objects["category"], objects["area"]
+            else:
+                bboxes = [o["bbox"] for o in objects]
+                categories = [o["category_id"] for o in objects]
+                areas = [o["area"] for o in objects]
+            images.append(np.array(im))
+            anns.append(format_image_annotations_as_coco(
+                chunk["image_id"][k], categories, areas, bboxes))
+        inputs = image_processor(images=images, annotations=anns, return_tensors="pt").to(device)
+        with torch.no_grad():
+            outputs = model(pixel_values=inputs["pixel_values"],
+                            pixel_mask=inputs.get("pixel_mask", None))
+        preds = image_processor.post_process_object_detection(
+            ModelOutput(logits=outputs.logits, pred_boxes=outputs.pred_boxes),
+            threshold=0.5, target_sizes=torch.tensor(origsizes, device=device),
+        )
+        for k in range(end - start):
+            lab = inputs["labels"][k]
+            tboxes = convert_bbox_yolo_to_pascal(torch.tensor(lab["boxes"]), lab["orig_size"])
+            metric.update(
+                [{"boxes": preds[k]["boxes"], "scores": preds[k]["scores"],
+                  "labels": preds[k]["labels"]}],
+                [{"boxes": tboxes, "labels": torch.tensor(lab["class_labels"]).reshape(-1)}],
+            )
+    results = metric.compute()
+    out = {"map_50_95": round(results["map"].item(), 4),
+           "map_50": round(results["map_50"].item(), 4),
+           "map_75": round(results["map_75"].item(), 4),
+           "mar_100": round(results["mar_100"].item(), 4)}
+    if "classes" in results:
+        cls = results["classes"]
+        mpc = results["map_per_class"]
+        for c_id, m in zip(cls, mpc):
+            out[f"map_{c_id.item()}"] = round(m.item(), 4)
+    return out
+
+
+def oversample(dataset, boost, seed=42):
+    rng = np.random.default_rng(seed)
+    weights = []
+    for i in range(len(dataset)):
+        objs = dataset[i]["objects"]
+        if isinstance(objs, dict):
+            cats = objs["category"]
+        else:
+            cats = [o["category_id"] for o in objs]
+        w = 1
+        for c in set(int(c) for c in cats):
+            w = max(w, 1 + boost.get(int(c), 0))
+        weights.append(w)
+    weights = np.array(weights, dtype=float)
+    n = len(weights)
+    pick = rng.choice(n, size=n, replace=True, p=weights / weights.sum())
+    return dataset.select(pick.tolist())
+
+
+def main():
+    do_push = os.environ.get("PUSH", "1") == "1"
+    epochs = int(os.environ.get("EPOCHS", "3"))
+    bs = int(os.environ.get("BATCH", "4"))
+    grad_acc = int(os.environ.get("GRAD_ACC", "2"))
+    max_train = int(os.environ.get("MAX_TRAIN", "0")) or None
+    max_eval = int(os.environ.get("MAX_EVAL", "0")) or None
+
+    dataset = load_dataset(DATASET)
+    feat = dataset["train"].features["objects"]
+    inner = feat if isinstance(feat, dict) else feat.feature
+    cat_feat = inner["category_id"]
+    categories = cat_feat.names if hasattr(cat_feat, "names") else list(range(cat_feat.num_classes))
+    id2label = dict(enumerate(categories))
+    label2id = {v: k for k, v in id2label.items()}
+    logger.info(f"Cats: {categories}")
+
+    if max_train:
+        dataset["train"] = dataset["train"].select(range(min(max_train, len(dataset["train"]))))
+    if max_eval:
+        dataset["validation"] = dataset["validation"].select(range(min(max_eval, len(dataset["validation"]))))
+
+    config = AutoConfig.from_pretrained(MODEL, **{"label2id": label2id, "id2label": id2label})
+    model = AutoModelForObjectDetection.from_pretrained(MODEL, config=config, ignore_mismatched_sizes=True)
+    image_processor = AutoImageProcessor.from_pretrained(
+        MODEL,
+        do_resize=True,
+        size={"max_height": SQUARE, "max_width": SQUARE},
+        do_pad=True,
+        pad_size={"height": SQUARE, "width": SQUARE},
+    )
+
+    max_size = SQUARE
+    train_transforms = A.Compose(
+        [
+            A.Compose(
+                [A.SmallestMaxSize(max_size=max_size, p=1.0),
+                 A.RandomSizedBBoxSafeCrop(height=max_size, width=max_size, p=1.0)],
+                p=0.2,
+            ),
+            A.OneOf([A.Blur(blur_limit=7, p=0.5), A.MotionBlur(blur_limit=7, p=0.5)], p=0.1),
+            A.Perspective(p=0.1),
+            A.HorizontalFlip(p=0.5),
+            A.RandomBrightnessContrast(p=0.3),
+        ],
+        bbox_params=A.BboxParams(format="coco", label_fields=["category"], clip=True, min_area=25),
+    )
+    validation_transform = A.Compose(
+        [A.NoOp()], bbox_params=A.BboxParams(format="coco", label_fields=["category"], clip=True)
+    )
+
+    train_transform_batch = partial(augment_and_transform_batch,
+                                    transform=train_transforms, image_processor=image_processor)
+    val_transform_batch = partial(augment_and_transform_batch,
+                                  transform=validation_transform, image_processor=image_processor)
+
+    train_ds = dataset["train"]
+    if not max_train:
+        train_ds = oversample(train_ds, RARE_BOOST)
+        logger.info(f"Oversampled train size: {len(train_ds)}")
+    train_ds = train_ds.with_transform(train_transform_batch)
+    val_ds = dataset["validation"].with_transform(val_transform_batch)
+
+    logging_steps = int(os.environ.get("LOG_STEPS", "50"))
+    args = TrainingArguments(
+        output_dir="./out",
+        per_device_train_batch_size=bs,
+        gradient_accumulation_steps=grad_acc,
+        num_train_epochs=epochs,
+        learning_rate=float(os.environ.get("LR", "1e-4")),
+        lr_scheduler_type="cosine",
+        warmup_ratio=0.05,
+        weight_decay=1e-4,
+        fp16=torch.cuda.is_available(),
+        dataloader_num_workers=3,
+        dataloader_pin_memory=True,
+        dataloader_prefetch_factor=4,
+        remove_unused_columns=False,
+        logging_steps=logging_steps,
+        report_to=[],
+        eval_strategy="no",
+        save_strategy="no",
+        seed=42,
+        ddp_find_unused_parameters=None,
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=args,
+        train_dataset=train_ds,
+        processing_class=image_processor,
+        data_collator=collate_fn,
+    )
+
+    trainer.train()
+    torch.cuda.empty_cache()
+    metrics = evaluate_model(model, image_processor, dataset["validation"], device=model.device)
+    logger.info("FINAL RESULT: " + json.dumps(metrics, indent=2))
+    with open("final_metrics.json", "w") as f:
+        json.dump(metrics, f, indent=2)
+
+    model.save_pretrained("./out/best")
+    image_processor.save_pretrained("./out/best")
+
+    if do_push:
+        repo_id = os.environ.get("REPO", "harness-race/opencode-r3")
+        logger.info(f"Pushing to {repo_id}")
+        model.push_to_hub(
+            repo_id=repo_id,
+            commit_message="Fine-tune RT-DETR-R50 on biglam/loc_beyond_words (Beyond Words)",
+            private=False,
+        )
+        image_processor.push_to_hub(repo_id=repo_id, commit_message="Update processor")
+        with open("result.txt", "w") as f:
+            f.write(json.dumps(metrics))
+    logger.info("DONE")
+
+
+if __name__ == "__main__":
+    main()