Link to this sectionPredição de modelo com Ultralytics YOLO#

Link to this sectionIntrodução#

No mundo do machine learning e da computer vision, o processo de dar sentido a dados visuais é frequentemente chamado de inferência ou predição. O Ultralytics YOLO26 oferece um recurso poderoso conhecido como modo predict, feito sob medida para inferência de alto desempenho em tempo real em uma ampla gama de fontes de dados.

Link to this sectionAplicações do mundo real#

Manufatura	Esportes	Segurança
Detecção de Peças de Reposição de Veículos	Detecção de Jogadores de Futebol	Detecção de Queda de Pessoas

Link to this sectionPor que usar o Ultralytics YOLO para inferência?#

Veja por que você deve considerar o modo predict do YOLO26 para suas várias necessidades de inferência:

• Versatilidade: Capaz de executar inferência em imagens, vídeos e até mesmo transmissões ao vivo.
• Desempenho: Projetado para processamento em tempo real e de alta velocidade sem sacrificar a accuracy.
• Facilidade de uso: Interfaces intuitivas em Python e CLI para implantação e teste rápidos.
• Altamente personalizável: Várias configurações e parâmetros para ajustar o comportamento de inferência do modelo de acordo com suas necessidades específicas.
• Pronto para produção: Implante modelos como endpoints de API na Ultralytics Platform com escalonamento automático e monitoramento, ou execute a inferência localmente.

Link to this sectionPrincipais recursos do modo predict#

O modo predict do YOLO26 foi projetado para ser robusto e versátil, apresentando:

• Compatibilidade com múltiplas fontes de dados: Seja com dados em formato de imagens individuais, uma coleção de imagens, arquivos de vídeo ou fluxos de vídeo em tempo real, o modo predict resolve para você.
• Modo de streaming: Use o recurso de streaming para gerar um gerador de objetos Results com uso eficiente de memória. Habilite isso definindo stream=True no método de chamada do preditor.
• Processamento em lote: Processe várias imagens ou quadros de vídeo em um único lote, reduzindo ainda mais o tempo total de inferência.
• Fácil de integrar: Integre facilmente com pipelines de dados existentes e outros componentes de software, graças à sua API flexível.

Os modelos Ultralytics YOLO retornam uma lista Python de objetos Results ou um gerador de objetos Results com eficiência de memória quando stream=True é passado para o modelo durante a inferência:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # pretrained YOLO26n model

# Run batched inference on a list of images
results = model(["image1.jpg", "image2.jpg"])  # return a list of Results objects

# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    obb = result.obb  # Oriented boxes object for OBB outputs
    result.show()  # display to screen
    result.save(filename="result.jpg")  # save to disk

Link to this sectionFontes de inferência#

O YOLO26 pode processar diferentes tipos de fontes de entrada para inferência, conforme mostrado na tabela abaixo. As fontes incluem imagens estáticas, fluxos de vídeo e vários formatos de dados. A tabela também indica se cada fonte pode ser usada no modo de streaming com o argumento stream=True ✅. O modo de streaming é benéfico para processar vídeos ou transmissões ao vivo, pois cria um gerador de resultados em vez de carregar todos os quadros na memória.

Abaixo estão exemplos de código para usar cada tipo de fonte:

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Define path to the image file
source = "path/to/image.jpg"

# Run inference on the source
results = model(source)  # list of Results objects

Link to this sectionArgumentos de inferência#

model.predict() aceita múltiplos argumentos que podem ser passados no momento da inferência para substituir os padrões:

Link to this sectionFormato fixo vs retângulo mínimo (rect)#

Por padrão, o predict usa rect=True, o que permite o preenchimento de retângulo mínimo quando possível. A imagem é escalonada para caber dentro de imgsz e preenchida apenas até o múltiplo de stride mais próximo, portanto o tensor final pode ser menor que imgsz. O preenchimento de retângulo mínimo só é usado quando todas as imagens no lote têm o mesmo formato e o backend o suporta (PyTorch .pt, ou ONNX / Triton dinâmico). Caso contrário, as imagens são preenchidas até o alvo completo imgsz.

Usa rect=False para preencher sempre até o alvo completo imgsz. Isso é recomendado quando precisas de um tamanho de entrada fixo para corresponder a modelos exportados (ONNX, TensorRT, etc.).

Inteiro vs tupla imgsz

• Um inteiro imgsz=640 torna-se um alvo quadrado (640, 640) após o arredondamento de stride.
• Uma tupla imgsz=(384, 672) define um alvo retangular. Com rect=True e auto=True, o tensor real pode ser menor que esse alvo.

Treino vs predict/export

O treino aceita apenas um único inteiro imgsz (uma lista [h, w] é convertida para o maior valor). Predict e export aceitam um inteiro ou uma tupla (height, width).

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on 'bus.jpg' with arguments
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)

Argumentos de inferência:

Argumentos de visualização:

Link to this sectionFormatos de imagem e vídeo#

O YOLO26 suporta vários formatos de imagem e vídeo, conforme especificado em ultralytics/data/utils.py. Vê as tabelas abaixo para os sufixos válidos e exemplos de comandos predict.

Link to this sectionImagens#

A tabela abaixo contém formatos de imagem Ultralytics válidos.

Link to this sectionVídeos#

A tabela abaixo contém formatos de vídeo Ultralytics válidos.

Link to this sectionTrabalhando com Resultados#

Todas as chamadas predict() da Ultralytics retornarão uma lista de objetos Results:

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # batch inference

Os objetos Results possuem os seguintes atributos:

Link to this sectionResultados por Tarefa#

Cada previsão retorna um objeto Results por imagem ou quadro. Os campos comuns acima estão sempre disponíveis, enquanto os dados de previsão específicos da tarefa são armazenados nos campos abaixo. Tensores de coordenadas, confiança e probabilidade são torch.float32 a menos que seja usada precisão reduzida (half precision), caso em que são torch.float16. Após result.numpy(), os tensores tornam-se arrays NumPy com dtypes NumPy correspondentes. Máscaras de instância são tensores binários torch.uint8, enquanto máscaras semânticas usam o dtype inteiro prático menor para IDs de classe: torch.uint8, torch.int16 ou torch.int32, dependendo da contagem de classes.

Os objetos Results possuem os seguintes métodos:

Para mais detalhes, consulte a documentação da classe Results.

Link to this sectionCaixas (Boxes)#

O objeto Boxes pode ser usado para indexar, manipular e converter caixas delimitadoras para diferentes formatos.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.boxes)  # print the Boxes object containing the detection bounding boxes

Aqui está uma tabela para os métodos e propriedades da classe Boxes, incluindo seu nome, tipo e descrição:

Para mais detalhes, consulte a documentação da classe Boxes.

Link to this sectionMáscaras#

O objeto Masks pode ser usado para indexar, manipular e converter máscaras para segmentos.

from ultralytics import YOLO

# Load a pretrained YOLO26n-seg Segment model
model = YOLO("yolo26n-seg.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.masks)  # print the Masks object containing the detected instance masks

Aqui está uma tabela para os métodos e propriedades da classe Masks, incluindo seu nome, tipo e descrição:

Para mais detalhes, consulte a documentação da classe Masks.

Link to this sectionSemanticMask#

SemanticMask armazena um mapa de classe denso para resultados de segmentação semântica. Ao contrário de Masks, ele não contém uma máscara binária por objeto e não fornece auxiliares de polígono.

from ultralytics import YOLO

# Load a pretrained YOLO26n-sem Semantic model
model = YOLO("yolo26n-sem.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.semantic_mask.data)  # print the H x W class-ID map

Link to this sectionKeypoints#

O objeto Keypoints pode ser usado para indexar, manipular e normalizar coordenadas.

from ultralytics import YOLO

# Load a pretrained YOLO26n-pose Pose model
model = YOLO("yolo26n-pose.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.keypoints)  # print the Keypoints object containing the detected keypoints

Aqui está uma tabela para os métodos e propriedades da classe Keypoints, incluindo seu nome, tipo e descrição:

Para mais detalhes, veja a documentação da classe Keypoints.

Link to this sectionProbs#

O objeto Probs pode ser usado para indexar, obter top1 e top5 índices e pontuações de classificação.

from ultralytics import YOLO

# Load a pretrained YOLO26n-cls Classify model
model = YOLO("yolo26n-cls.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.probs)  # print the Probs object containing the detected class probabilities

Aqui está uma tabela resumindo os métodos e propriedades da classe Probs:

Para mais detalhes, veja a documentação da classe Probs.

Link to this sectionOBB#

O objeto OBB pode ser usado para indexar, manipular e converter caixas delimitadoras orientadas para diferentes formatos.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n-obb.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/boats.jpg")  # results list

# View results
for r in results:
    print(r.obb)  # print the OBB object containing the oriented detection bounding boxes

Aqui está uma tabela para os métodos e propriedades da classe OBB, incluindo seus nomes, tipos e descrições:

Para mais detalhes, veja a documentação da classe OBB.

Link to this sectionPlotando Resultados#

O método plot() em objetos Results facilita a visualização de predições ao sobrepor objetos detectados (como caixas delimitadoras, máscaras, keypoints e probabilidades) sobre a imagem original. Este método retorna a imagem anotada como um array NumPy, permitindo fácil exibição ou salvamento.

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on 'bus.jpg'
results = model(["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/zidane.jpg"])  # results list

# Visualize the results
for i, r in enumerate(results):
    # Plot results image
    im_bgr = r.plot()  # BGR-order numpy array
    im_rgb = Image.fromarray(im_bgr[..., ::-1])  # RGB-order PIL image

    # Show results to screen (in supported environments)
    r.show()

    # Save results to disk
    r.save(filename=f"results{i}.jpg")

Link to this sectionParâmetros do Método plot()#

O método plot() suporta vários argumentos para personalizar a saída:

Link to this sectionInferência Thread-Safe#

Garantir a segurança de thread durante a inferência é crucial quando você está executando vários modelos YOLO em paralelo em threads diferentes. A inferência thread-safe garante que as predições de cada thread sejam isoladas e não interfiram umas nas outras, evitando condições de corrida e garantindo saídas consistentes e confiáveis.

Ao usar modelos YOLO em uma aplicação multi-thread, é importante instanciar objetos de modelo separados para cada thread ou empregar armazenamento local de thread para evitar conflitos:

from threading import Thread

from ultralytics import YOLO

def thread_safe_predict(model, image_path):
    """Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
    model = YOLO(model)
    results = model.predict(image_path)
    # Process results

# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()

Para uma visão aprofundada sobre a inferência thread-safe com modelos YOLO e instruções passo a passo, por favor, consulte nosso Guia de Inferência Thread-Safe com YOLO. Este guia fornecerá todas as informações necessárias para evitar armadilhas comuns e garantir que sua inferência multi-thread funcione sem problemas.

Link to this sectionLoop for de fonte de streaming#

Aqui está um script Python usando OpenCV (cv2) e YOLO para executar inferência em quadros de vídeo. Este script assume que você já instalou os pacotes necessários (opencv-python e ultralytics).

import cv2

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO inference on the frame
        results = model(frame)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLO Inference", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Este script executará predições em cada quadro do vídeo, visualizará os resultados e os exibirá em uma janela. O loop pode ser encerrado pressionando 'q'.

Link to this sectionFAQ#

Link to this sectionO que é o Ultralytics YOLO e seu modo predict para inferência em tempo real?#

O Ultralytics YOLO é um modelo de última geração para detecção de objetos, segmentação de instâncias, segmentação semântica e classificação em tempo real. Seu modo predict permite que usuários realizem inferência de alta velocidade em várias fontes de dados, como imagens, vídeos e transmissões ao vivo. Projetado para desempenho e versatilidade, ele também oferece processamento em lote e modos de streaming. Para mais detalhes sobre seus recursos, confira o modo predict do Ultralytics YOLO.

Link to this sectionComo posso executar inferência usando o Ultralytics YOLO em diferentes fontes de dados?#

O Ultralytics YOLO pode processar uma ampla gama de fontes de dados, incluindo imagens individuais, vídeos, diretórios, URLs e streams. Você pode especificar a fonte de dados na chamada model.predict(). Por exemplo, use 'image.jpg' para uma imagem local ou 'https://ultralytics.com/images/bus.jpg' para uma URL. Confira os exemplos detalhados para várias fontes de inferência na documentação.

Link to this sectionComo otimizo a velocidade de inferência e o uso de memória do YOLO?#

Para otimizar a velocidade de inferência e gerenciar a memória de forma eficiente, você pode usar o modo de streaming definindo stream=True no método de chamada do preditor. O modo de streaming gera um gerador de objetos Results eficiente em termos de memória, em vez de carregar todos os quadros na memória. Para processar vídeos longos ou grandes conjuntos de dados, o modo de streaming é particularmente útil. Saiba mais sobre o modo de streaming.

Link to this sectionQuais argumentos de inferência o Ultralytics YOLO suporta?#

O método model.predict() no YOLO suporta vários argumentos como conf, iou, imgsz, device e outros. Esses argumentos permitem que você personalize o processo de inferência, definindo parâmetros como limites de confiança, tamanho da imagem e o dispositivo usado para computação. Descrições detalhadas desses argumentos podem ser encontradas na seção argumentos de inferência.

Link to this sectionComo posso visualizar e salvar os resultados das predições do YOLO?#

Após executar a inferência com o YOLO, os objetos Results contêm métodos para exibir e salvar imagens anotadas. Você pode usar métodos como result.show() e result.save(filename="result.jpg") para visualizar e salvar os resultados. Quaisquer diretórios pais ausentes no caminho do nome do arquivo são criados automaticamente (por exemplo, result.save("path/to/result.jpg")). Para uma lista completa desses métodos, consulte a seção trabalhando com resultados.