Add segment-objects.py for pixel-level image segmentation

New script that produces segmentation masks (semantic maps or per-instance
binary masks) using SAM3 with text prompts. Tested on HF Jobs with wildlife
camera trap images. Also updates README to document both scripts and adds
example segmentation image.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

README.md

@@ -1,14 +1,27 @@
 ---
 viewer: false
-tags: [uv-script, computer-vision, object-detection, sam3, image-processing, hf-jobs]
+tags: [uv-script, computer-vision, object-detection, image-segmentation, sam3, image-processing, hf-jobs]
 license: apache-2.0
 ---
 
-# SAM3 Object Detection
+# SAM3 Vision Scripts
 
-Detect objects in images using Meta's [sam3](https://huggingface.co/facebook/sam3) (Segment Anything Model 3) with text prompts. Process HuggingFace datasets with zero-shot object detection using natural language descriptions.
+Detect and segment objects in images using Meta's **SAM3** (Segment Anything Model 3) with text prompts. Process HuggingFace datasets with zero-shot detection and segmentation using natural language descriptions.
 
-## Quick Start
+| Script | What it does | Output |
+|--------|-------------|--------|
+| `detect-objects.py` | Object detection with bounding boxes | `objects` column with bbox, category, score |
+| `segment-objects.py` | Pixel-level segmentation masks | Segmentation maps or per-instance masks |
+
+Browse results interactively: **[SAM3 Results Browser](https://huggingface.co/spaces/uv-scripts/sam3-detection-browser)**
+
+---
+
+## Object Detection (`detect-objects.py`)
+
+Detect objects and output bounding boxes in HuggingFace object detection format.
+
+### Quick Start
 
 **Requires GPU.** Use HuggingFace Jobs for cloud execution:
 
@@ -21,9 +34,7 @@ hf jobs uv run --flavor a100-large \
     --class-name photograph
 ```
 
-## Example Output
-
-Here's an example of detected objects (photographs in historical newspapers) with bounding boxes and confidence scores:
+### Example Output
 
 <div style="max-width: 400px;">
 <img src="./example-detection.png" alt="Example Detection" style="width: 100%; height: auto;"/>
@@ -32,35 +43,101 @@ _Photograph detected in a historical newspaper with bounding box and confidence
 
 </div>
 
-## Local Execution
+### Arguments
 
-If you have a CUDA GPU locally:
+**Required:**
+
+- `input_dataset` - Input HF dataset ID
+- `output_dataset` - Output HF dataset ID
+- `--class-name` - Object class to detect (e.g., `"photograph"`, `"animal"`, `"table"`)
+
+**Common options:**
+
+- `--confidence-threshold FLOAT` - Min confidence (default: 0.5)
+- `--batch-size INT` - Batch size (default: 4)
+- `--max-samples INT` - Limit samples for testing
+- `--image-column STR` - Image column name (default: "image")
+- `--private` - Make output private
+
+<details>
+<summary>All options</summary>
+
+```
+--mask-threshold FLOAT       Mask generation threshold (default: 0.5)
+--split STR                  Dataset split (default: "train")
+--shuffle                    Shuffle before processing
+--model STR                  Model ID (default: "facebook/sam3")
+--dtype STR                  Precision: float32|float16|bfloat16
+--hf-token STR               HF token (or use HF_TOKEN env var)
+```
+
+</details>
+
+### Output Format
+
+Adds `objects` column with ClassLabel-based detections:
+
+```python
+{
+    "objects": [
+        {
+            "bbox": [x, y, width, height],
+            "category": 0,  # Always 0 for single class
+            "score": 0.87
+        }
+    ]
+}
+```
+
+---
+
+## Image Segmentation (`segment-objects.py`)
+
+Produce pixel-level segmentation masks for objects matching a text prompt. Two output formats available.
+
+### Quick Start
 
 ```bash
-uv run detect-objects.py INPUT OUTPUT --class-name CLASSNAME
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN=HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/sam3/raw/main/segment-objects.py \
+    input-dataset \
+    output-dataset \
+    --class-name deer
 ```
 
-## Arguments
+### Example Output
+
+<div style="max-width: 400px;">
+<img src="./example-segmentation.png" alt="Example Segmentation" style="width: 100%; height: auto;"/>
+
+_Deer segmented in a wildlife camera trap image with pixel-level mask and bounding box. Generated from [davanstrien/ena24-detection](https://huggingface.co/datasets/davanstrien/ena24-detection)._
+
+</div>
+
+### Arguments
 
 **Required:**
 
 - `input_dataset` - Input HF dataset ID
 - `output_dataset` - Output HF dataset ID
-- `--class-name` - Object class to detect (e.g., `"photograph"`, `"animal"`, `"table"`)
+- `--class-name` - Object class to segment (e.g., `"deer"`, `"animal"`, `"table"`)
 
 **Common options:**
 
+- `--output-format` - `semantic-mask` (default) or `instance-masks`
 - `--confidence-threshold FLOAT` - Min confidence (default: 0.5)
+- `--include-boxes` - Also output bounding boxes
 - `--batch-size INT` - Batch size (default: 4)
 - `--max-samples INT` - Limit samples for testing
-- `--image-column STR` - Image column name (default: "image")
 - `--private` - Make output private
 
 <details>
 <summary>All options</summary>
 
 ```
---mask-threshold FLOAT       Mask generation threshold (default: 0.5)
+--mask-threshold FLOAT       Mask binarization threshold (default: 0.5)
+--image-column STR           Image column name (default: "image")
 --split STR                  Dataset split (default: "train")
 --shuffle                    Shuffle before processing
 --model STR                  Model ID (default: "facebook/sam3")
@@ -70,48 +147,59 @@ uv run detect-objects.py INPUT OUTPUT --class-name CLASSNAME
 
 </details>
 
-## HuggingFace Jobs Examples
+### Output Formats
 
-### Historical Newspapers
+**Semantic mask** (`--output-format semantic-mask`, default):
+- Adds `segmentation_map` column: single image per sample where pixel value = instance ID (0 = background)
+- More compact, viewable in the HF dataset viewer
+- Also adds `num_instances` and `scores` columns
+
+**Instance masks** (`--output-format instance-masks`):
+- Adds `segmentation_masks` column: list of binary mask images (one per detected instance)
+- Also adds `scores` and `category` columns
+- Best for extracting individual objects or creating training data
+
+### Example
 
-Detect photographs in historical newspaper scans:
+Segment deer in wildlife camera trap images:
 
 ```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 \
-    davanstrien/newspapers-with-images-after-photography \
-    my-username/newspapers-detected \
-    --class-name photograph \
-    --confidence-threshold 0.6 \
-    --batch-size 8
+    https://huggingface.co/datasets/uv-scripts/sam3/raw/main/segment-objects.py \
+    davanstrien/ena24-detection \
+    my-username/wildlife-segmented \
+    --class-name deer \
+    --include-boxes
 ```
 
-### Document Tables
+---
+
+## HuggingFace Jobs Examples
 
-Extract tables from document scans:
+### Historical Newspapers
 
 ```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 \
-    my-documents \
-    documents-with-tables \
-    --class-name table
+    davanstrien/newspapers-with-images-after-photography \
+    my-username/newspapers-detected \
+    --class-name photograph \
+    --confidence-threshold 0.6 \
+    --batch-size 8
 ```
 
 ### Wildlife Camera Traps
 
-Detect animals in camera trap images:
-
 ```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 \
+    https://huggingface.co/datasets/uv-scripts/sam3/raw/main/segment-objects.py \
     wildlife-images \
-    wildlife-detections \
+    wildlife-segmented \
     --class-name animal \
-    --confidence-threshold 0.5
+    --include-boxes
 ```
 
 ### Quick Testing
@@ -121,14 +209,14 @@ Test on a small subset before full run:
 ```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 \
+    https://huggingface.co/datasets/uv-scripts/sam3/raw/main/segment-objects.py \
     large-dataset \
     test-output \
     --class-name object \
     --max-samples 20
 ```
 
-### Using Different GPU Flavors
+### GPU Flavors
 
 ```bash
 # L4 (cost-effective)
@@ -140,50 +228,25 @@ hf jobs uv run --flavor a100-large \
 
 See [HF Jobs pricing](https://huggingface.co/pricing#spaces-compute).
 
-## Output Format
-
-Adds `objects` column with ClassLabel-based detections:
-
-```python
-{
-    "objects": [
-        {
-            "bbox": [x, y, width, height],
-            "category": 0,  # Always 0 for single class
-            "score": 0.87
-        }
-    ]
-}
-```
-
-Load and use:
-
-```python
-from datasets import load_dataset
+## Local Execution
 
-ds = load_dataset("username/output", split="train")
+If you have a CUDA GPU locally:
 
-# ClassLabel feature preserves your class name
-class_name = ds.features["objects"].feature["category"].names[0]
-print(f"Detected class: {class_name}")
+```bash
+# Detection
+uv run detect-objects.py INPUT OUTPUT --class-name CLASSNAME
 
-for sample in ds:
-    for obj in sample["objects"]:
-        print(f"{class_name}: {obj['score']:.2f} at {obj['bbox']}")
+# Segmentation
+uv run segment-objects.py INPUT OUTPUT --class-name CLASSNAME
 ```
 
-## Detecting Multiple Object Types
+## Multiple Object Types
 
-To detect multiple object types, run the script multiple times with different `--class-name` values:
+Run the script multiple times with different `--class-name` values:
 
 ```bash
-# Detect photographs
 hf jobs uv run ... --class-name photograph
-
-# Detect illustrations
 hf jobs uv run ... --class-name illustration
-
-# Merge results as needed
 ```
 
 ## Performance
@@ -211,17 +274,12 @@ _Varies by image size and detection complexity_
 
 ## About SAM3
 
-[SAM3](https://huggingface.co/facebook/sam3) is Meta's zero-shot vision model. Describe any object in natural language and it will detect it—no training required.
-
-**Note:** This script uses transformers from git (SAM3 not yet in stable release).
+[SAM3](https://huggingface.co/facebook/sam3) is Meta's zero-shot vision model. Describe any object in natural language and it will detect and segment it — no training required.
 
 ## See Also
 
-More UV scripts at [huggingface.co/uv-scripts](https://huggingface.co/uv-scripts):
-
-- **dataset-creation** - Create HF datasets from files
-- **vllm** - Fast LLM inference
-- **ocr** - Document OCR
+- **[SAM3 Results Browser](https://huggingface.co/spaces/uv-scripts/sam3-detection-browser)** - Browse detection and segmentation results interactively
+- More UV scripts at [huggingface.co/uv-scripts](https://huggingface.co/uv-scripts)
 
 ## License
 

segment-objects.py

@@ -0,0 +1,558 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "transformers>=5.4.0",
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "torch",
+#     "torchvision",
+#     "accelerate",
+# ]
+# ///
+
+"""
+Segment objects in images using Meta's SAM3 (Segment Anything Model 3).
+
+This script processes images from a HuggingFace dataset and produces pixel-level
+segmentation masks for objects matching a text prompt. Outputs either per-instance
+binary masks or a combined semantic segmentation map.
+
+Examples:
+    # Segment photographs in historical newspapers (instance masks)
+    uv run segment-objects.py \\
+        davanstrien/newspapers-with-images-after-photography \\
+        my-username/newspapers-segmented \\
+        --class-name photograph
+
+    # Segment with semantic map output (single image per sample)
+    uv run segment-objects.py \\
+        wildlife-images \\
+        wildlife-segmented \\
+        --class-name animal \\
+        --output-format semantic-mask
+
+    # Include bounding boxes alongside masks
+    uv run segment-objects.py \\
+        input-dataset output-dataset \\
+        --class-name table \\
+        --include-boxes
+
+    # Test on small subset
+    uv run segment-objects.py input output \\
+        --class-name table \\
+        --max-samples 10
+
+    # 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/segment-objects.py \\
+        input-dataset output-dataset \\
+        --class-name photograph
+
+Note: To segment multiple object types, run the script multiple times with different
+      --class-name values.
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+from typing import Any
+
+import numpy as np
+import torch
+from datasets import ClassLabel, Dataset, Sequence, Value, load_dataset
+from datasets import Image as ImageFeature
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from transformers import Sam3Model, Sam3Processor
+
+os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+if not torch.cuda.is_available():
+    logger.error("CUDA is not available. This script requires a GPU.")
+    logger.error("For cloud execution, use HF Jobs with --flavor l4x1 or similar.")
+    sys.exit(1)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Segment objects in images using SAM3",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+
+    parser.add_argument(
+        "input_dataset", help="Input HuggingFace dataset ID (e.g., 'username/dataset')"
+    )
+    parser.add_argument(
+        "output_dataset", help="Output HuggingFace dataset ID (e.g., 'username/output')"
+    )
+
+    parser.add_argument(
+        "--class-name",
+        required=True,
+        help="Object class to segment (e.g., 'photograph', 'animal', 'table')",
+    )
+    parser.add_argument(
+        "--output-format",
+        default="semantic-mask",
+        choices=["instance-masks", "semantic-mask"],
+        help="Output format: 'instance-masks' (one binary mask per object) or "
+        "'semantic-mask' (single image, pixel value = instance ID). Default: semantic-mask",
+    )
+    parser.add_argument(
+        "--confidence-threshold",
+        type=float,
+        default=0.5,
+        help="Minimum confidence score for detections (default: 0.5)",
+    )
+    parser.add_argument(
+        "--mask-threshold",
+        type=float,
+        default=0.5,
+        help="Threshold for mask binarization (default: 0.5)",
+    )
+    parser.add_argument(
+        "--include-boxes",
+        action="store_true",
+        help="Also include bounding boxes in output",
+    )
+
+    parser.add_argument(
+        "--image-column",
+        default="image",
+        help="Name of the column containing images (default: 'image')",
+    )
+    parser.add_argument(
+        "--split", default="train", help="Dataset split to process (default: 'train')"
+    )
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        default=None,
+        help="Maximum number of samples to process (for testing)",
+    )
+    parser.add_argument(
+        "--shuffle", action="store_true", help="Shuffle dataset before processing"
+    )
+
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=4,
+        help="Batch size for processing (default: 4)",
+    )
+    parser.add_argument(
+        "--model",
+        default="facebook/sam3",
+        help="SAM3 model ID (default: 'facebook/sam3')",
+    )
+    parser.add_argument(
+        "--dtype",
+        default="bfloat16",
+        choices=["float32", "float16", "bfloat16"],
+        help="Model precision (default: 'bfloat16')",
+    )
+
+    parser.add_argument(
+        "--private", action="store_true", help="Make output dataset private"
+    )
+    parser.add_argument(
+        "--hf-token",
+        default=None,
+        help="HuggingFace token (default: uses HF_TOKEN env var or cached token)",
+    )
+
+    return parser.parse_args()
+
+
+def masks_to_semantic_map(masks: torch.Tensor) -> Image.Image:
+    """Combine per-instance binary masks into a single semantic segmentation map.
+
+    Pixel values: 0=background, 1=first instance, 2=second instance, etc.
+    Later instances take priority in overlapping regions.
+    """
+    if len(masks) == 0:
+        return Image.new("L", (1, 1), 0)
+
+    h, w = masks.shape[1], masks.shape[2]
+    seg_map = np.zeros((h, w), dtype=np.uint8)
+
+    for i, mask in enumerate(masks):
+        binary = mask.cpu().numpy().astype(bool)
+        seg_map[binary] = i + 1  # 0 is background
+
+    return Image.fromarray(seg_map, mode="L")
+
+
+def masks_to_instance_images(masks: torch.Tensor) -> list[Image.Image]:
+    """Convert per-instance mask tensors to a list of binary PIL Images."""
+    images = []
+    for mask in masks:
+        binary = (mask.cpu().numpy() * 255).astype(np.uint8)
+        images.append(Image.fromarray(binary, mode="L"))
+    return images
+
+
+def process_batch(
+    batch: dict[str, list[Any]],
+    image_column: str,
+    class_name: str,
+    processor: Sam3Processor,
+    model: Sam3Model,
+    confidence_threshold: float,
+    mask_threshold: float,
+    output_format: str,
+    include_boxes: bool,
+) -> dict[str, list]:
+    """Process a batch of images and return segmentation masks."""
+    images = batch[image_column]
+
+    pil_images = []
+    for img in images:
+        if isinstance(img, str):
+            img = Image.open(img)
+        if img.mode != "RGB":
+            img = img.convert("RGB")
+        pil_images.append(img)
+
+    try:
+        inputs = processor(
+            images=pil_images,
+            text=[class_name] * len(pil_images),
+            return_tensors="pt",
+        ).to(model.device, dtype=model.dtype)
+
+        with torch.no_grad():
+            outputs = model(**inputs)
+
+        results = processor.post_process_instance_segmentation(
+            outputs,
+            threshold=confidence_threshold,
+            mask_threshold=mask_threshold,
+            target_sizes=inputs.get("original_sizes").tolist(),
+        )
+
+    except Exception as e:
+        logger.warning(f"Failed to process batch: {e}")
+        return _empty_batch_result(len(pil_images), output_format, include_boxes)
+
+    batch_result: dict[str, list] = {}
+
+    if output_format == "semantic-mask":
+        batch_result["segmentation_map"] = []
+        batch_result["num_instances"] = []
+    else:
+        batch_result["segmentation_masks"] = []
+
+    batch_result["scores"] = []
+    batch_result["category"] = []
+    if include_boxes:
+        batch_result["boxes"] = []
+
+    for result in results:
+        masks = result.get("masks", torch.tensor([]))
+        scores = result.get("scores", torch.tensor([]))
+        boxes = result.get("boxes", torch.tensor([]))
+
+        scores_np = scores.cpu().float().numpy() if len(scores) > 0 else np.array([])
+        score_list = [float(s) for s in scores_np]
+        category_list = [0] * len(score_list)
+
+        if output_format == "semantic-mask":
+            batch_result["segmentation_map"].append(masks_to_semantic_map(masks))
+            batch_result["num_instances"].append(len(score_list))
+        else:
+            batch_result["segmentation_masks"].append(
+                masks_to_instance_images(masks) if len(masks) > 0 else []
+            )
+
+        batch_result["scores"].append(score_list)
+        batch_result["category"].append(category_list)
+
+        if include_boxes:
+            if len(boxes) > 0:
+                boxes_np = boxes.cpu().float().numpy()
+                box_list = []
+                for box in boxes_np:
+                    x1, y1, x2, y2 = box
+                    box_list.append(
+                        [float(x1), float(y1), float(x2 - x1), float(y2 - y1)]
+                    )
+                batch_result["boxes"].append(box_list)
+            else:
+                batch_result["boxes"].append([])
+
+    return batch_result
+
+
+def _empty_batch_result(
+    n: int, output_format: str, include_boxes: bool
+) -> dict[str, list]:
+    result: dict[str, list] = {}
+    if output_format == "semantic-mask":
+        result["segmentation_map"] = [Image.new("L", (1, 1), 0)] * n
+        result["num_instances"] = [0] * n
+    else:
+        result["segmentation_masks"] = [[]] * n
+    result["scores"] = [[]] * n
+    result["category"] = [[]] * n
+    if include_boxes:
+        result["boxes"] = [[]] * n
+    return result
+
+
+def load_and_validate_dataset(
+    dataset_id: str,
+    split: str,
+    image_column: str,
+    max_samples: int | None = None,
+    shuffle: bool = False,
+    hf_token: str | None = None,
+) -> Dataset:
+    logger.info(f"Loading dataset: {dataset_id} (split: {split})")
+
+    try:
+        dataset = load_dataset(dataset_id, split=split, token=hf_token)
+    except Exception as e:
+        logger.error(f"Failed to load dataset '{dataset_id}': {e}")
+        sys.exit(1)
+
+    if image_column not in dataset.column_names:
+        logger.error(f"Column '{image_column}' not found in dataset")
+        logger.error(f"Available columns: {dataset.column_names}")
+        sys.exit(1)
+
+    if shuffle:
+        logger.info("Shuffling dataset")
+        dataset = dataset.shuffle()
+
+    if max_samples is not None:
+        logger.info(f"Limiting to {max_samples} samples")
+        dataset = dataset.select(range(min(max_samples, len(dataset))))
+
+    logger.info(f"Loaded {len(dataset)} samples")
+    return dataset
+
+
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    class_name: str,
+    output_format: str,
+    num_samples: int,
+    total_detections: int,
+    images_with_detections: int,
+    processing_time: str,
+    confidence_threshold: float,
+    mask_threshold: float,
+    include_boxes: bool,
+) -> str:
+    from datetime import datetime
+
+    detection_rate = (
+        (images_with_detections / num_samples * 100) if num_samples > 0 else 0
+    )
+    avg_detections = total_detections / num_samples if num_samples > 0 else 0
+
+    format_desc = (
+        "per-instance binary masks"
+        if output_format == "instance-masks"
+        else "semantic segmentation maps"
+    )
+
+    return f"""---
+tags:
+- image-segmentation
+- sam3
+- segment-anything
+- segmentation-masks
+- uv-script
+- generated
+---
+
+# Image Segmentation: {class_name.title()} using SAM3
+
+This dataset contains **{format_desc}** for **{class_name}** segmented in images from [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using Meta's SAM3.
+
+**Generated using**: [uv-scripts/sam3](https://huggingface.co/datasets/uv-scripts/sam3) segmentation script
+
+## Statistics
+
+- **Objects Segmented**: {class_name}
+- **Total Instances**: {total_detections:,}
+- **Images with Detections**: {images_with_detections:,} / {num_samples:,} ({detection_rate:.1f}%)
+- **Average Instances per Image**: {avg_detections:.2f}
+- **Output Format**: {output_format}
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+- **Processing Time**: {processing_time}
+- **Confidence Threshold**: {confidence_threshold}
+- **Mask Threshold**: {mask_threshold}
+- **Includes Bounding Boxes**: {"Yes" if include_boxes else "No"}
+
+## Reproduction
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/sam3/raw/main/segment-objects.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --class-name {class_name} \\
+    --output-format {output_format} \\
+    --confidence-threshold {confidence_threshold} \\
+    --mask-threshold {mask_threshold}{"  --include-boxes" if include_boxes else ""}
+```
+
+---
+
+Generated with [UV Scripts](https://huggingface.co/uv-scripts)
+"""
+
+
+def main():
+    args = parse_args()
+
+    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 Image Segmentation")
+    logger.info(f"  Input: {args.input_dataset}")
+    logger.info(f"  Output: {args.output_dataset}")
+    logger.info(f"  Class: {class_name}")
+    logger.info(f"  Format: {args.output_format}")
+    logger.info(f"  Confidence threshold: {args.confidence_threshold}")
+    logger.info(f"  Batch size: {args.batch_size}")
+
+    if args.hf_token:
+        login(token=args.hf_token)
+    elif os.getenv("HF_TOKEN"):
+        login(token=os.getenv("HF_TOKEN"))
+
+    dataset = load_and_validate_dataset(
+        args.input_dataset,
+        args.split,
+        args.image_column,
+        args.max_samples,
+        args.shuffle,
+        args.hf_token,
+    )
+
+    logger.info(f"Loading SAM3 model: {args.model}")
+    try:
+        processor = Sam3Processor.from_pretrained(args.model)
+        model = Sam3Model.from_pretrained(
+            args.model, torch_dtype=getattr(torch, args.dtype), device_map="auto"
+        )
+        logger.info(f"Model loaded on {model.device}")
+    except Exception as e:
+        logger.error(f"Failed to load model: {e}")
+        logger.error("Ensure the model exists and you have access permissions")
+        sys.exit(1)
+
+    # Build output features
+    new_features = dataset.features.copy()
+    if args.output_format == "semantic-mask":
+        new_features["segmentation_map"] = ImageFeature()
+        new_features["num_instances"] = Value("int32")
+    else:
+        new_features["segmentation_masks"] = Sequence(ImageFeature())
+
+    new_features["scores"] = Sequence(Value("float32"))
+    new_features["category"] = Sequence(ClassLabel(names=[class_name]))
+
+    if args.include_boxes:
+        new_features["boxes"] = Sequence(Sequence(Value("float32"), length=4))
+
+    logger.info("Processing images...")
+    start_time = time.time()
+    processed_dataset = dataset.map(
+        lambda batch: process_batch(
+            batch,
+            args.image_column,
+            class_name,
+            processor,
+            model,
+            args.confidence_threshold,
+            args.mask_threshold,
+            args.output_format,
+            args.include_boxes,
+        ),
+        batched=True,
+        batch_size=args.batch_size,
+        features=new_features,
+        desc="Segmenting objects",
+    )
+    end_time = time.time()
+    processing_time_str = f"{(end_time - start_time) / 60:.1f} minutes"
+
+    # Calculate statistics
+    if args.output_format == "semantic-mask":
+        total_detections = sum(processed_dataset["num_instances"])
+        images_with_detections = sum(
+            1 for n in processed_dataset["num_instances"] if n > 0
+        )
+    else:
+        total_detections = sum(
+            len(masks) for masks in processed_dataset["segmentation_masks"]
+        )
+        images_with_detections = sum(
+            1 for masks in processed_dataset["segmentation_masks"] if len(masks) > 0
+        )
+
+    logger.info("Segmentation complete!")
+    logger.info(f"  Total instances: {total_detections}")
+    logger.info(
+        f"  Images with detections: {images_with_detections}/{len(processed_dataset)}"
+    )
+
+    logger.info(f"Pushing to HuggingFace Hub: {args.output_dataset}")
+    try:
+        processed_dataset.push_to_hub(args.output_dataset, private=args.private)
+        logger.info(
+            f"Dataset available at: https://huggingface.co/datasets/{args.output_dataset}"
+        )
+    except Exception as e:
+        logger.error(f"Failed to push to hub: {e}")
+        logger.info("Saving locally as backup...")
+        processed_dataset.save_to_disk("./output_dataset")
+        logger.info("Saved to ./output_dataset")
+        sys.exit(1)
+
+    logger.info("Creating dataset card...")
+    card_content = create_dataset_card(
+        source_dataset=args.input_dataset,
+        model=args.model,
+        class_name=class_name,
+        output_format=args.output_format,
+        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,
+        include_boxes=args.include_boxes,
+    )
+    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()