Refactor object detection script to use single class detection and update argument naming

detect-objects.py

@@ -15,39 +15,43 @@
 """
 Detect objects in images using Meta's SAM3 (Segment Anything Model 3).
 
-This script processes images from a HuggingFace dataset and detects objects
-based on text prompts, outputting bounding boxes in HuggingFace object detection format.
+This script processes images from a HuggingFace dataset and detects a single object
+type based on a text prompt, outputting bounding boxes in HuggingFace object detection format.
 
 Examples:
     # Detect photographs in historical newspapers
     uv run detect-objects.py \\
         davanstrien/newspapers-with-images-after-photography \\
         my-username/newspapers-detected \\
-        --classes photograph
+        --class-name photograph
 
-    # Detect multiple object types
+    # Detect animals in camera trap images
     uv run detect-objects.py \\
-        my-dataset \\
-        my-output \\
-        --classes "photograph,illustration,headline" \\
-        --confidence-threshold 0.7
+        wildlife-images \\
+        wildlife-detected \\
+        --class-name animal \\
+        --confidence-threshold 0.6
 
     # Test on small subset
     uv run detect-objects.py input output \\
-        --classes photo \\
+        --class-name table \\
         --max-samples 10
 
     # Run on HF Jobs with L4 GPU
-    hfjobs run --flavor l4x1 \\
-        -e HF_TOKEN=$HF_TOKEN \\
-        ghcr.io/astral-sh/uv:latest \\
-        /bin/bash -c "uv run https://huggingface.co/datasets/uv-scripts/sam3/raw/main/detect-objects.py \\
-            input-dataset output-dataset --classes 'photo,illustration'"
+    hf jobs uv run --flavor l4x1 \\
+        -s HF_TOKEN=$HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/sam3/raw/main/detect-objects.py \\
+        input-dataset output-dataset \\
+        --class-name photograph \\
+        --confidence-threshold 0.5
 
 Performance:
     - L4 GPU: ~2-4 images/sec (depending on image size and batch size)
     - Memory: ~8-12 GB VRAM
     - Recommended batch size: 4-8 for L4, 8-16 for A10
+
+Note: To detect multiple object types, run the script multiple times with different
+      --class-name values and merge the results.
 """
 
 import argparse
@@ -98,9 +102,9 @@ def parse_args():
 
     # Object detection configuration
     parser.add_argument(
-        "--classes",
+        "--class-name",
         required=True,
-        help="Comma-separated list of object classes to detect (e.g., 'photograph,illustration,diagram')",
+        help="Object class to detect (e.g., 'photograph', 'animal', 'table')",
     )
     parser.add_argument(
         "--confidence-threshold",
@@ -206,13 +210,13 @@ def load_and_validate_dataset(
 def process_batch(
     batch: Dict[str, List[Any]],
     image_column: str,
-    class_names: List[str],
+    class_name: str,
     processor: Sam3Processor,
     model: Sam3Model,
     confidence_threshold: float,
     mask_threshold: float,
 ) -> Dict[str, List[List[Dict[str, Any]]]]:
-    """Process a batch of images and return detections."""
+    """Process a batch of images and return detections for a single class."""
     images = batch[image_column]
 
     # Convert to PIL Images and ensure RGB
@@ -231,7 +235,7 @@ def process_batch(
     try:
         inputs = processor(
             images=pil_images,
-            text=class_names,  # All class names as prompts
+            text=class_name,  # Single class name as prompt
             return_tensors="pt",
         )
         # Move to device and convert to model's dtype
@@ -264,7 +268,6 @@ def process_batch(
     for result in results:
         boxes = result.get("boxes", torch.tensor([]))
         scores = result.get("scores", torch.tensor([]))
-        labels = result.get("labels", torch.tensor([]))
 
         # Handle empty results
         if len(boxes) == 0:
@@ -273,16 +276,14 @@ def process_batch(
 
         # Build list of detections
         detections = []
-        for box, score, label_idx in zip(
-            boxes.cpu().numpy(), scores.cpu().numpy(), labels.cpu().numpy()
-        ):
+        for box, score in zip(boxes.cpu().numpy(), scores.cpu().numpy()):
             x1, y1, x2, y2 = box
             width = x2 - x1
             height = y2 - y1
 
             detection = {
                 "bbox": [float(x1), float(y1), float(width), float(height)],
-                "category": int(label_idx),  # Index into class_names
+                "category": 0,  # Single class, always index 0
                 "score": float(score),
             }
             detections.append(detection)
@@ -294,18 +295,16 @@ def process_batch(
 
 def main():
     args = parse_args()
-    # Parse class names
-    class_names = [name.strip() for name in args.classes.split(",")]
-    if not class_names or not all(class_names):
-        logger.error(
-            "❌ Invalid --classes argument. Provide comma-separated class names."
-        )
+
+    class_name = args.class_name.strip()
+    if not class_name:
+        logger.error("❌ Invalid --class-name argument. Provide a class name.")
         sys.exit(1)
 
     logger.info("🚀 SAM3 Object Detection")
     logger.info(f"   Input: {args.input_dataset}")
     logger.info(f"   Output: {args.output_dataset}")
-    logger.info(f"   Classes: {class_names}")
+    logger.info(f"   Class: {class_name}")
     logger.info(f"   Confidence threshold: {args.confidence_threshold}")
     logger.info(f"   Batch size: {args.batch_size}")
 
@@ -344,7 +343,7 @@ def main():
         lambda batch: process_batch(
             batch,
             args.image_column,
-            class_names,
+            class_name,
             processor,
             model,
             args.confidence_threshold,
@@ -361,7 +360,7 @@ def main():
     new_features["objects"] = Sequence(
         {
             "bbox": Sequence(Value("float32"), length=4),
-            "category": ClassLabel(names=class_names),
+            "category": ClassLabel(names=[class_name]),
             "score": Value("float32"),
         }
     )