[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7B0GJNGC8P59B2QFTVRPD3A":3,"skill-same:01M7B0GJNGC8P59B2QFTVRPD3A":73},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":42,"commitSha":43,"skillDirectory":44,"forksCount":14,"repositoryHtmlUrl":45,"repositoryHomepageUrl":6,"ownerHtmlUrl":46,"ownerBlogUrl":6,"ownerDescription":47,"updatedAt":48,"install":49,"resources":62},"01M7B0GJNGC8P59B2QFTVRPD3A","segment-anything-model",null,"SAM: zero-shot image segmentation via points, boxes, masks.","dbillion\u002Fhermes-skills-public","dbillion","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F49393855?v=4","01M7AVH8QPGCM8WKWS22TRT0T6","Oludayo Adeoye","01M7AVH8RD1JJWA0YS9CFEWAV9",0,"MIT","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fmlops\u002Fmodels\u002Fsegment-anything\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: segment-anything-model\ndescription: \"SAM: zero-shot image segmentation via points, boxes, masks.\"\nversion: 1.0.0\nauthor: Orchestra Research\nlicense: MIT\ndependencies: [segment-anything, transformers>=4.30.0, torch>=1.7.0]\nplatforms: [linux, macos, windows]\nmetadata:\n  hermes:\n    tags: [Multimodal, Image Segmentation, Computer Vision, SAM, Zero-Shot]\n\n---\n\n# Segment Anything Model (SAM)\n\nComprehensive guide to using Meta AI's Segment Anything Model for zero-shot image segmentation.\n\n## When to use SAM\n\n**Use SAM when:**\n- Need to segment any object in images without task-specific training\n- Building interactive annotation tools with point\u002Fbox prompts\n- Generating training data for other vision models\n- Need zero-shot transfer to new image domains\n- Building object detection\u002Fsegmentation pipelines\n- Processing medical, satellite, or domain-specific images\n\n**Key features:**\n- **Zero-shot segmentation**: Works on any image domain without fine-tuning\n- **Flexible prompts**: Points, bounding boxes, or previous masks\n- **Automatic segmentation**: Generate all object masks automatically\n- **High quality**: Trained on 1.1 billion masks from 11 million images\n- **Multiple model sizes**: ViT-B (fastest), ViT-L, ViT-H (most accurate)\n- **ONNX export**: Deploy in browsers and edge devices\n\n**Use alternatives instead:**\n- **YOLO\u002FDetectron2**: For real-time object detection with classes\n- **Mask2Former**: For semantic\u002Fpanoptic segmentation with categories\n- **GroundingDINO + SAM**: For text-prompted segmentation\n- **SAM 2**: For video segmentation tasks\n\n## Quick start\n\n### Installation\n\n```bash\n# From GitHub\npip install git+https:\u002F\u002Fgithub.com\u002Ffacebookresearch\u002Fsegment-anything.git\n\n# Optional dependencies\npip install opencv-python pycocotools matplotlib\n\n# Or use HuggingFace transformers\npip install transformers\n```\n\n### Download checkpoints\n\n```bash\n# ViT-H (largest, most accurate) - 2.4GB\nwget https:\u002F\u002Fdl.fbaipublicfiles.com\u002Fsegment_anything\u002Fsam_vit_h_4b8939.pth\n\n# ViT-L (medium) - 1.2GB\nwget https:\u002F\u002Fdl.fbaipublicfiles.com\u002Fsegment_anything\u002Fsam_vit_l_0b3195.pth\n\n# ViT-B (smallest, fastest) - 375MB\nwget https:\u002F\u002Fdl.fbaipublicfiles.com\u002Fsegment_anything\u002Fsam_vit_b_01ec64.pth\n```\n\n### Basic usage with SamPredictor\n\n```python\nimport numpy as np\nfrom segment_anything import sam_model_registry, SamPredictor\n\n# Load model\nsam = sam_model_registry[\"vit_h\"](checkpoint=\"sam_vit_h_4b8939.pth\")\nsam.to(device=\"cuda\")\n\n# Create predictor\npredictor = SamPredictor(sam)\n\n# Set image (computes embeddings once)\nimage = cv2.imread(\"image.jpg\")\nimage = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\npredictor.set_image(image)\n\n# Predict with point prompts\ninput_point = np.array([[500, 375]])  # (x, y) coordinates\ninput_label = np.array([1])  # 1 = foreground, 0 = background\n\nmasks, scores, logits = predictor.predict(\n    point_coords=input_point,\n    point_labels=input_label,\n    multimask_output=True  # Returns 3 mask options\n)\n\n# Select best mask\nbest_mask = masks[np.argmax(scores)]\n```\n\n### HuggingFace Transformers\n\n```python\nimport torch\nfrom PIL import Image\nfrom transformers import SamModel, SamProcessor\n\n# Load model and processor\nmodel = SamModel.from_pretrained(\"facebook\u002Fsam-vit-huge\")\nprocessor = SamProcessor.from_pretrained(\"facebook\u002Fsam-vit-huge\")\nmodel.to(\"cuda\")\n\n# Process image with point prompt\nimage = Image.open(\"image.jpg\")\ninput_points = [[[450, 600]]]  # Batch of points\n\ninputs = processor(image, input_points=input_points, return_tensors=\"pt\")\ninputs = {k: v.to(\"cuda\") for k, v in inputs.items()}\n\n# Generate masks\nwith torch.no_grad():\n    outputs = model(**inputs)\n\n# Post-process masks to original size\nmasks = processor.image_processor.post_process_masks(\n    outputs.pred_masks.cpu(),\n    inputs[\"original_sizes\"].cpu(),\n    inputs[\"reshaped_input_sizes\"].cpu()\n)\n```\n\n## Core concepts\n\n### Model architecture\n\n\u003C!-- ascii-guard-ignore -->\n```\nSAM Architecture:\n┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐\n│  Image Encoder  │────▶│ Prompt Encoder  │────▶│  Mask Decoder   │\n│     (ViT)       │     │ (Points\u002FBoxes)  │     │ (Transformer)   │\n└─────────────────┘     └─────────────────┘     └─────────────────┘\n        │                       │                       │\n   Image Embeddings      Prompt Embeddings         Masks + IoU\n   (computed once)       (per prompt)             predictions\n```\n\u003C!-- ascii-guard-ignore-end -->\n\n### Model variants\n\n| Model | Checkpoint | Size | Speed | Accuracy |\n|-------|------------|------|-------|----------|\n| ViT-H | `vit_h` | 2.4 GB | Slowest | Best |\n| ViT-L | `vit_l` | 1.2 GB | Medium | Good |\n| ViT-B | `vit_b` | 375 MB | Fastest | Good |\n\n### Prompt types\n\n| Prompt | Description | Use Case |\n|--------|-------------|----------|\n| Point (foreground) | Click on object | Single object selection |\n| Point (background) | Click outside object | Exclude regions |\n| Bounding box | Rectangle around object | Larger objects |\n| Previous mask | Low-res mask input | Iterative refinement |\n\n## Interactive segmentation\n\n### Point prompts\n\n```python\n# Single foreground point\ninput_point = np.array([[500, 375]])\ninput_label = np.array([1])\n\nmasks, scores, logits = predictor.predict(\n    point_coords=input_point,\n    point_labels=input_label,\n    multimask_output=True\n)\n\n# Multiple points (foreground + background)\ninput_points = np.array([[500, 375], [600, 400], [450, 300]])\ninput_labels = np.array([1, 1, 0])  # 2 foreground, 1 background\n\nmasks, scores, logits = predictor.predict(\n    point_coords=input_points,\n    point_labels=input_labels,\n    multimask_output=False  # Single mask when prompts are clear\n)\n```\n\n### Box prompts\n\n```python\n# Bounding box [x1, y1, x2, y2]\ninput_box = np.array([425, 600, 700, 875])\n\nmasks, scores, logits = predictor.predict(\n    box=input_box,\n    multimask_output=False\n)\n```\n\n### Combined prompts\n\n```python\n# Box + points for precise control\nmasks, scores, logits = predictor.predict(\n    point_coords=np.array([[500, 375]]),\n    point_labels=np.array([1]),\n    box=np.array([400, 300, 700, 600]),\n    multimask_output=False\n)\n```\n\n### Iterative refinement\n\n```python\n# Initial prediction\nmasks, scores, logits = predictor.predict(\n    point_coords=np.array([[500, 375]]),\n    point_labels=np.array([1]),\n    multimask_output=True\n)\n\n# Refine with additional point using previous mask\nmasks, scores, logits = predictor.predict(\n    point_coords=np.array([[500, 375], [550, 400]]),\n    point_labels=np.array([1, 0]),  # Add background point\n    mask_input=logits[np.argmax(scores)][None, :, :],  # Use best mask\n    multimask_output=False\n)\n```\n\n## Automatic mask generation\n\n### Basic automatic segmentation\n\n```python\nfrom segment_anything import SamAutomaticMaskGenerator\n\n# Create generator\nmask_generator = SamAutomaticMaskGenerator(sam)\n\n# Generate all masks\nmasks = mask_generator.generate(image)\n\n# Each mask contains:\n# - segmentation: binary mask\n# - bbox: [x, y, w, h]\n# - area: pixel count\n# - predicted_iou: quality score\n# - stability_score: robustness score\n# - point_coords: generating point\n```\n\n### Customized generation\n\n```python\nmask_generator = SamAutomaticMaskGenerator(\n    model=sam,\n    points_per_side=32,          # Grid density (more = more masks)\n    pred_iou_thresh=0.88,        # Quality threshold\n    stability_score_thresh=0.95,  # Stability threshold\n    crop_n_layers=1,             # Multi-scale crops\n    crop_n_points_downscale_factor=2,\n    min_mask_region_area=100,    # Remove tiny masks\n)\n\nmasks = mask_generator.generate(image)\n```\n\n### Filtering masks\n\n```python\n# Sort by area (largest first)\nmasks = sorted(masks, key=lambda x: x['area'], reverse=True)\n\n# Filter by predicted IoU\nhigh_quality = [m for m in masks if m['predicted_iou'] > 0.9]\n\n# Filter by stability score\nstable_masks = [m for m in masks if m['stability_score'] > 0.95]\n```\n\n## Batched inference\n\n### Multiple images\n\n```python\n# Process multiple images efficiently\nimages = [cv2.imread(f\"image_{i}.jpg\") for i in range(10)]\n\nall_masks = []\nfor image in images:\n    predictor.set_image(image)\n    masks, _, _ = predictor.predict(\n        point_coords=np.array([[500, 375]]),\n        point_labels=np.array([1]),\n        multimask_output=True\n    )\n    all_masks.append(masks)\n```\n\n### Multiple prompts per image\n\n```python\n# Process multiple prompts efficiently (one image encoding)\npredictor.set_image(image)\n\n# Batch of point prompts\npoints = [\n    np.array([[100, 100]]),\n    np.array([[200, 200]]),\n    np.array([[300, 300]])\n]\n\nall_masks = []\nfor point in points:\n    masks, scores, _ = predictor.predict(\n        point_coords=point,\n        point_labels=np.array([1]),\n        multimask_output=True\n    )\n    all_masks.append(masks[np.argmax(scores)])\n```\n\n## ONNX deployment\n\n### Export model\n\n```bash\npython scripts\u002Fexport_onnx_model.py \\\n    --checkpoint sam_vit_h_4b8939.pth \\\n    --model-type vit_h \\\n    --output sam_onnx.onnx \\\n    --return-single-mask\n```\n\n### Use ONNX model\n\n```python\nimport onnxruntime\n\n# Load ONNX model\nort_session = onnxruntime.InferenceSession(\"sam_onnx.onnx\")\n\n# Run inference (image embeddings computed separately)\nmasks = ort_session.run(\n    None,\n    {\n        \"image_embeddings\": image_embeddings,\n        \"point_coords\": point_coords,\n        \"point_labels\": point_labels,\n        \"mask_input\": np.zeros((1, 1, 256, 256), dtype=np.float32),\n        \"has_mask_input\": np.array([0], dtype=np.float32),\n        \"orig_im_size\": np.array([h, w], dtype=np.float32)\n    }\n)\n```\n\n## Common workflows\n\n### Workflow 1: Annotation tool\n\n```python\nimport cv2\n\n# Load model\npredictor = SamPredictor(sam)\npredictor.set_image(image)\n\ndef on_click(event, x, y, flags, param):\n    if event == cv2.EVENT_LBUTTONDOWN:\n        # Foreground point\n        masks, scores, _ = predictor.predict(\n            point_coords=np.array([[x, y]]),\n            point_labels=np.array([1]),\n            multimask_output=True\n        )\n        # Display best mask\n        display_mask(masks[np.argmax(scores)])\n```\n\n### Workflow 2: Object extraction\n\n```python\ndef extract_object(image, point):\n    \"\"\"Extract object at point with transparent background.\"\"\"\n    predictor.set_image(image)\n\n    masks, scores, _ = predictor.predict(\n        point_coords=np.array([point]),\n        point_labels=np.array([1]),\n        multimask_output=True\n    )\n\n    best_mask = masks[np.argmax(scores)]\n\n    # Create RGBA output\n    rgba = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8)\n    rgba[:, :, :3] = image\n    rgba[:, :, 3] = best_mask * 255\n\n    return rgba\n```\n\n### Workflow 3: Medical image segmentation\n\n```python\n# Process medical images (grayscale to RGB)\nmedical_image = cv2.imread(\"scan.png\", cv2.IMREAD_GRAYSCALE)\nrgb_image = cv2.cvtColor(medical_image, cv2.COLOR_GRAY2RGB)\n\npredictor.set_image(rgb_image)\n\n# Segment region of interest\nmasks, scores, _ = predictor.predict(\n    box=np.array([x1, y1, x2, y2]),  # ROI bounding box\n    multimask_output=True\n)\n```\n\n## Output format\n\n### Mask data structure\n\n```python\n# SamAutomaticMaskGenerator output\n{\n    \"segmentation\": np.ndarray,  # H×W binary mask\n    \"bbox\": [x, y, w, h],        # Bounding box\n    \"area\": int,                 # Pixel count\n    \"predicted_iou\": float,      # 0-1 quality score\n    \"stability_score\": float,    # 0-1 robustness score\n    \"crop_box\": [x, y, w, h],    # Generation crop region\n    \"point_coords\": [[x, y]],    # Input point\n}\n```\n\n### COCO RLE format\n\n```python\nfrom pycocotools import mask as mask_utils\n\n# Encode mask to RLE\nrle = mask_utils.encode(np.asfortranarray(mask.astype(np.uint8)))\nrle[\"counts\"] = rle[\"counts\"].decode(\"utf-8\")\n\n# Decode RLE to mask\ndecoded_mask = mask_utils.decode(rle)\n```\n\n## Performance optimization\n\n### GPU memory\n\n```python\n# Use smaller model for limited VRAM\nsam = sam_model_registry[\"vit_b\"](checkpoint=\"sam_vit_b_01ec64.pth\")\n\n# Process images in batches\n# Clear CUDA cache between large batches\ntorch.cuda.empty_cache()\n```\n\n### Speed optimization\n\n```python\n# Use half precision\nsam = sam.half()\n\n# Reduce points for automatic generation\nmask_generator = SamAutomaticMaskGenerator(\n    model=sam,\n    points_per_side=16,  # Default is 32\n)\n\n# Use ONNX for deployment\n# Export with --return-single-mask for faster inference\n```\n\n## Common issues\n\n| Issue | Solution |\n|-------|----------|\n| Out of memory | Use ViT-B model, reduce image size |\n| Slow inference | Use ViT-B, reduce points_per_side |\n| Poor mask quality | Try different prompts, use box + points |\n| Edge artifacts | Use stability_score filtering |\n| Small objects missed | Increase points_per_side |\n\n## References\n\n- **[Advanced Usage](references\u002Fadvanced-usage.md)** - Batching, fine-tuning, integration\n- **[Troubleshooting](references\u002Ftroubleshooting.md)** - Common issues and solutions\n\n## Resources\n\n- **GitHub**: https:\u002F\u002Fgithub.com\u002Ffacebookresearch\u002Fsegment-anything\n- **Paper**: https:\u002F\u002Farxiv.org\u002Fabs\u002F2304.02643\n- **Demo**: https:\u002F\u002Fsegment-anything.com\n- **SAM 2 (Video)**: https:\u002F\u002Fgithub.com\u002Ffacebookresearch\u002Fsegment-anything-2\n- **HuggingFace**: https:\u002F\u002Fhuggingface.co\u002Ffacebook\u002Fsam-vit-huge\n","# Segment Anything Model (SAM)\n\nComprehensive guide to using Meta AI's Segment Anything Model for zero-shot image segmentation.\n\n## When to use SAM\n\n**Use SAM when:**\n- Need to segment any object in images without task-specific training\n- Building interactive annotation tools with point\u002Fbox prompts\n- Generating training data for other vision models\n- Need zero-shot transfer to new image domains\n- Building object detection\u002Fsegmentation pipelines\n- Processing medical, satellite, or domain-specific images\n\n**Key features:**\n- **Zero-shot segmentation**: Works on any image domain without fine-tuning\n- **Flexible prompts**: Points, bounding boxes, or previous masks\n- **Automatic segmentation**: Generate all object masks automatically\n- **High quality**: Trained on 1.1 billion masks from 11 million images\n- **Multiple model sizes**: ViT-B (fastest), ViT-L, ViT-H (most accurate)\n- **ONNX export**: Deploy in browsers and edge devices\n\n**Use alternatives instead:**\n- **YOLO\u002FDetectron2**: For real-time object detection with classes\n- **Mask2Former**: For semantic\u002Fpanoptic segmentation with categories\n- **GroundingDINO + SAM**: For text-prompted segmentation\n- **SAM 2**: For video segmentation tasks\n\n## Quick start\n\n### Installation\n\n```bash\n# From GitHub\npip install git+https:\u002F\u002Fgithub.com\u002Ffacebookresearch\u002Fsegment-anything.git\n\n# Optional dependencies\npip install opencv-python pycocotools matplotlib\n\n# Or use HuggingFace transformers\npip install transformers\n```\n\n### Download checkpoints\n\n```bash\n# ViT-H (largest, most accurate) - 2.4GB\nwget https:\u002F\u002Fdl.fbaipublicfiles.com\u002Fsegment_anything\u002Fsam_vit_h_4b8939.pth\n\n# ViT-L (medium) - 1.2GB\nwget https:\u002F\u002Fdl.fbaipublicfiles.com\u002Fsegment_anything\u002Fsam_vit_l_0b3195.pth\n\n# ViT-B (smallest, fastest) - 375MB\nwget https:\u002F\u002Fdl.fbaipublicfiles.com\u002Fsegment_anything\u002Fsam_vit_b_01ec64.pth\n```\n\n### Basic usage with SamPredictor\n\n```python\nimport numpy as np\nfrom segment_anything import sam_model_registry, SamPredictor\n\n# Load model\nsam = sam_model_registry[\"vit_h\"](checkpoint=\"sam_vit_h_4b8939.pth\")\nsam.to(device=\"cuda\")\n\n# Create predictor\npredictor = SamPredictor(sam)\n\n# Set image (computes embeddings once)\nimage = cv2.imread(\"image.jpg\")\nimage = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\npredictor.set_image(image)\n\n# Predict with point prompts\ninput_point = np.array([[500, 375]])  # (x, y) coordinates\ninput_label = np.array([1])  # 1 = foreground, 0 = background\n\nmasks, scores, logits = predictor.predict(\n    point_coords=input_point,\n    point_labels=input_label,\n    multimask_output=True  # Returns 3 mask options\n)\n\n# Select best mask\nbest_mask = masks[np.argmax(scores)]\n```\n\n### HuggingFace Transformers\n\n```python\nimport torch\nfrom PIL import Image\nfrom transformers import SamModel, SamProcessor\n\n# Load model and processor\nmodel = SamModel.from_pretrained(\"facebook\u002Fsam-vit-huge\")\nprocessor = SamProcessor.from_pretrained(\"facebook\u002Fsam-vit-huge\")\nmodel.to(\"cuda\")\n\n# Process image with point prompt\nimage = Image.open(\"image.jpg\")\ninput_points = [[[450, 600]]]  # Batch of points\n\ninputs = processor(image, input_points=input_points, return_tensors=\"pt\")\ninputs = {k: v.to(\"cuda\") for k, v in inputs.items()}\n\n# Generate masks\nwith torch.no_grad():\n    outputs = model(**inputs)\n\n# Post-process masks to original size\nmasks = processor.image_processor.post_process_masks(\n    outputs.pred_masks.cpu(),\n    inputs[\"original_sizes\"].cpu(),\n    inputs[\"reshaped_input_sizes\"].cpu()\n)\n```\n\n## Core concepts\n\n### Model architecture\n\n\u003C!-- ascii-guard-ignore -->\n```\nSAM Architecture:\n┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐\n│  Image Encoder  │────▶│ Prompt Encoder  │────▶│  Mask Decoder   │\n│     (ViT)       │     │ (Points\u002FBoxes)  │     │ (Transformer)   │\n└─────────────────┘     └─────────────────┘     └─────────────────┘\n        │                       │                       │\n   Image Embeddings      Prompt Embeddings         Masks + IoU\n   (computed once)       (per prompt)             predictions\n```\n\u003C!-- ascii-guard-ignore-end -->\n\n### Model variants\n\n| Model | Checkpoint | Size | Speed | Accuracy |\n|-------|------------|------|-------|----------|\n| ViT-H | `vit_h` | 2.4 GB | Slowest | Best |\n| ViT-L | `vit_l` | 1.2 GB | Medium | Good |\n| ViT-B | `vit_b` | 375 MB | Fastest | Good |\n\n### Prompt types\n\n| Prompt | Description | Use Case |\n|--------|-------------|----------|\n| Point (foreground) | Click on object | Single object selection |\n| Point (background) | Click outside object | Exclude regions |\n| Bounding box | Rectangle around object | Larger objects |\n| Previous mask | Low-res mask input | Iterative refinement |\n\n## Interactive segmentation\n\n### Point prompts\n\n```python\n# Single foreground point\ninput_point = np.array([[500, 375]])\ninput_label = np.array([1])\n\nmasks, scores, logits = predictor.predict(\n    point_coords=input_point,\n    point_labels=input_label,\n    multimask_output=True\n)\n\n# Multiple points (foreground + background)\ninput_points = np.array([[500, 375], [600, 400], [450, 300]])\ninput_labels = np.array([1, 1, 0])  # 2 foreground, 1 background\n\nmasks, scores, logits = predictor.predict(\n    point_coords=input_points,\n    point_labels=input_labels,\n    multimask_output=False  # Single mask when prompts are clear\n)\n```\n\n### Box prompts\n\n```python\n# Bounding box [x1, y1, x2, y2]\ninput_box = np.array([425, 600, 700, 875])\n\nmasks, scores, logits = predictor.predict(\n    box=input_box,\n    multimask_output=False\n)\n```\n\n### Combined prompts\n\n```python\n# Box + points for precise control\nmasks, scores, logits = predictor.predict(\n    point_coords=np.array([[500, 375]]),\n    point_labels=np.array([1]),\n    box=np.array([400, 300, 700, 600]),\n    multimask_output=False\n)\n```\n\n### Iterative refinement\n\n```python\n# Initial prediction\nmasks, scores, logits = predictor.predict(\n    point_coords=np.array([[500, 375]]),\n    point_labels=np.array([1]),\n    multimask_output=True\n)\n\n# Refine with additional point using previous mask\nmasks, scores, logits = predictor.predict(\n    point_coords=np.array([[500, 375], [550, 400]]),\n    point_labels=np.array([1, 0]),  # Add background point\n    mask_input=logits[np.argmax(scores)][None, :, :],  # Use best mask\n    multimask_output=False\n)\n```\n\n## Automatic mask generation\n\n### Basic automatic segmentation\n\n```python\nfrom segment_anything import SamAutomaticMaskGenerator\n\n# Create generator\nmask_generator = SamAutomaticMaskGenerator(sam)\n\n# Generate all masks\nmasks = mask_generator.generate(image)\n\n# Each mask contains:\n# - segmentation: binary mask\n# - bbox: [x, y, w, h]\n# - area: pixel count\n# - predicted_iou: quality score\n# - stability_score: robustness score\n# - point_coords: generating point\n```\n\n### Customized generation\n\n```python\nmask_generator = SamAutomaticMaskGenerator(\n    model=sam,\n    points_per_side=32,          # Grid density (more = more masks)\n    pred_iou_thresh=0.88,        # Quality threshold\n    stability_score_thresh=0.95,  # Stability threshold\n    crop_n_layers=1,             # Multi-scale crops\n    crop_n_points_downscale_factor=2,\n    min_mask_region_area=100,    # Remove tiny masks\n)\n\nmasks = mask_generator.generate(image)\n```\n\n### Filtering masks\n\n```python\n# Sort by area (largest first)\nmasks = sorted(masks, key=lambda x: x['area'], reverse=True)\n\n# Filter by predicted IoU\nhigh_quality = [m for m in masks if m['predicted_iou'] > 0.9]\n\n# Filter by stability score\nstable_masks = [m for m in masks if m['stability_score'] > 0.95]\n```\n\n## Batched inference\n\n### Multiple images\n\n```python\n# Process multiple images efficiently\nimages = [cv2.imread(f\"image_{i}.jpg\") for i in range(10)]\n\nall_masks = []\nfor image in images:\n    predictor.set_image(image)\n    masks, _, _ = predictor.predict(\n        point_coords=np.array([[500, 375]]),\n        point_labels=np.array([1]),\n        multimask_output=True\n    )\n    all_masks.append(masks)\n```\n\n### Multiple prompts per image\n\n```python\n# Process multiple prompts efficiently (one image encoding)\npredictor.set_image(image)\n\n# Batch of point prompts\npoints = [\n    np.array([[100, 100]]),\n    np.array([[200, 200]]),\n    np.array([[300, 300]])\n]\n\nall_masks = []\nfor point in points:\n    masks, scores, _ = predictor.predict(\n        point_coords=point,\n        point_labels=np.array([1]),\n        multimask_output=True\n    )\n    all_masks.append(masks[np.argmax(scores)])\n```\n\n## ONNX deployment\n\n### Export model\n\n```bash\npython scripts\u002Fexport_onnx_model.py \\\n    --checkpoint sam_vit_h_4b8939.pth \\\n    --model-type vit_h \\\n    --output sam_onnx.onnx \\\n    --return-single-mask\n```\n\n### Use ONNX model\n\n```python\nimport onnxruntime\n\n# Load ONNX model\nort_session = onnxruntime.InferenceSession(\"sam_onnx.onnx\")\n\n# Run inference (image embeddings computed separately)\nmasks = ort_session.run(\n    None,\n    {\n        \"image_embeddings\": image_embeddings,\n        \"point_coords\": point_coords,\n        \"point_labels\": point_labels,\n        \"mask_input\": np.zeros((1, 1, 256, 256), dtype=np.float32),\n        \"has_mask_input\": np.array([0], dtype=np.float32),\n        \"orig_im_size\": np.array([h, w], dtype=np.float32)\n    }\n)\n```\n\n## Common workflows\n\n### Workflow 1: Annotation tool\n\n```python\nimport cv2\n\n# Load model\npredictor = SamPredictor(sam)\npredictor.set_image(image)\n\ndef on_click(event, x, y, flags, param):\n    if event == cv2.EVENT_LBUTTONDOWN:\n        # Foreground point\n        masks, scores, _ = predictor.predict(\n            point_coords=np.array([[x, y]]),\n            point_labels=np.array([1]),\n            multimask_output=True\n        )\n        # Display best mask\n        display_mask(masks[np.argmax(scores)])\n```\n\n### Workflow 2: Object extraction\n\n```python\ndef extract_object(image, point):\n    \"\"\"Extract object at point with transparent background.\"\"\"\n    predictor.set_image(image)\n\n    masks, scores, _ = predictor.predict(\n        point_coords=np.array([point]),\n        point_labels=np.array([1]),\n        multimask_output=True\n    )\n\n    best_mask = masks[np.argmax(scores)]\n\n    # Create RGBA output\n    rgba = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8)\n    rgba[:, :, :3] = image\n    rgba[:, :, 3] = best_mask * 255\n\n    return rgba\n```\n\n### Workflow 3: Medical image segmentation\n\n```python\n# Process medical images (grayscale to RGB)\nmedical_image = cv2.imread(\"scan.png\", cv2.IMREAD_GRAYSCALE)\nrgb_image = cv2.cvtColor(medical_image, cv2.COLOR_GRAY2RGB)\n\npredictor.set_image(rgb_image)\n\n# Segment region of interest\nmasks, scores, _ = predictor.predict(\n    box=np.array([x1, y1, x2, y2]),  # ROI bounding box\n    multimask_output=True\n)\n```\n\n## Output format\n\n### Mask data structure\n\n```python\n# SamAutomaticMaskGenerator output\n{\n    \"segmentation\": np.ndarray,  # H×W binary mask\n    \"bbox\": [x, y, w, h],        # Bounding box\n    \"area\": int,                 # Pixel count\n    \"predicted_iou\": float,      # 0-1 quality score\n    \"stability_score\": float,    # 0-1 robustness score\n    \"crop_box\": [x, y, w, h],    # Generation crop region\n    \"point_coords\": [[x, y]],    # Input point\n}\n```\n\n### COCO RLE format\n\n```python\nfrom pycocotools import mask as mask_utils\n\n# Encode mask to RLE\nrle = mask_utils.encode(np.asfortranarray(mask.astype(np.uint8)))\nrle[\"counts\"] = rle[\"counts\"].decode(\"utf-8\")\n\n# Decode RLE to mask\ndecoded_mask = mask_utils.decode(rle)\n```\n\n## Performance optimization\n\n### GPU memory\n\n```python\n# Use smaller model for limited VRAM\nsam = sam_model_registry[\"vit_b\"](checkpoint=\"sam_vit_b_01ec64.pth\")\n\n# Process images in batches\n# Clear CUDA cache between large batches\ntorch.cuda.empty_cache()\n```\n\n### Speed optimization\n\n```python\n# Use half precision\nsam = sam.half()\n\n# Reduce points for automatic generation\nmask_generator = SamAutomaticMaskGenerator(\n    model=sam,\n    points_per_side=16,  # Default is 32\n)\n\n# Use ONNX for deployment\n# Export with --return-single-mask for faster inference\n```\n\n## Common issues\n\n| Issue | Solution |\n|-------|----------|\n| Out of memory | Use ViT-B model, reduce image size |\n| Slow inference | Use ViT-B, reduce points_per_side |\n| Poor mask quality | Try different prompts, use box + points |\n| Edge artifacts | Use stability_score filtering |\n| Small objects missed | Increase points_per_side |\n\n## References\n\n- **[Advanced Usage](references\u002Fadvanced-usage.md)** - Batching, fine-tuning, integration\n- **[Troubleshooting](references\u002Ftroubleshooting.md)** - Common issues and solutions\n\n## Resources\n\n- **GitHub**: https:\u002F\u002Fgithub.com\u002Ffacebookresearch\u002Fsegment-anything\n- **Paper**: https:\u002F\u002Farxiv.org\u002Fabs\u002F2304.02643\n- **Demo**: https:\u002F\u002Fsegment-anything.com\n- **SAM 2 (Video)**: https:\u002F\u002Fgithub.com\u002Ffacebookresearch\u002Fsegment-anything-2\n- **HuggingFace**: https:\u002F\u002Fhuggingface.co\u002Ffacebook\u002Fsam-vit-huge\n",{"name":5,"author":24,"license":15,"version":25,"metadata":26,"platforms":34,"description":7,"dependencies":38},"Orchestra Research","1.0.0",{"hermes":27},{"tags":28},[29,30,31,32,33],"Multimodal","Image Segmentation","Computer Vision","SAM","Zero-Shot",[35,36,37],"linux","macos","windows",[39,40,41],"segment-anything","transformers>=4.30.0","torch>=1.7.0","master","f341c46fed021656175d5c9ccc67a72126e50bfb","skills\u002Fmlops\u002Fmodels\u002Fsegment-anything","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public","https:\u002F\u002Fgithub.com\u002Fdbillion","I enjoy writing codes,teaching programming, solving problems, tasted automation in Python and never looked back😋😋😋💞","2026-10-14 03:31:55",{"source":8,"skillName":5,"commands":50,"prompt":60,"zipAvailable":61},[51,54,57],{"tool":52,"command":53},"npx","npx skills add dbillion\u002Fhermes-skills-public --skill segment-anything-model",{"tool":55,"command":56},"bunx","bunx skills add dbillion\u002Fhermes-skills-public --skill segment-anything-model",{"tool":58,"command":59},"pnpm","pnpm dlx skills add dbillion\u002Fhermes-skills-public --skill segment-anything-model","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fmlops\u002Fmodels\u002Fsegment-anything\u002FSKILL.md",true,[63,69],{"path":64,"resourceType":65,"resourceTypeDesc":66,"sizeBytes":67,"sourceHtmlUrl":68},"references\u002Fadvanced-usage.md","REFERENCE","参考文档",15803,"https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fmlops\u002Fmodels\u002Fsegment-anything\u002Freferences\u002Fadvanced-usage.md",{"path":70,"resourceType":65,"resourceTypeDesc":66,"sizeBytes":71,"sourceHtmlUrl":72},"references\u002Ftroubleshooting.md",11914,"https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fmlops\u002Fmodels\u002Fsegment-anything\u002Freferences\u002Ftroubleshooting.md",[74,81,88,97,104,111],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":19},"01M7B25T0V7RBKES86Y3RTXQRN","blocked-page-recovery","Use when a fetch fails: 403\u002F429, paywall, WAF, bot wall.","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fweb\u002Fblocked-page-recovery\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":19},"01M7B25DSBBMZRHVD28MAX7N5X","gemini-vision-fallback","Vision fallback: Gemini REST API if vision_analyze blocked.","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fvision\u002Fgemini-vision-fallback\u002FSKILL.md",[],[],{"skillNo":89,"name":90,"nameZh":6,"description":91,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":92,"licenseFileUrl":93,"sourceHtmlUrl":94,"categories":95,"keywords":96,"publishedAt":19},"01M7B22XW9QXT2ZWWXVZDFWYZP","twitter-cli","Use twitter-cli for ALL Twitter\u002FX operations — reading tweets, posting, replying, quoting, liking, retweeting, following, searching, user lookups. Invoke whenever user requests any Twitter interaction.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Ftwitter-cli\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Ftwitter-cli\u002FSKILL.md",[],[],{"skillNo":98,"name":99,"nameZh":6,"description":100,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":101,"categories":102,"keywords":103,"publishedAt":19},"01M7B22QMWY1B4F7BC114RG4S6","prism-scan","Structural analysis through dynamically generated cognitive lenses. Generates the optimal analytical lens for the specific code\u002Fartifact, then executes it. Finds conservation laws, structural invariants, and concrete bugs that vanilla analysis misses. Use on any code file, system design, or text artifact.","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fts-superhermes-prism-scan\u002FSKILL.md",[],[],{"skillNo":105,"name":106,"nameZh":6,"description":107,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":108,"categories":109,"keywords":110,"publishedAt":19},"01M7B22JA5XCAP1ACT6V50WYR1","prism-reflect","Constraint transparency: analyzes an artifact structurally, then analyzes what its own analysis concealed. Produces a conservation law AND a constraint report showing what was maximized, what was sacrificed, and what to investigate next. The only AI skill that knows what it can't see.","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fts-superhermes-prism-reflect\u002FSKILL.md",[],[],{"skillNo":112,"name":113,"nameZh":6,"description":114,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":115,"categories":116,"keywords":117,"publishedAt":19},"01M7B22EB15M75M4X3C52YGDCC","prism-full","Full Prism: multi-pass structural analysis with mandatory adversarial self-correction. Designs custom analytical passes, executes them with chaining, then attacks its own findings before synthesizing. Use for maximum depth on important code or artifacts.","https:\u002F\u002Fgithub.com\u002Fdbillion\u002Fhermes-skills-public\u002Fblob\u002Fmaster\u002Fskills\u002Fts-superhermes-prism-full\u002FSKILL.md",[],[]]