Começar

Modelo Fast Segment Anything (FastSAM)

O Fast Segment Anything Model (FastSAM) é uma solução em tempo real baseada em CNN para a tarefa Segment Anything. Esta tarefa foi concebida para segmentar qualquer objeto numa imagem com base em vários prompts de interação possíveis fornecidos pelo utilizador. FastSAM reduz significativamente as exigências computacionais e mantém um desempenho competitivo, sendo uma opção prática para diversas tarefas de visão.



Assista: Rastreamento de objetos usando FastSAM com Ultralytics

Arquitetura do modelo#

Visão geral da arquitetura do modelo Fast Segment Anything (FastSAM)

Visão geral#

FastSAM foi concebido para resolver as limitações do Segment Anything Model (SAM), um modelo pesado baseado em Transformer que exige muitos recursos computacionais. FastSAM divide a tarefa Segment Anything em duas etapas sequenciais: segmentação de todas as instâncias e seleção orientada por prompts. Na primeira etapa, utiliza YOLOv8-seg para produzir as máscaras de segmentação de todas as instâncias da imagem. Na segunda etapa, devolve a região de interesse correspondente ao prompt.

Principais funcionalidades#

  1. Solução em tempo real: Ao tirar partido da eficiência computacional das CNNs, FastSAM oferece uma solução em tempo real para a tarefa Segment Anything, sendo útil em aplicações industriais que exigem resultados rápidos.

  2. Eficiência e desempenho: FastSAM reduz significativamente as exigências computacionais e de recursos, alcançando um desempenho comparável ao de SAM e permitindo aplicações em tempo real.

  3. Segmentação orientada por prompts: FastSAM pode segmentar qualquer objeto numa imagem com a orientação de vários prompts de interação fornecidos pelo utilizador, oferecendo flexibilidade e adaptabilidade em diferentes cenários.

  4. Baseado em YOLOv8-seg: FastSAM baseia-se em YOLOv8-seg, um detetor de objetos com um ramo de segmentação de instâncias. Isto permite-lhe produzir eficazmente as máscaras de segmentação de todas as instâncias de uma imagem.

  5. Resultados competitivos em benchmarks: Na tarefa de propostas de objetos no MS COCO, FastSAM obtém pontuações elevadas e é significativamente mais rápido do que SAM numa única NVIDIA RTX 3090, demonstrando a sua eficiência e capacidade.

  6. Aplicações práticas: Esta abordagem oferece uma solução prática para muitas tarefas de visão e funciona dezenas a centenas de vezes mais rápido do que os métodos Segment Anything anteriores.

  7. Viabilidade da compactação de modelos: O FastSAM demonstra a viabilidade de uma abordagem capaz de reduzir significativamente o esforço computacional ao introduzir um prior artificial na estrutura, abrindo assim novas possibilidades para arquiteturas de modelos grandes voltadas a tarefas gerais de visão computacional.

Modelos disponíveis, tarefas compatíveis e modos de operação#

Esta tabela apresenta os modelos disponíveis, os respetivos pesos pré-treinados, as tarefas suportadas e a compatibilidade com diferentes modos de operação, como Treino, Validação, Inferência e Exportação. Os modos suportados são indicados com ✅ e os não suportados com ❌.

Tipo de modeloPesos pré-treinadosTarefas suportadasTreinamentoValidaçãoInferênciaExportar
FastSAM-sFastSAM-s.ptSegmentação de instâncias❌✅✅✅
FastSAM-xFastSAM-x.ptSegmentação de instâncias❌✅✅✅

Comparação do FastSAM com o YOLO#

Aqui comparamos FastSAM-s com as variantes SAM da Meta e os modelos de segmentação da Ultralytics, incluindo YOLO26:

ModeloTamanho
(MB)
Parâmetros
(M)
Velocidade (CPU)
(ms/im)
Meta SAM-b37593.741703
Meta SAM2-b16280.828867
Meta SAM2-t78.138.923430
MobileSAM40.710.123802
FastSAM-s com backbone YOLOv823.911.858.0
Ultralytics YOLOv8n-seg7.1 (11.0x menor)3.4 (11.4x menos)24.8 (945x mais rápido)
Ultralytics YOLO11n-seg6.2 (12.6x menor)2.9 (13.4x menos)24.3 (964x mais rápido)
Ultralytics YOLO26n-seg6.7 (11.7x menor)2.7 (14.4x menos)25.2 (930x mais rápido)

Esta comparação demonstra as diferenças substanciais entre os tamanhos e as velocidades dos modelos das variantes SAM e dos modelos de segmentação YOLO. Embora o SAM ofereça recursos exclusivos de segmentação automática, os modelos YOLO, especialmente YOLOv8n-seg, YOLO11n-seg e YOLO26n-seg, são significativamente menores, mais rápidos e mais eficientes em termos computacionais.

As velocidades do SAM foram medidas com PyTorch; as velocidades do YOLO, com ONNX Runtime. Os testes foram executados em um Apple M4 Air de 2025 com 16 GB de RAM, usando torch==2.10.0, ultralytics==8.4.31 e onnxruntime==1.24.4. Para reproduzir este teste:

Exemplo
from ultralytics import ASSETS, SAM, YOLO, FastSAM

# Avalie o desempenho de SAM2-t, SAM2-b, SAM-b, MobileSAM
for file in ["sam_b.pt", "sam2_b.pt", "sam2_t.pt", "mobile_sam.pt"]:
    model = SAM(file)
    model.info()
    model(ASSETS)

# Perfilar FastSAM-s
model = FastSAM("FastSAM-s.pt")
model.info()
model(ASSETS)

# Avalie o desempenho dos modelos YOLO (ONNX)
for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt", "yolo26n-seg.pt"]:
    model = YOLO(file_name)
    model.info()
    onnx_path = model.export(format="onnx", dynamic=True, nms=False)  # Cabeça sem NMS do YOLO26; sem efeito para YOLOv8/YOLO11
    model = YOLO(onnx_path)
    model(ASSETS)

Exemplos de uso#

Os modelos FastSAM são fáceis de integrar às tuas aplicações Python. A Ultralytics oferece uma API Python e comandos da CLI.

Uso de predição#

Para segmentar uma imagem, use o método predict, conforme mostrado abaixo:

Exemplo
from ultralytics import FastSAM

# Defina uma fonte para inferência
source = "path/to/bus.jpg"

# Crie um modelo FastSAM
model = FastSAM("FastSAM-s.pt")  # ou FastSAM-x.pt

# Executa a inferência numa imagem
everything_results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)

# Executar inferência com prompt de bboxes
results = model(source, bboxes=[439, 437, 524, 709])

# Execute a inferência com um prompt de pontos
results = model(source, points=[[200, 200]], labels=[1])

# Execute a inferência com prompts de texto
results = model(source, texts="a photo of a dog")

# Execute a inferência simultaneamente com prompts de caixas delimitadoras, pontos e texto
results = model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")

Este trecho demonstra como é simples carregar um modelo pré-treinado e executar uma predição em uma imagem.

Exemplo de FastSAMPredictor

Executa a inferência numa imagem uma vez para obter todos os results de segmentação e, em seguida, aplica prompts a esses resultados várias vezes sem voltar a executar a inferência.

from ultralytics.models.fastsam import FastSAMPredictor

# Crie um FastSAMPredictor
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "model": "FastSAM-s.pt", "save": False, "imgsz": 1024}
predictor = FastSAMPredictor(overrides=overrides)

# Segmente tudo
everything_results = predictor("ultralytics/assets/bus.jpg")

# Inferência com prompt
bbox_results = predictor.prompt(everything_results, bboxes=[[200, 200, 300, 300]])
point_results = predictor.prompt(everything_results, points=[200, 200])
text_results = predictor.prompt(everything_results, texts="a photo of a dog")
Nota

Todos os results devolvidos nos exemplos acima são objetos Results que dão acesso às máscaras previstas e à imagem de origem.

Uso de validação#

FastSAM só suporta a deteção e a segmentação de uma única classe de objetos, pelo que reconhece e segmenta todos os objetos como pertencendo à mesma classe. Ao preparar o conjunto de dados, converte todos os IDs de categoria de objetos em 0.

A validação do modelo em um conjunto de dados pode ser feita da seguinte forma:

Exemplo
from ultralytics import FastSAM

# Crie um modelo FastSAM
model = FastSAM("FastSAM-s.pt")  # ou FastSAM-x.pt

# Valida o modelo
results = model.val(data="coco8-seg.yaml")

Uso do rastreamento#

Para rastrear objetos em uma imagem, use o método track, conforme mostrado abaixo:

Exemplo
from ultralytics import FastSAM

# Crie um modelo FastSAM
model = FastSAM("FastSAM-s.pt")  # ou FastSAM-x.pt

# Rastrear com um modelo FastSAM em um vídeo
results = model.track(source="path/to/video.mp4", imgsz=640)

Uso oficial do FastSAM#

O FastSAM também está disponível diretamente no repositório CASIA-LMC-Lab/FastSAM. Aqui está uma breve visão geral das etapas típicas que você pode seguir para usar o FastSAM:

Instalação#

  1. Clone o repositório FastSAM:

    git clone https://github.com/CASIA-LMC-Lab/FastSAM.git
  2. Crie e ative um ambiente Conda com Python 3.9:

    conda create -n FastSAM python=3.9
    conda activate FastSAM
  3. Acesse o repositório clonado e instale os pacotes necessários:

    cd FastSAM
    pip install -r requirements.txt
  4. Instale o modelo CLIP:

    pip install git+https://github.com/ultralytics/CLIP.git

Exemplo de uso#

  1. Baixe um checkpoint do modelo.

  2. Use o FastSAM para inferência. Exemplos de comandos:

    • Segmente tudo em uma imagem:

      python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
    • Segmente objetos específicos usando um prompt de texto:

      python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "the yellow dog"
    • Segmente objetos dentro de uma caixa delimitadora (forneça as coordenadas da caixa no formato xywh):

      python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
    • Segmente objetos próximos a pontos específicos:

      python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"

Além disso, você pode experimentar o FastSAM por meio da demonstração no Colab do CASIA-LMC-Lab.

Citações e agradecimentos#

Gostaríamos de reconhecer as contribuições significativas dos autores do FastSAM para a área de segmentação de instâncias em tempo real:

Citação
@misc{zhao2023fast,
      title={Fast Segment Anything},
      author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
      year={2023},
      eprint={2306.12156},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}

O artigo original do FastSAM está disponível no arXiv. Os autores disponibilizaram publicamente seu trabalho, e a base de código pode ser acessada no GitHub. Agradecemos os esforços deles para promover a área e tornar seu trabalho acessível à comunidade em geral.

Perguntas frequentes#

  • FastSAM, abreviatura de Fast Segment Anything Model, é uma solução em tempo real baseada numa rede neuronal convolucional (CNN), concebida para reduzir as exigências computacionais e manter um elevado desempenho em tarefas de segmentação de objetos. Ao contrário do Segment Anything Model (SAM), que utiliza uma arquitetura mais pesada baseada em Transformer, FastSAM utiliza Ultralytics YOLOv8-seg para realizar uma segmentação eficiente de instâncias em duas etapas: segmentação de todas as instâncias, seguida de seleção orientada por prompts.

  • FastSAM realiza segmentação em tempo real ao dividir a tarefa em duas etapas: segmentação de todas as instâncias com YOLOv8-seg e seleção orientada por prompts. Tirando partido da eficiência computacional das CNNs, FastSAM reduz significativamente as exigências computacionais e de recursos, mantendo um desempenho competitivo. Esta abordagem em duas etapas permite ao FastSAM oferecer uma segmentação rápida e eficiente, adequada para aplicações que exigem resultados rápidos.

  • O FastSAM é útil em diversas tarefas de visão computacional que exigem desempenho de segmentação em tempo real. As aplicações incluem:

    • Automação industrial para controle e garantia da qualidade
    • Análise de vídeo em tempo real para segurança e vigilância
    • Veículos autônomos para detecção e segmentação de objetos
    • Imagens médicas para tarefas de segmentação precisas e rápidas

    A capacidade de lidar com vários prompts de interação do usuário torna o FastSAM adaptável e flexível para diferentes cenários.

  • Para usar o FastSAM para inferência em Python, você pode seguir o exemplo abaixo:

    from ultralytics import FastSAM
    
    # Defina uma fonte para inferência
    source = "path/to/bus.jpg"
    
    # Crie um modelo FastSAM
    model = FastSAM("FastSAM-s.pt")  # ou FastSAM-x.pt
    
    # Executa a inferência numa imagem
    everything_results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
    
    # Executar inferência com prompt de bboxes
    results = model(source, bboxes=[439, 437, 524, 709])
    
    # Execute a inferência com um prompt de pontos
    results = model(source, points=[[200, 200]], labels=[1])
    
    # Execute a inferência com prompts de texto
    results = model(source, texts="a photo of a dog")
    
    # Execute a inferência simultaneamente com prompts de caixas delimitadoras, pontos e texto
    results = model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")

    Para saber mais sobre os métodos de inferência, consulte a seção Uso de previsão da documentação.

  • O FastSAM aceita vários tipos de prompts para orientar as tarefas de segmentação:

    • Prompt para tudo: gera a segmentação de todos os objetos visíveis.
    • Prompt de caixa delimitadora (BBox): segmenta objetos dentro de uma caixa delimitadora especificada. Uma caixa que não se sobrepõe a nenhuma máscara detetada não seleciona nada.
    • Prompt de texto: usa um texto descritivo para segmentar objetos que correspondam à descrição.
    • Prompt de ponto: segmenta objetos próximos a pontos definidos pelo usuário.

    Essa flexibilidade permite que o FastSAM se adapte a uma ampla variedade de cenários de interação com o usuário, ampliando sua utilidade em diferentes aplicações. Para saber mais sobre como usar esses prompts, consulte a seção Principais recursos.

Comentários26

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

    1. PrashantDixit0GitHub(editado)

      @qinfendekaizhou, can you share the reproducible code for it? Or the reference from where u noticed this.

      In general, post-process time gets increased because of the post-processes involved to show the results, like

      1. NMS
      2. filtering by confidence score/ labels
      3. Scaling results to the original given inputs
      4. Number of objects to be annotated,
      5. Type of annotation, like BB or Segmentation
  1. shahedmomenzadehGitHub

    Hi, I have a question Can I use the generated bbox cordinates by a yolo detection model like yolov11 as bboxes prompt for FastSAM ?

    1. Glenn JocherUltralytics

      @shahedmomenzadeh yes, you can use YOLO detection model-generated bbox coordinates as prompts for FastSAM. The FastSAM documentation shows examples of passing bbox coordinates directly to the model using either the Python API or CLI. Just ensure your coordinates are in XYXY format as shown in the examples.

  2. ismailwaleGitHub

    How can I make an inference of a video using frame by frame in loop using FastSam ?because I tried multiple times making inference directly with video predictor I constantly running out of memory despite setting stream =True since SAM is trying to keep the memory of 2000 frames of the video at ones . I will appreciate any ideal on how to predict and segment the video as a single frame image at every instance and put everything in a loop.

    Similar question win MobileSam

    1. Glenn JocherUltralytics

      @ismailwale to process a video frame by frame and avoid memory overload with FastSAM or MobileSAM, load the video as a frame sequence using a tool like OpenCV. Loop through each frame, run inference on it individually, and clear any cached results to free up memory between frames. For reference on frame-wise usage, consult OpenCV and FastSAM integration. Let me know if you need further clarifications!

    2. llu025GitHub

      Thank you all for your great work! I am having troubles with prompting with a bounding box, it seems the FastSAM model ignores it and detects objects all over the video frames. This is how I obtain the results:

      results = model(
          input_filename,
          device=device,
          imgsz=(736, 1280),
          verbose=False,
          stream=True,
          bboxes=[0, 0, 360, 640],
          retina_masks=True,
          conf=0.4,
          iou=0.9,
      )

      I also tried with bboxes=[[0, 0, 360, 640]], without success. The model should detect objects in the top left quadrant of the video, instead it detects everywhere. Also, it oddly does not raise any error or warnings, both with bboxes as list of integers or bboxes as list of lists of integers.

    3. Glenn JocherUltralytics

      It seems the bounding box prompts aren't being applied as expected. Ensure the bboxes format is correct (e.g., [[x1, y1, x2, y2]] as a list of lists). Additionally, try using the FastSAMPredictor approach for more controlled prompt application, as shown in this example. Let me know if the issue persists!

    4. llu025GitHub

      Thank you @glenn-jocher for the "prompt" response ;-)

      I need to use stream=True since I am working with large videos. I cannot use it coupled with FastSAMPredictor, because it does not support it. My only alternative is to grab frames on my own with OpenCV, is that correct?

      By the way, in your examples in here bboxes is passed as a list of integers, I followed those in the beginning. I see in the examples with FastSAMPredictor that a list of lists is used instead. In any case, I ensured that I was using a list of lists, and it did not work anyway.

      Here's a minimal example of what I am trying to do, i.e., detecting objects in the top left part of the video:

      from ultralytics import FastSAM
      import os
      import ffmpeg
      
      input_filename = "test_video.mp4"
      base_name = os.path.splitext(os.path.basename(input_filename))[0]
      output_filename = os.path.join("output", f"{base_name}.avi")
      
      model = FastSAM("models/FastSAM-x.pt")
      
      process2 = (
          ffmpeg.input(
              "pipe:",
              format="rawvideo",
              pix_fmt="rgb24",
              s="1280x720",
              loglevel="-8",
          )
          .output(
              output_filename,
              pix_fmt="yuv420p",
              vcodec="libx264",
              loglevel="-8",
              crf=17,
          )
          .overwrite_output()
          .run_async(pipe_stdin=True)
      )
      
      results = model(
          input_filename,
          device="cuda",
          imgsz=(736, 1280),
          verbose=False,
          stream=True,
          bboxes=[[0, 0, 360, 640]],
          retina_masks=True,
          conf=0.4,
          iou=0.9,
      )
      
      for result in results:
          frame = result.plot()
          # Save on disk with process2
          process2.stdin.write(frame.tobytes())
      
      process2.stdin.close()
      process2.wait()
    5. Glenn JocherUltralytics

      Thank you for the detailed explanation and example. Yes, you're correct—using OpenCV to manually grab frames is a valid and efficient approach, especially when working with stream=True for large videos, as it avoids memory issues. Regarding bboxes, FastSAM expects a list of lists in the format [[x1, y1, x2, y2]]. If this still doesn't work as intended, please ensure your bounding box coordinates are correct and within the frame dimensions. Let us know if you encounter any further issues!

    6. llu025GitHub

      I still encounter the same issue. I used bboxes=[[20, 20, 500, 500]] just to be 100% sure the coordinates are within the the frame dimensions (1280x720), nothing changed. Since I have to grab frames with OpenCV anyway, I will just crop them myself, but I am quite sure this option is not working as intended.

    7. Glenn JocherUltralytics

      @llu025 thank you for the update. If you’re certain the bboxes parameter is properly configured and still not working as intended, cropping frames manually with OpenCV before passing them to the model is indeed a reliable workaround. It may also be worth checking the latest FastSAM updates or reporting this as a potential issue to ensure the bounding box prompt functionality is reviewed. Let us know if you need further assistance!

  3. chongkuiqiGitHub

    Thanks for your great work! I'm using FastSAM-x with bboxes prompt, the original image shape is [720, 1280], and I set 'imgsz' 1024. However, the results mask shape is [576, 1024], but I remembered in ultralytics-8.2.10, I can get masks with the same shape as the original image. May I ask why this change happened ?

    1. Glenn JocherUltralytics

      @feiwenxiong fastSAM should support multiple boxes. If you're experiencing limitations, please ensure your input format is correct. For further assistance, you might want to check the latest updates or documentation.

  4. YuechengLiuGitHub

    Thanks the authors for the great work!

    I'm using FastSAM-x for instance segmentation (bboxes as the prompt), but I find that the shape of the predicted masks mismatch with the bounding box number. (e.g. the model takes 18 bboxes as input, but the shape of the predicted mask is (17, H, W)) . I tried to set conf=0.01 and iou=0.999, but it doesn't work. How can I solve that? Thanks!

    1. Glenn JocherUltralytics

      @YuechengLiu thank you for your kind words! The issue you're experiencing might be due to a mismatch in the bounding box prompts and the segmentation results. Please ensure you're using the latest version of the FastSAM model. If the problem persists, consider checking the input format and the bounding box coordinates. For further assistance, you can refer to the FastSAM documentation: https://docs.ultralytics.com/models/fast-sam/.

    2. YuechengLiuGitHub

      Thanks for your kind reply! The bounding boxes I'm using are predicted by yolov10x (result.boxes.xyxy), so I think the input format might be right. I also tried the same bounding boxes for mobile_sam, and the output dimension is as expected (same as the input dimension). The problem does not always occur. Do you have any idea about that? Thanks!

    3. Glenn JocherUltralytics

      Thanks for confirming you're using the latest version. Given that the issue is intermittent, it might be related to the specific bounding boxes or the image content. Please try running the model with a different set of bounding boxes or images to see if the issue persists. If it does, consider opening an issue on the GitHub repository with detailed information for further investigation.

  5. nguyenvandang1998GitHub

    Hi! I am using the FastSAM model and trying to obtain information about the bounding box and mask image of the object, but I don't know how to do it. I hope you can help me. Thank you very much!!

    1. Glenn JocherUltralytics(editado)

      Hi there! 🙌 To extract both bounding boxes and mask images using the FastSAM model, you would typically work with the results object returned by the model's prediction method. For the bounding boxes, you can access them directly as shown in the documentation or examples provided. For the mask images, since FastSAM is designed for real-time segmentation, the results should also include segmentation masks corresponding to detected objects.

      Here's a simplified way to access both:

      from ultralytics import FastSAM
      
      # Define your image source
      source = 'path/to/your/image.jpg'
      
      # Load the FastSAM model (ensure you've chosen the correct model path)
      model = FastSAM('FastSAM-s.pt')  # or another appropriate model
      
      # Perform inference
      results = model(source)
      
      # Accessing bounding boxes (assuming XYXY format)
      boxes = results[0].boxes.xyxy
      
      # Accessing segmentation masks
      # The masks are directly associated with detected objects in the results
      masks = results[0].masks
      
      # To visualize or further process masks and boxes, you would iterate through these objects

      To visualize or save the masks, you'd typically iterate over the masks object, and each mask can be processed according to your requirements (e.g., overlaying on the original image or saving as separate mask images).

      Remember, the exact attribute names (boxes, masks) and methods might vary based on the model output specification, so it's always good to refer to the specific documentation or example codes for guidance.

      Hope this helps! Let us know if you have more questions. 😊

      2