Add dataset card creation and visualization script for object detection results

detect-objects.py

@@ -37,19 +37,14 @@ Examples:
         --class-name table \\
         --max-samples 10
 
-    # Run on HF Jobs with L4 GPU
-    hf jobs uv run --flavor l4x1 \\
-        -s HF_TOKEN=$HF_TOKEN \\
+    # Run on HF Jobs with GPU
+    hf jobs uv run --flavor a100-large \\
+        -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.
 """
@@ -58,12 +53,13 @@ import argparse
 import logging
 import os
 import sys
+import time
 from typing import Any, Dict, List
 
 import torch
 from datasets import ClassLabel, Dataset, Features, Sequence, Value, load_dataset
 from datasets import Image as ImageFeature
-from huggingface_hub import HfApi, login
+from huggingface_hub import DatasetCard, HfApi, login
 from PIL import Image
 from tqdm.auto import tqdm
 from transformers import Sam3Model, Sam3Processor
@@ -171,6 +167,196 @@ def parse_args():
     return parser.parse_args()
 
 
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    class_name: str,
+    num_samples: int,
+    total_detections: int,
+    images_with_detections: int,
+    processing_time: str,
+    confidence_threshold: float,
+    mask_threshold: float,
+    batch_size: int,
+    dtype: str,
+    image_column: str = "image",
+    split: str = "train",
+) -> str:
+    """Create a dataset card documenting the object detection process."""
+    from datetime import datetime
+
+    model_name = model.split("/")[-1]
+    avg_detections = total_detections / num_samples if num_samples > 0 else 0
+    detection_rate = (
+        (images_with_detections / num_samples * 100) if num_samples > 0 else 0
+    )
+
+    return f"""---
+tags:
+- object-detection
+- sam3
+- segment-anything
+- bounding-boxes
+- uv-script
+- generated
+---
+
+# Object Detection: {class_name.title()} Detection using {model_name}
+
+This dataset contains object detection results (bounding boxes) for **{class_name}** detected in images from [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using Meta's SAM3 (Segment Anything Model 3).
+
+**Generated using**: [uv-scripts/sam3](https://huggingface.co/datasets/uv-scripts/sam3) detection script
+
+## Detection Statistics
+
+- **Objects Detected**: {class_name}
+- **Total Detections**: {total_detections:,}
+- **Images with Detections**: {images_with_detections:,} / {num_samples:,} ({detection_rate:.1f}%)
+- **Average Detections per Image**: {avg_detections:.2f}
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Script Repository**: [uv-scripts/sam3](https://huggingface.co/datasets/uv-scripts/sam3)
+- **Number of Samples Processed**: {num_samples:,}
+- **Processing Time**: {processing_time}
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+
+### Configuration
+
+- **Image Column**: `{image_column}`
+- **Dataset Split**: `{split}`
+- **Class Name**: `{class_name}`
+- **Confidence Threshold**: {confidence_threshold}
+- **Mask Threshold**: {mask_threshold}
+- **Batch Size**: {batch_size}
+- **Model Dtype**: {dtype}
+
+## Model Information
+
+SAM3 (Segment Anything Model 3) is Meta's state-of-the-art object detection and segmentation model that excels at:
+- 🎯 **Zero-shot detection** - Detect objects using natural language prompts
+- 📦 **Bounding boxes** - Accurate object localization
+- 🎭 **Instance segmentation** - Pixel-perfect masks (not included in this dataset)
+- 🖼️ **Any image domain** - Works on photos, documents, medical images, etc.
+
+This dataset uses SAM3 in text-prompted detection mode to find instances of "{class_name}" in the source images.
+
+## Dataset Structure
+
+The dataset contains all original columns from the source dataset plus an `objects` column with detection results in HuggingFace object detection format (dict-of-lists):
+
+- **bbox**: List of bounding boxes in `[x, y, width, height]` format (pixel coordinates)
+- **category**: List of category indices (always `0` for single-class detection)
+- **score**: List of confidence scores (0.0 to 1.0)
+
+### Schema
+
+```python
+{{
+    "objects": {{
+        "bbox": [[x, y, w, h], ...],      # List of bounding boxes
+        "category": [0, 0, ...],           # All same class
+        "score": [0.95, 0.87, ...]        # Confidence scores
+    }}
+}}
+```
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+# Load the dataset
+dataset = load_dataset("{{{{output_dataset_id}}}}", split="{split}")
+
+# Access detections for an image
+example = dataset[0]
+detections = example["objects"]
+
+# Iterate through all detected objects in this image
+for bbox, category, score in zip(
+    detections["bbox"],
+    detections["category"],
+    detections["score"]
+):
+    x, y, w, h = bbox
+    print(f"Detected {class_name} at ({x}, {y}) with confidence {{score:.2f}}")
+
+# Filter high-confidence detections
+high_conf_examples = [
+    ex for ex in dataset
+    if any(score > 0.8 for score in ex["objects"]["score"])
+]
+
+# Count total detections across dataset
+total = sum(len(ex["objects"]["bbox"]) for ex in dataset)
+print(f"Total detections: {{total}}")
+```
+
+## Visualization
+
+To visualize the detections, you can use the visualization script from the same repository:
+
+```bash
+# Visualize first sample with detections
+uv run https://huggingface.co/datasets/uv-scripts/sam3/raw/main/visualize-detections.py \\
+    {{{{output_dataset_id}}}} \\
+    --first-with-detections
+
+# Visualize random samples
+uv run https://huggingface.co/datasets/uv-scripts/sam3/raw/main/visualize-detections.py \\
+    {{{{output_dataset_id}}}} \\
+    --num-samples 5
+
+# Save visualizations to files
+uv run https://huggingface.co/datasets/uv-scripts/sam3/raw/main/visualize-detections.py \\
+    {{{{output_dataset_id}}}} \\
+    --num-samples 3 \\
+    --output-dir ./visualizations
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/sam3](https://huggingface.co/datasets/uv-scripts/sam3) object detection script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/sam3/raw/main/detect-objects.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --class-name {class_name} \\
+    --confidence-threshold {confidence_threshold} \\
+    --mask-threshold {mask_threshold} \\
+    --batch-size {batch_size} \\
+    --dtype {dtype}
+```
+
+### Running on HuggingFace Jobs (GPU)
+
+This script requires a GPU. To run on HuggingFace infrastructure:
+
+```bash
+hf jobs uv run --flavor a100-large \\
+    -s HF_TOKEN=HF_TOKEN \\
+    https://huggingface.co/datasets/uv-scripts/sam3/raw/main/detect-objects.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --class-name {class_name} \\
+    --confidence-threshold {confidence_threshold}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60) if processing_time.split()[0].replace(".", "").isdigit() else "N/A":.1f} images/second
+- **GPU Configuration**: CUDA with {dtype} precision
+
+---
+
+Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
+"""
+
+
 def load_and_validate_dataset(
     dataset_id: str,
     split: str,
@@ -225,9 +411,7 @@ def process_batch(
     for img in images:
         if isinstance(img, str):
             img = Image.open(img)
-        if img.mode == "L":
-            img = img.convert("RGB")
-        elif img.mode != "RGB":
+        if img.mode == "L" or img.mode != "RGB":
             img = img.convert("RGB")
         pil_images.append(img)
 
@@ -356,6 +540,7 @@ def main():
 
     # Process dataset with explicit output features
     logger.info("🔍 Processing images...")
+    start_time = time.time()
     processed_dataset = dataset.map(
         lambda batch: process_batch(
             batch,
@@ -371,6 +556,9 @@ def main():
         features=new_features,
         desc="Detecting objects",
     )
+    end_time = time.time()
+    processing_time_seconds = end_time - start_time
+    processing_time_str = f"{processing_time_seconds / 60:.1f} minutes"
 
     # Calculate statistics
     total_detections = sum(len(objs) for objs in processed_dataset["objects"])
@@ -399,6 +587,28 @@ def main():
         logger.info("✅ Saved to ./output_dataset")
         sys.exit(1)
 
+    # Create and push dataset card
+    logger.info("📝 Creating dataset card...")
+    card_content = create_dataset_card(
+        source_dataset=args.input_dataset,
+        model=args.model,
+        class_name=class_name,
+        num_samples=len(processed_dataset),
+        total_detections=total_detections,
+        images_with_detections=images_with_detections,
+        processing_time=processing_time_str,
+        confidence_threshold=args.confidence_threshold,
+        mask_threshold=args.mask_threshold,
+        batch_size=args.batch_size,
+        dtype=args.dtype,
+        image_column=args.image_column,
+        split=args.split,
+    )
+
+    card = DatasetCard(card_content)
+    card.push_to_hub(args.output_dataset, token=args.hf_token or os.getenv("HF_TOKEN"))
+    logger.info("✅ Dataset card created and pushed!")
+
 
 if __name__ == "__main__":
     main()

visualize-detections.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "matplotlib",
+#     "pillow",
+# ]
+# ///
+
+"""
+Visualize object detection predictions from a HuggingFace dataset.
+
+This script loads a dataset with object detection predictions and visualizes
+the bounding boxes on sample images.
+
+Examples:
+    # Visualize the first sample with detections
+    uv run visualize-detections.py my-username/detected-objects --first-with-detections
+
+    # Visualize a specific sample
+    uv run visualize-detections.py my-username/detected-objects --index 0
+
+    # Visualize multiple random samples
+    uv run visualize-detections.py my-username/detected-objects --num-samples 5
+
+    # Save visualizations to files instead of displaying
+    uv run visualize-detections.py my-username/detected-objects --num-samples 3 --output-dir ./visualizations
+
+    # Visualize specific split
+    uv run visualize-detections.py my-username/detected-objects --split train --num-samples 5
+"""
+
+import argparse
+import random
+from pathlib import Path
+
+import matplotlib.patches as patches
+import matplotlib.pyplot as plt
+from datasets import load_dataset
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Visualize object detection predictions",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+
+    parser.add_argument(
+        "dataset_id", help="HuggingFace dataset ID (e.g., 'username/dataset')"
+    )
+    parser.add_argument(
+        "--index",
+        type=int,
+        default=None,
+        help="Index of sample to visualize (default: random)",
+    )
+    parser.add_argument(
+        "--num-samples",
+        type=int,
+        default=1,
+        help="Number of samples to visualize (default: 1)",
+    )
+    parser.add_argument(
+        "--first-with-detections",
+        action="store_true",
+        help="Find and visualize the first sample with detections",
+    )
+    parser.add_argument(
+        "--split", default="train", help="Dataset split to use (default: 'train')"
+    )
+    parser.add_argument(
+        "--image-column",
+        default="image",
+        help="Name of the image column (default: 'image')",
+    )
+    parser.add_argument(
+        "--objects-column",
+        default="objects",
+        help="Name of the objects column (default: 'objects')",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default=None,
+        help="Directory to save visualizations (default: show interactively)",
+    )
+    parser.add_argument(
+        "--figsize-width",
+        type=int,
+        default=15,
+        help="Figure width in inches (default: 15)",
+    )
+    parser.add_argument(
+        "--figsize-height",
+        type=int,
+        default=20,
+        help="Figure height in inches (default: 20)",
+    )
+    parser.add_argument(
+        "--bbox-color",
+        default="red",
+        help="Color for bounding boxes (default: 'red')",
+    )
+    parser.add_argument(
+        "--show-scores",
+        action="store_true",
+        default=True,
+        help="Show confidence scores on bounding boxes",
+    )
+
+    return parser.parse_args()
+
+
+def visualize_sample(
+    sample,
+    image_column="image",
+    objects_column="objects",
+    figsize=(15, 20),
+    bbox_color="red",
+    show_scores=True,
+    title=None,
+):
+    """Visualize a single sample with bounding boxes."""
+    image = sample[image_column]
+    objects = sample[objects_column]
+
+    fig, ax = plt.subplots(1, figsize=figsize)
+    ax.imshow(image, cmap="gray" if image.mode == "L" else None)
+
+    # Draw bounding boxes
+    num_detections = len(objects["bbox"])
+    for i in range(num_detections):
+        bbox = objects["bbox"][i]
+        score = objects["score"][i]
+        category = objects["category"][i]
+
+        x, y, w, h = bbox
+        rect = patches.Rectangle(
+            (x, y), w, h, linewidth=2, edgecolor=bbox_color, facecolor="none"
+        )
+        ax.add_patch(rect)
+
+        if show_scores:
+            label = f"{score:.2f}"
+            ax.text(
+                x,
+                y - 5,
+                label,
+                color=bbox_color,
+                fontsize=10,
+                bbox=dict(facecolor="white", alpha=0.7),
+            )
+
+    # Set title
+    if title:
+        ax.set_title(title, fontsize=14, pad=20)
+    else:
+        ax.set_title(f"Detections: {num_detections}", fontsize=14, pad=20)
+
+    ax.axis("off")
+    plt.tight_layout()
+
+    return fig, ax
+
+
+def main():
+    args = parse_args()
+
+    # Load dataset
+    print(f"📂 Loading dataset: {args.dataset_id} (split: {args.split})")
+    dataset = load_dataset(args.dataset_id, split=args.split)
+    print(f"✅ Loaded {len(dataset)} samples")
+
+    # Determine indices to visualize
+    if args.index is not None:
+        indices = [args.index]
+    elif args.first_with_detections:
+        # Find first sample with detections
+        print("🔍 Finding first sample with detections...")
+        first_idx = None
+        for idx in range(len(dataset)):
+            sample = dataset[idx]
+            if len(sample[args.objects_column]["bbox"]) > 0:
+                first_idx = idx
+                break
+
+        if first_idx is None:
+            print("❌ No samples with detections found in dataset")
+            return
+
+        print(f"✅ Found first sample with detections at index {first_idx}")
+        indices = [first_idx]
+    else:
+        # Select random samples
+        indices = random.sample(range(len(dataset)), min(args.num_samples, len(dataset)))
+
+    # Create output directory if saving
+    if args.output_dir:
+        output_path = Path(args.output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+        print(f"💾 Saving visualizations to: {output_path}")
+
+    # Visualize samples
+    figsize = (args.figsize_width, args.figsize_height)
+
+    for idx in indices:
+        sample = dataset[idx]
+        num_detections = len(sample[args.objects_column]["bbox"])
+
+        print(f"\n🖼️  Sample {idx}: {num_detections} detections")
+
+        # Create visualization
+        title = f"Sample {idx} - {num_detections} detections"
+        fig, ax = visualize_sample(
+            sample,
+            image_column=args.image_column,
+            objects_column=args.objects_column,
+            figsize=figsize,
+            bbox_color=args.bbox_color,
+            show_scores=args.show_scores,
+            title=title,
+        )
+
+        # Save or show
+        if args.output_dir:
+            output_file = output_path / f"sample_{idx}.png"
+            plt.savefig(output_file, dpi=150, bbox_inches="tight")
+            print(f"   Saved: {output_file}")
+            plt.close(fig)
+        else:
+            plt.show()
+
+    if args.output_dir:
+        print(f"\n✅ Saved {len(indices)} visualizations to {args.output_dir}")
+
+
+if __name__ == "__main__":
+    main()