Predição de Modelo com Ultralytics YOLO

Introdução

No mundo do machine learning e da computer vision, o processo de interpretar dados visuais é frequentemente chamado de inferência ou predição. O Ultralytics YOLO26 oferece um recurso poderoso conhecido como predict mode, projetado para inferência de alto desempenho em tempo real através de uma ampla gama de fontes de dados.

Aplicações do Mundo Real

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

Por que usar o Ultralytics YOLO para inferência?

Veja por que você deve considerar o predict mode do YOLO26 para suas diversas 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 de alta velocidade sem sacrificar a accuracy.
• Facilidade de Uso: Interfaces intuitivas em Python e CLI para implementação e testes rápidos.
• Altamente Customizável: Diversas configurações e parâmetros para ajustar o comportamento de inferência do modelo de acordo com seus requisitos específicos.
• Pronto para Produção: Implemente modelos como endpoints de API na Ultralytics Platform com escalonamento automático e monitoramento, ou execute a inferência localmente.

Principais Recursos do Predict Mode

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

• Compatibilidade com Múltiplas Fontes de Dados: Se seus dados estão na forma de imagens individuais, uma coleção de imagens, arquivos de vídeo ou transmissões de vídeo em tempo real, o predict mode atende a você.
• Modo de Streaming: Use o recurso de streaming para gerar um gerador eficiente em termos de memória de objetos Results. 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 Integração: 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 eficiente de memória de objetos Results 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

Fontes 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, transmissões 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

Argumentos de Inferência

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

Forma fixa versus 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é ao 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 a mesma forma e o backend suporta isso (PyTorch .pt, ou ONNX dinâmico / Triton). Caso contrário, as imagens são preenchidas até ao alvo imgsz completo.

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

Inteiro versus tuplo imgsz

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

Treino versus predict/export

O treino aceita apenas um imgsz inteiro único (uma lista [h, w] é forçada para o valor maior). Predict e export aceitam um inteiro ou um tuplo (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:

Formatos de Imagem e Vídeo

O YOLO26 suporta vários formatos de imagem e vídeo, conforme especificado em ultralytics/data/utils.py. Veja as tabelas abaixo para os sufixos válidos e comandos de exemplo de previsão.

Imagens

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

Vídeos

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

Trabalhando 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

Objetos Results possuem os seguintes atributos:

Objetos Results possuem os seguintes métodos:

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

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, veja a documentação da classe Boxes.

Masks

O objeto Masks pode ser usado para indexar, manipular e converter máscaras em 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, veja a documentação da classe Masks.

Keypoints

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 seus nomes, tipos e descrições:

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

Probs

O objeto Probs pode ser usado para indexar e obter índices e pontuações top1 e top5 da 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.

OBB

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.

Visualizando 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) na 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")

Parâmetros do método plot()

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

Inferência Thread-Safe

Garantir a segurança de thread durante a inferência é crucial quando você está executando vários modelos YOLO em paralelo através de diferentes threads. 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 resultados consistentes e confiáveis.

Ao usar modelos YOLO em uma aplicação multi-threaded, é 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 detalhada sobre inferência thread-safe com modelos YOLO e instruções passo a passo, por favor, consulte nosso Guia de Inferência Thread-Safe YOLO. Este guia fornecerá todas as informações necessárias para evitar erros comuns e garantir que sua inferência multi-threaded funcione sem problemas.

Loop for de fonte de streaming

Aqui está um script Python usando OpenCV (cv2) e YOLO para executar inferência em frames 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 frame do vídeo, visualizará os resultados e os exibirá em uma janela. O loop pode ser encerrado pressionando 'q'.

FAQ

O que é Ultralytics YOLO e seu modo predict para inferência em tempo real?

Ultralytics YOLO é um modelo de última geração para detecção de objetos em tempo real, segmentação de instância, segmentação semântica e classificação. Seu modo predict permite aos usuários realizar 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 modos de processamento em lote e streaming. Para mais detalhes sobre seus recursos, confira o modo predict do Ultralytics YOLO.

Como posso executar inferência usando Ultralytics YOLO em diferentes fontes de dados?

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.

Como 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 eficiente em termos de memória de objetos Results em vez de carregar todos os frames 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.

Quais 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.

Como posso visualizar e salvar os resultados das predições YOLO?

Após executar a inferência com 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 filename são criados automaticamente (ex: result.save("path/to/result.jpg")). Para uma lista abrangente desses métodos, consulte a seção trabalhando com resultados.