Last Updated on 29/04/2026 by Eran Feit
Why Segment Anything (SAM) is a Game-Changer for Python Developers Generating high-quality training data is often the biggest bottleneck in computer vision. In this Segment Anything Python tutorial , you will solve the problem of manual image labeling by leveraging Meta’s SAM model to produce pixel-perfect masks instantly. Instead of spending weeks annotating datasets or training custom U-Net architectures, you will learn how to implement a zero-shot segmentation pipeline that works on any object right out of the box. Whether you are building an automated labeling tool or a creative AI app, this guide provides the exact implementation logic needed to extract masks without a single line of training code.
Under the hood, SAM’s transformer backbone and data engine make it promptable and robust. In practice, that means you can point it at a single image and get a comprehensive set of masks you can analyze, filter, and export—perfect for rapid prototyping, labeling bootstraps, or production pre-processing pipelines. The vibrant ecosystem and documentation around SAM keep the workflow approachable even if you’re new to segmentation.
Segment Anything Python tutorial About this tutorial In this tutorial, you’ll segment your images without training by loading the ViT-H checkpoint of SAM in Python, configuring the Automatic Mask Generator , and visualizing the resulting overlays. You’ll check GPU availability, prepare the image (resize + color space), set high-quality defaults for stability and IoU thresholds, and then export a clean PNG of the colored masks. The end result is a reproducible, copy-paste pipeline that turns any image into a stack of usable masks—fast—without a single epoch of fine-tuning.
This tutorial shows how to run Segment Anything (SAM) in Python to generate high-quality masks automatically.SAM Automatic Mask Generator , and visualize results.fast, effortless, and proven path to production-ready segmentation with SAM in Python.
For a hands-on classifier example you can pair with SAM masks, see my DenseNet201 sports tutorial here → https://eranfeit.net/how-to-build-a-densenet201-model-for-sports-image-classification/
Link for the video tutorial : https://youtu.be/8ZkKg9imOH8
You can download the code here : https://eranfeit.lemonsqueezy.com/buy/3a0df4b9-e074-49be-be37-7add7d079817
or here : https://ko-fi.com/s/5de0fcc9bc
Post for Medium users : https://medium.com/@feitgemel/segment-anything-python-no-training-image-masks-3785b8c4af78
Master Computer Vision
Follow my latest tutorials and AI insights on my
Personal Blog .
Beginner Complete CV Bootcamp
Foundation using PyTorch & TensorFlow.
Get Started → Interactive Deep Learning with PyTorch
Hands-on practice in an interactive environment.
Start Learning → Advanced Modern CV: GPT & OpenCV4
Vision GPT and production-ready models.
Go Advanced → Setting Up Your SAM Environment: Dependencies and CUDA Configuration Before we dive into the code, it is essential to have the correct environment for this Segment Anything Python tutorial . Ensure you have a working installation of PyTorch, as SAM relies heavily on tensor operations for its mask decoder.
In this part, you verify CUDA availability, import your libraries, and load an image.Segment Anything Python experience is stable and predictable across machines.
The foundation of any successful computer-vision workflow is a reliable environment.CUDA availability so you instantly know if GPU acceleration is active.
Next, we import essential packages: NumPy , Matplotlib , and OpenCV .
Image loading and resizing are practical cornerstones for reproducible workflows.
Finally, we convert from BGR (OpenCV’s default) to RGB for correct color rendering in Matplotlib.SAM automatic mask generator you’ll configure next.
Here is the test image :
Segment Anything Python — No-Training Image Masks 11 ### Check and import core libraries for Segment Anything Python. import torch ### Print whether CUDA is available for GPU acceleration. print ( " Cuda is available : " , torch . cuda . is_available ()) ### Import NumPy for array ops, Matplotlib for plotting, and OpenCV for image I/O and preprocessing. import numpy as np import matplotlib . pyplot as plt import cv2 ### Import SAM registry and the automatic mask generator interface. from segment_anything import sam_model_registry , SamAutomaticMaskGenerator ### Define the path to the ViT-H checkpoint, model type, and target device. sam_checkpoint = " e:/temp/sam_vit_h_4b8939.pth " model_type = " vit_h " device = " cuda " ### Read the image from disk using OpenCV. image = cv2 . imread ( " Best-Semantic-Segmentation-models/Segment-Anything/2-Segment-your-images-without-training/Rahaf.jpg " ) ### Inspect the original image shape to guide resizing decisions. print ( image . shape ) ### Choose a percentage scaling factor for reproducible resizing. scale_precent = 40 ### Compute new width based on scale percentage. width = int ( image . shape [ 1 ] * scale_precent / 100 ) ### Compute new height based on scale percentage. height = int ( image . shape [ 0 ] * scale_precent / 100 ) ### Bundle width and height into a dimension tuple. dim = ( width , height ) ### Resize the image with area interpolation for downscaling quality. image = cv2 . resize ( image , dim , interpolation = cv2 . INTER_AREA ) ### Convert BGR (OpenCV) to RGB (Matplotlib) for correct plot colors. image = cv2 . cvtColor ( image , cv2 . COLOR_BGR2RGB ) ### Set up a square figure for consistent visualization. plt . figure ( figsize = ( 10 , 10 )) ### Show the prepared image to confirm visual correctness. plt . imshow ( image ) ### Remove axes for a cleaner, publication-style image. plt . axis ( ' off ' ) ### Render the plot to screen. plt . show () Summary. image segmentation without training using SAM.
Want a classic clustering baseline before SAM? Check my K-means segmentation walkthrough → https://eranfeit.net/python-image-segmentation-made-easy-with-opencv-and-k-means-algorithm/
Loading SAM (ViT-H) and configuring the automatic mask generator In the next step of our Segment Anything Python tutorial , we will initialize the model. You’ll need to download the model checkpoints (ViT-H, ViT-L, or ViT-B) to allow the Python script to load the weights locally.
Here you load the ViT-H variant via sam_model_registry and move it to your target device.SamAutomaticMaskGenerator with sensible parameters for quality and speed.
SAM provides multiple backbones, and ViT-H offers excellent accuracy for complex scenes.model_type = "vit_h" you opt into that capability, ensuring strong mask quality.
Moving the model to the right device is crucial for performance.cuda is available, GPU inference yields significant speed-ups.pred_iou_thresh or stability_score_thresh.
The automatic mask generator is the engine that samples points, predicts masks, and filters results.points_per_side control how densely SAM probes the image.pred_iou_thresh and stability_score_thresh remove unstable masks early.
These defaults are a high-quality starting point.points_per_side.min_mask_region_area.
If you prefer transformer-based classification, compare this ViT tutorial → https://eranfeit.net/build-an-image-classifier-with-vision-transformer/
### Build the SAM model from the registry using the specified ViT-H checkpoint. sam = sam_model_registry [ model_type ]( checkpoint = sam_checkpoint ) ### Move the model to the selected device for faster inference when CUDA is available. sam . to ( device = device ) ### Configure the automatic mask generator for robust quality and reasonable speed. mask_generator_ = SamAutomaticMaskGenerator ( model = sam , points_per_side = 32 , pred_iou_thresh = 0.96 , stability_score_thresh = 0.96 , crop_n_layers = 1 , crop_n_points_downscale_factor = 2 , min_mask_region_area = 100 , ) The SAM automatic mask generator is ready.computer vision segmentation Python workflows.
Generating masks, visualizing overlays, and saving results In the final step, you run the generator, inspect how many masks were discovered, visualize them as transparent overlays, and save the result.
Generate(image) runs the full sampling-and-masking pipeline over your preprocessed image.segmentation, area, and bbox.
A compact overlay function makes results instantly interpretable.area shows large regions first, which often correspond to dominant objects in the scene.
Saving figures is critical for reproducible pipelines.
Common refinements include filtering by area, adjusting points per side, or batching multiple images.image segmentation without training .
Curious how CNN backbones compare? See ResNet50 vs MobileNetV2 notes → https://eranfeit.net/tensorflow-image-classification-tutorial-resnet50-vs-mobilenet/
### Run SAM to generate segmentation masks for the prepared image. masks = mask_generator_ . generate ( image ) ### Print how many masks were found as a quick quality and density check. print ( " Total mask discovered : " + str ( len ( masks ))) ### Define a helper to overlay masks as semi-transparent colored regions. def show_anns ( anns ): ### If no masks, exit early to avoid plotting artifacts. if len ( anns ) == 0 : return ### Sort masks by area so larger regions render first. sorted_anns = sorted ( anns , key = ( lambda x : x [ ' area ' ]), reverse =True ) ### Grab the current axes and lock autoscaling for layered overlays. ax = plt . gca () ax . set_autoscale_on ( False ) ### Prepare containers for optional polygon logic and color sampling. polygons = [] color = [] ### Render each mask as a colored alpha overlay. for ann in sorted_anns : m = ann [ ' segmentation ' ] img = np . ones (( m . shape [ 0 ], m . shape [ 1 ], 3 )) color_mask = np . random . random (( 1 , 3 )). tolist ()[ 0 ] for i in range ( 3 ): img [:,:, i ] = color_mask [ i ] ax . imshow ( np . dstack (( img , m * 0.35 ))) ### Plot the base image and overlays, then export a PNG for your records. plt . figure ( figsize = ( 10 , 10 )) plt . imshow ( image ) show_anns ( masks ) plt . axis ( ' off ' ) plt . savefig ( " Best-Semantic-Segmentation-models/Segment-Anything/2-Segment-your-images-without-training/output2.png " ) plt . show () Summary. ViT-H SAM tutorial you can adapt to any dataset or pipeline.
Here is the Result :
Segment Anything Python — No-Training Image Masks 12 Segment Anything Python — No-Training Image Masks 13 Need real-time edge inference ideas? Explore YOLOv8 + Jetson Nano here → https://eranfeit.net/yolov8-object-detection-with-jetson-nano-and-opencv/
FAQ – Segment Anything Python tutorial What is Segment Anything (SAM) used for? SAM generates object masks from images with minimal prompting. It accelerates labeling and exploration without dataset-specific training.
Do I need CUDA for good performance? CUDA is not mandatory but strongly recommended. GPU inference cuts runtime and boosts iteration speed.
Which SAM backbone should I choose? ViT-H offers strong quality with higher memory needs. Smaller backbones fit lighter devices.
How can I reduce tiny noisy masks? Increase min_mask_region_area and adjust IoU and stability thresholds to filter weak regions.
How do I get more mask coverage? Raise points_per_side to sample more points and capture finer details.
Why do my colors look wrong in plots? Convert BGR to RGB before plotting in Matplotlib for accurate colors.
Can I export masks for post-processing? Yes. Read the ‘segmentation’ arrays from each mask dictionary and save as needed.
How do I keep results consistent across runs? Use fixed resize scales, stable parameters, and record seeds and versions.
How can I process very large images faster? Lower sampling density or crop layers, downscale inputs, or batch across GPUs.
Is SAM production-ready? Yes, with profiling, parameter tuning, and proper exporting of overlays and masks.
Final Thoughts on this Segment Anything Python Tutorial You now have a clean, reproducible Segment Anything Python pipeline that loads ViT-H, generates masks automatically, and saves polished overlays.
Connect ☕ Buy me a coffee — https://ko-fi.com/eranfeit
🖥️ Email : feitgemel@gmail.com
🌐 https://eranfeit.net
🤝 Fiverr : https://www.fiverr.com/s/mB3Pbb
Enjoy,
Eran
Skip to content 
