train.py

#!/usr/bin/env python
# /// script
# requires-python = ">=3.11"
# dependencies = [
#    "torch",
#    "torchvision",
#    "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"]).cpu()
            metric.update(
                [{"boxes": preds[k]["boxes"].cpu(), "scores": preds[k]["scores"].cpu(),
                  "labels": preds[k]["labels"].cpu()}],
                [{"boxes": tboxes, "labels": torch.tensor(lab["class_labels"]).reshape(-1).cpu()}],
            )
    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()