Add RT-DETR object detection training script

train_rtdetr_detection.py

@@ -0,0 +1,266 @@
+# /// script
+# dependencies = [
+#     "transformers>=4.40.0",
+#     "torch",
+#     "torchvision",
+#     "datasets",
+#     "albumentations",
+#     "accelerate",
+#     "huggingface_hub",
+#     "Pillow",
+#     "evaluate",
+#     "pycocotools",
+# ]
+# ///
+
+"""
+RT-DETR Fine-tuning Script for Object Detection
+Fine-tunes RT-DETR on the CPPE-5 dataset (medical PPE detection)
+"""
+
+import os
+import torch
+import numpy as np
+from PIL import Image
+from functools import partial
+from dataclasses import dataclass
+from typing import Dict, List, Any
+
+from datasets import load_dataset
+from transformers import (
+    RTDetrForObjectDetection,
+    RTDetrImageProcessor,
+    TrainingArguments,
+    Trainer,
+)
+from huggingface_hub import login
+
+# Login
+hf_token = os.environ.get("HF_TOKEN")
+if hf_token:
+    login(token=hf_token)
+    print("Logged in to Hugging Face Hub")
+
+# ============================================================================
+# Configuration
+# ============================================================================
+MODEL_NAME = "PekingU/rtdetr_r50vd"  # RT-DETR with ResNet-50 backbone
+DATASET_NAME = "cppe-5"  # Medical PPE detection dataset (5 classes)
+OUTPUT_DIR = "rtdetr-cppe5-detection"
+HUB_MODEL_ID = "Godsonntungi2/rtdetr-cppe5-detection"
+
+# Training parameters (optimized for A10G 24GB)
+BATCH_SIZE = 4
+LEARNING_RATE = 1e-5
+NUM_EPOCHS = 10
+MAX_TRAIN_SAMPLES = 500  # Limit for demo (full dataset has ~1000)
+
+print(f"Loading model: {MODEL_NAME}")
+print(f"Dataset: {DATASET_NAME}")
+
+# ============================================================================
+# Load Dataset
+# ============================================================================
+print("\nLoading CPPE-5 dataset...")
+dataset = load_dataset(DATASET_NAME)
+print(f"Train samples: {len(dataset['train'])}")
+print(f"Test samples: {len(dataset['test'])}")
+
+# Limit samples for demo
+if MAX_TRAIN_SAMPLES:
+    dataset["train"] = dataset["train"].select(range(min(MAX_TRAIN_SAMPLES, len(dataset["train"]))))
+    dataset["test"] = dataset["test"].select(range(min(100, len(dataset["test"]))))
+    print(f"Using {len(dataset['train'])} train, {len(dataset['test'])} test samples")
+
+# Get categories
+categories = dataset["train"].features["objects"].feature["category"].names
+id2label = {i: label for i, label in enumerate(categories)}
+label2id = {label: i for i, label in enumerate(categories)}
+print(f"Classes: {categories}")
+
+# ============================================================================
+# Image Processor & Model
+# ============================================================================
+print("\nLoading image processor and model...")
+image_processor = RTDetrImageProcessor.from_pretrained(MODEL_NAME)
+
+model = RTDetrForObjectDetection.from_pretrained(
+    MODEL_NAME,
+    id2label=id2label,
+    label2id=label2id,
+    ignore_mismatched_sizes=True,  # Important: class head size changes
+)
+print(f"Model loaded with {len(id2label)} classes")
+
+# ============================================================================
+# Data Preprocessing
+# ============================================================================
+def format_annotations(image_id, objects, image_size):
+    """Convert dataset annotations to COCO format for RT-DETR"""
+    annotations = []
+    for i, (bbox, category) in enumerate(zip(objects["bbox"], objects["category"])):
+        # CPPE-5 bbox format: [x, y, width, height]
+        annotations.append({
+            "id": i,
+            "image_id": image_id,
+            "category_id": category,
+            "bbox": bbox,
+            "area": bbox[2] * bbox[3],
+            "iscrowd": 0,
+        })
+    return {
+        "image_id": image_id,
+        "annotations": annotations,
+    }
+
+def transform_batch(examples, image_processor):
+    """Transform a batch of examples for RT-DETR"""
+    images = []
+    annotations = []
+
+    for idx, (image, objects) in enumerate(zip(examples["image"], examples["objects"])):
+        # Convert to RGB if needed
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        images.append(image)
+
+        # Format annotations
+        anno = format_annotations(idx, objects, image.size)
+        annotations.append(anno)
+
+    # Process with image processor
+    result = image_processor(
+        images=images,
+        annotations=annotations,
+        return_tensors="pt",
+    )
+
+    return result
+
+# Apply transforms
+print("\nPreparing datasets...")
+transform_fn = partial(transform_batch, image_processor=image_processor)
+
+# Process in batches
+train_dataset = dataset["train"].with_transform(
+    lambda x: transform_fn(x)
+)
+eval_dataset = dataset["test"].with_transform(
+    lambda x: transform_fn(x)
+)
+
+# ============================================================================
+# Custom Collator
+# ============================================================================
+def collate_fn(batch):
+    """Custom collate function for object detection"""
+    pixel_values = torch.stack([item["pixel_values"] for item in batch])
+    labels = [item["labels"] for item in batch]
+
+    return {
+        "pixel_values": pixel_values,
+        "labels": labels,
+    }
+
+# ============================================================================
+# Training Arguments
+# ============================================================================
+training_args = TrainingArguments(
+    output_dir=OUTPUT_DIR,
+
+    # Training params
+    num_train_epochs=NUM_EPOCHS,
+    per_device_train_batch_size=BATCH_SIZE,
+    per_device_eval_batch_size=BATCH_SIZE,
+    learning_rate=LEARNING_RATE,
+    weight_decay=0.01,
+
+    # Optimization
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.1,
+    fp16=True,  # Mixed precision
+    gradient_accumulation_steps=4,
+
+    # Logging & saving
+    logging_steps=10,
+    eval_strategy="epoch",
+    save_strategy="epoch",
+    save_total_limit=2,
+    load_best_model_at_end=True,
+    metric_for_best_model="eval_loss",
+
+    # Hub
+    push_to_hub=True,
+    hub_model_id=HUB_MODEL_ID,
+    hub_strategy="end",
+
+    # Other
+    remove_unused_columns=False,
+    dataloader_num_workers=2,
+)
+
+# ============================================================================
+# Trainer
+# ============================================================================
+print("\nInitializing Trainer...")
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    processing_class=image_processor,
+    data_collator=collate_fn,
+)
+
+# ============================================================================
+# Train!
+# ============================================================================
+print("\nStarting training...")
+print(f"  Epochs: {NUM_EPOCHS}")
+print(f"  Batch size: {BATCH_SIZE}")
+print(f"  Learning rate: {LEARNING_RATE}")
+print("="*60)
+
+trainer.train()
+
+# ============================================================================
+# Save & Push to Hub
+# ============================================================================
+print("\nSaving model...")
+trainer.save_model()
+image_processor.save_pretrained(OUTPUT_DIR)
+
+print("\nPushing to Hub...")
+trainer.push_to_hub()
+
+print("\n" + "="*60)
+print("Training complete!")
+print(f"Model: https://huggingface.co/{HUB_MODEL_ID}")
+print("="*60)
+
+# ============================================================================
+# Quick Inference Test
+# ============================================================================
+print("\nRunning quick inference test...")
+test_image = dataset["test"][0]["image"]
+if test_image.mode != "RGB":
+    test_image = test_image.convert("RGB")
+
+inputs = image_processor(images=test_image, return_tensors="pt")
+inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+with torch.no_grad():
+    outputs = model(**inputs)
+
+# Post-process
+results = image_processor.post_process_object_detection(
+    outputs,
+    target_sizes=torch.tensor([test_image.size[::-1]]),
+    threshold=0.5
+)[0]
+
+print(f"Detected {len(results['labels'])} objects:")
+for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+    print(f"  - {id2label[label.item()]}: {score.item():.2f}")
+
+print("\nDone!")