Predição de modelos com o Ultralytics YOLO#

Introdução#

No mundo da aprendizagem automática e da visão computacional, o processo de interpretar dados visuais é frequentemente chamado inferência ou predição. O Ultralytics YOLO26 oferece uma funcionalidade poderosa conhecida como modo predict, concebida para inferência de alto desempenho em tempo real com uma ampla variedade de fontes de dados.

Consulta a pré-visualização inédita do YOLO27 para ver exemplos de inferência planeados.

Aplicações no mundo real#

Por que usar o Ultralytics YOLO para inferência?#

Veja por que deves considerar o modo de predição do YOLO26 para as tuas diversas necessidades de inferência:

• Versatilidade: capaz de executar inferências em imagens, vídeos e até transmissões ao vivo.
• Desempenho: desenvolvido para processamento em tempo real e alta velocidade, sem sacrificar a precisão.
• Facilidade de uso: interfaces intuitivas de Python e CLI para implantação e testes rápidos.
• Altamente personalizável: várias configurações e parâmetros permitem ajustar o comportamento da inferência do modelo de acordo com os teus requisitos específicos.
• Pronto para produção: implanta modelos como endpoints de inferência da Ultralytics Platform com escalabilidade automática e monitoramento, ou executa a inferência localmente.

Principais recursos do modo de predição#

O modo de predição do YOLO26 foi desenvolvido para ser robusto e versátil, com os seguintes recursos:

• Compatibilidade com várias fontes de dados: sejam dados na forma de imagens individuais, coleções de imagens, arquivos de vídeo ou transmissões de vídeo em tempo real, o modo de predição atende às tuas necessidades.
• Modo de streaming: usa o recurso de streaming para gerar um gerador de objetos Results que economiza memória. Ativa esse recurso 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 fornece os resultados um de cada vez, o que é especialmente útil para vídeos longos e transmissões ao vivo.
• Processamento em lote: processa 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: integra facilmente com pipelines de dados existentes e outros componentes de software graças à API flexível.

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

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n.pt")  # modelo YOLO26n pré-treinado

# Executa inferência em lote em uma lista de imagens
results = model(["image1.jpg", "image2.jpg"])  # retorna uma lista de objetos Results

# Processa a lista de resultados
for result in results:
    boxes = result.boxes  # Objeto Boxes para saídas de caixas delimitadoras
    masks = result.masks  # Objeto Masks para saídas de máscaras de segmentação
    keypoints = result.keypoints  # Objeto Keypoints para saídas de pose
    probs = result.probs  # Objeto Probs para saídas de classificação
    obb = result.obb  # Objeto de caixas orientadas para saídas OBB
    result.show()  # exibe na tela
    result.save(filename="result.jpg")  # salva no disco

Fontes de inferência#

O YOLO26 pode processar diferentes tipos de fontes de entrada para inferência, como mostra a 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 é útil 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

# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")

# Define o caminho para o arquivo de imagem
source = "path/to/image.jpg"

# Executa inferência na fonte
results = model(source)  # lista de objetos Results

Argumentos de inferência#

model.predict() aceita vários argumentos que podem ser passados no momento da inferência para substituir os valores padrão:

Formato fixo vs. retângulo mínimo (rect)#

Por padrão, predict usa rect=True, que permite o preenchimento de retângulo mínimo quando possível. A imagem é redimensionada para caber em imgsz e recebe preenchimento apenas até o múltiplo de stride mais próximo, então o tensor final pode ser menor que imgsz. O preenchimento de retângulo mínimo só é usado quando todas as imagens do lote têm o mesmo formato e o backend oferece suporte (PyTorch .pt ou uma exportação com formato dinâmico, como ONNX dinâmico). Caso contrário, as imagens recebem preenchimento até o destino de imgsz completo.

Use rect=False para sempre preencher até o destino imgsz completo. Essa opção é recomendada quando você precisa de um tamanho de entrada fixo compatível com modelos exportados (ONNX, TensorRT etc.).

imgsz inteiro vs. tupla

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

Treinamento vs. predict/export

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

from ultralytics import YOLO

# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")

# Execute inferência em 'bus.jpg' com argumentos
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#

YOLO26 é compatível com 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 predict.

Imagens#

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

Vídeos#

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

Trabalhando com Results#

Todas as chamadas predict() do Ultralytics retornam uma lista de objetos Results:

from ultralytics import YOLO

# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")

# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # inferência em lotes

Os objetos Results têm os seguintes atributos:

Resultados por tarefa#

Quais campos 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 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. Os tensores de coordenadas e confiança do YOLO são torch.float32; os tensores de probabilidade são torch.float32, a menos que seja usada inferência FP16 (quantize=16), caso em que são torch.float16. Após result.numpy(), os tensores se tornam arrays NumPy com tipos de dados NumPy correspondentes. As máscaras de instância são tensores binários torch.uint8, enquanto as máscaras semânticas usam o menor tipo de dado inteiro prático para os IDs de classe: torch.uint8, torch.int16 ou torch.int32, dependendo do número de classes.

Os objetos Results têm os seguintes métodos:

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

Caixas#

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

from ultralytics import YOLO

# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")

# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg")  # lista de resultados

# Ver resultados
for r in results:
    print(r.boxes)  # imprima o objeto Boxes que contém as caixas delimitadoras das detecções

Veja uma tabela com os métodos e as 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

# Carregue um modelo YOLO26n-seg Segment pré-treinado
model = YOLO("yolo26n-seg.pt")

# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg")  # lista de resultados

# Ver resultados
for r in results:
    print(r.masks)  # imprima o objeto Masks que contém as máscaras de instância detectadas

Veja uma tabela com os métodos e as 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 classes denso para resultados de segmentação semântica. Ao contrário de Masks, não contém uma máscara binária por objeto nem oferece funções auxiliares para polígonos.

from ultralytics import YOLO

# Carregue um modelo YOLO26n-sem Semantic pré-treinado
model = YOLO("yolo26n-sem.pt")

# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg")  # lista de resultados

# Ver resultados
for r in results:
    print(r.semantic_mask.data)  # imprima o mapa de IDs de classe H x W

Pontos-chave#

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

from ultralytics import YOLO

# Carregue um modelo YOLO26n-pose Pose pré-treinado
model = YOLO("yolo26n-pose.pt")

# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg")  # lista de resultados

# Ver resultados
for r in results:
    print(r.keypoints)  # imprima o objeto Keypoints que contém os pontos-chave detectados

Veja uma tabela com os métodos e as propriedades da classe Keypoints, incluindo nome, tipo e descrição:

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

Probabilidades#

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

from ultralytics import YOLO

# Carregue um modelo YOLO26n-cls Classify pré-treinado
model = YOLO("yolo26n-cls.pt")

# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg")  # lista de resultados

# Ver resultados
for r in results:
    print(r.probs)  # imprima o objeto Probs que contém as probabilidades das classes detectadas

Veja uma tabela que resume os métodos e as propriedades da 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

# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n-obb.pt")

# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/boats.jpg")  # lista de resultados

# Ver resultados
for r in results:
    print(r.obb)  # imprime o objeto OBB que contém as caixas delimitadoras das detecções orientadas

Veja uma tabela com os métodos e as propriedades da classe OBB, incluindo nome, tipo e descrição:

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

Visualização dos resultados#

O método plot() dos objetos Results facilita a visualização das predições ao sobrepor os objetos detectados (como caixas delimitadoras, máscaras, pontos-chave e probabilidades) à imagem original. Esse método retorna a imagem anotada como um array NumPy, facilitando sua exibição ou gravação.

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() aceita vários argumentos para personalizar a saída:

Inferência segura para threads#

Garantir a segurança entre threads durante a inferência é fundamental quando você executa vários modelos YOLO em paralelo, em diferentes threads. A inferência segura para threads 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 um aplicativo multithread, é importante instanciar objetos de modelo separados para cada thread ou usar armazenamento local à 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)
    # Processa os resultados

# Inicia threads, cada uma com sua própria instância do modelo
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 aprofundada da inferência segura para threads com modelos YOLO e instruções passo a passo, consulte nosso Guia de inferência segura para threads com YOLO. Este guia fornece todas as informações necessárias para evitar problemas comuns e garantir que a inferência multithread seja executada sem complicações.

Loop for da fonte de streaming#

Este é um script Python que usa OpenCV (cv2) e YOLO para executar inferências em quadros de vídeo. O script pressupõe que você já instalou os pacotes necessários (opencv-python e ultralytics).

import cv2

from ultralytics import YOLO

# Carregar o modelo YOLO
model = YOLO("yolo26n.pt")

# Abre o arquivo de vídeo
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Percorre os quadros do vídeo
while cap.isOpened():
    # Lê um quadro do vídeo
    success, frame = cap.read()

    if success:
        # Executa a inferência YOLO no quadro
        results = model(frame)

        # Visualiza os resultados no quadro
        annotated_frame = results[0].plot()

        # Exibe o quadro anotado
        cv2.imshow("YOLO Inference", annotated_frame)

        # Interrompe o loop se 'q' for pressionado
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrompe o loop se o vídeo chegar ao fim
        break

# Libera o objeto de captura de vídeo e fecha a janela de exibição
cap.release()
cv2.destroyAllWindows()

Este script executa predições em cada quadro do vídeo, visualiza os resultados e os exibe em uma janela. Você pode sair do loop pressionando 'q'.

O que fazer a seguir#

Pronto para ir além de um modelo pré-treinado? Confirme se a sua tarefa atende ao seu problema, formate seus próprios dados com o guia de conjuntos de dados e, em seguida, treine com eles.

Perguntas frequentes#