Predição de modelo com Ultralytics YOLO#

Introduçã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 predict mode, adaptado para inferência de alto desempenho e em tempo real em uma ampla gama de fontes de dados.

Aplicaçõ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

Por 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 de alta velocidade em tempo real 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 inferência da Ultralytics Platform com auto-scaling e monitoramento, ou execute a inferência localmente.

Principais 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ê.
• Streaming Mode: Use o recurso de streaming para gerar um gerador eficiente em termos de memória de objetos Results. Ative isso definindo stream=True no método de chamada do preditor. Ao contrário do comportamento padrão (stream=False), que retorna uma lista contendo todos os resultados, stream=True produz resultados um por um, tornando-o especialmente útil para vídeos longos e transmissões ao vivo.
• 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 do Ultralytics YOLO retornam uma lista em Python de objetos Results ou um gerador eficiente em termos 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, fluxos de vídeo e vários formatos de dados. A tabela também indica se cada fonte pode ser usada em streaming mode com o argumento stream=True ✅. O streaming mode é benéfico para o processamento de 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 vários argumentos que podem ser passados no momento da inferência para substituir os padrões:

Forma fixa vs retângulo mínimo (rect)#

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

Use rect=False para sempre preencher até o destino completo de imgsz. Isso é recomendado quando você precisa de um tamanho de entrada fixo para corresponder a modelos exportados (ONNX, TensorRT, etc.).

Inteiro vs tupla imgsz

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

Treino vs predict/export

O treinamento 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:

Formatos de imagem e vídeo#

O YOLO26 suporta vários formatos de imagem e vídeo, conforme especificado em ultralytics/data/utils.py. Consulte as tabelas abaixo para ver os sufixos válidos e exemplos de comandos de prediçã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 do Ultralytics predict() 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 têm os seguintes atributos:

Resultados por Tarefa#

Quais campos abaixo são preenchidos depende da tarefa do seu modelo — compare detecção, segmentação, segmentação semântica, estimativa de profundidade, classificação, pose e OBB se você ainda não escolheu uma. Cada predição retorna um objeto Results por imagem ou quadro. Os campos comuns acima estão sempre disponíveis, enquanto os dados de predição específicos da tarefa são armazenados nos campos abaixo. Os tensores de coordenadas, confiança e probabilidade são torch.float32, a menos que a precisão reduzida (half precision) seja usada, caso em que se tornam torch.float16. Após result.numpy(), os tensores se tornam arrays do NumPy com os dtypes correspondentes do NumPy. As máscaras de instância são tensores binários torch.uint8, enquanto as 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 têm os seguintes métodos:

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

Caixas (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 nome, tipo e descrição:

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

Máscaras#

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 nome, tipo e descrição:

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

SemanticMask#

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 utilitários 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

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 nome, tipo e descrição:

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

Probs#

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

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 para a classe Probs:

Para mais detalhes, consulta 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 nome, tipo e descrição:

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

Plotando Resultados#

O método plot() em objetos Results facilita a visualização de predições sobrepondo objetos detectados (como caixas delimitadoras, máscaras, keypoints e probabilidades) na imagem original. Este método retorna a imagem anotada como um array do 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 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 análise detalhada da inferência thread-safe com modelos YOLO e instruções passo a passo, consulte nosso Guia de Inferência Thread-Safe do YOLO. Este guia fornecerá todas as informações necessárias para evitar armadilhas comuns e garantir que sua inferência multithread seja executada sem problemas.

Loop 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'.

O que vem a seguir#

Tudo pronto para ir além de um modelo pré-treinado? Confirme que sua tarefa se adapta ao seu problema, formate seus próprios dados com o Guia de Datasets e, em seguida, treine com eles.

FAQ#

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

O Ultralytics YOLO é um modelo de última geração para object detection, instance segmentation, semantic segmentation, depth estimation e classification em tempo real. O seu predict mode permite que os 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 streaming modes. Para obter mais detalhes sobre seus recursos, confira o predict mode do Ultralytics YOLO.

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

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 com eficiência, você pode usar o streaming mode definindo stream=True no método de chamada do preditor. O streaming mode gera um gerador eficiente em termos de memória de objetos Results em vez de carregar todos os quadros na memória. Para processar vídeos longos ou grandes conjuntos de dados, o streaming mode é particularmente útil. Saiba mais sobre o streaming mode.

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 muito mais. 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 extraio embeddings de um modelo YOLO?#

Use model.embed(source) para extrair embeddings de características da penúltima camada, ou passe embed=[layer_index] para model.predict() para escolher camadas específicas.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
source = "https://ultralytics.com/images/bus.jpg"

results = model.predict(source)  # Results objects
embeddings = model.embed(source)  # list of torch.Tensor embeddings

Como 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 pai ausentes no caminho do nome do arquivo são criados automaticamente (por exemplo, result.save("path/to/result.jpg")). Para obter uma lista abrangente desses métodos, consulte a seção trabalhando com resultados.