| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| 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} |
|
|
| 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() |
|
|
