#!/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()