Predição de Modelos com Ultralytics YOLO

Introdução

No mundo do aprendizado de máquina e da visão computacional, o processo de extrair significado de dados visuais é chamado de 'inferência' ou 'predição'. O Ultralytics YOLO11 oferece um recurso poderoso conhecido como modo de predição, feito sob medida para inferência de alto desempenho e em tempo real em uma ampla variedade de fontes de dados.

Assista: Como Extrair as Saídas do Modelo Ultralytics YOLO para Projetos Personalizados.

Aplicações no 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 Ultralytics YOLO para Inferência?

Aqui está o porquê você deve considerar o modo de predição do YOLO11 para suas diversas necessidades de inferência:

• Versatilidade: Capaz de fazer inferências em imagens, vídeos e até transmissões ao vivo.
• Desempenho: Projetado para processamento em tempo real e de alta velocidade sem sacrificar a precisão.
• Facilidade de Uso: Interfaces intuitivas de python e CLI para rápida implantação e teste.
• Altamente Personalizável: Várias configurações e parâmetros para ajustar o comportamento de inferência do modelo de acordo com seus requisitos específicos.

Principais Características do Modo Predict

O modo de predição do YOLO11 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 modo de predição oferece suporte a todos.
• Modo de Streaming: Use o recurso de streaming para gerar um gerador de Results objetos com uso eficiente de memória. Habilite isso definindo stream=True no método de chamada do preditor.
• Processamento em Lote: A capacidade de processar várias imagens ou quadros de vídeo em um único lote, acelerando ainda mais o tempo de inferência.
• Integração Amigável: Integre-se 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 Results objetos ou um gerador python de Results objetos com uso eficiente de memória quando stream=True é passado para o modelo durante a inferência:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # pretrained YOLO11n 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

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # pretrained YOLO11n model

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

# Process results generator
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 YOLO11 pode processar diferentes tipos de fontes de entrada para inferência, como 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 frames na memória.

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

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

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define current screenshot as source
source = "screen"

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define remote image or video URL
source = "https://ultralytics.com/images/bus.jpg"

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

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Open an image using PIL
source = Image.open("path/to/image.jpg")

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

import cv2

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Read an image using OpenCV
source = cv2.imread("path/to/image.jpg")

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

import numpy as np

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Create a random numpy array of HWC shape (640, 640, 3) with values in range [0, 255] and type uint8
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype="uint8")

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

import torch

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Create a random torch tensor of BCHW shape (1, 3, 640, 640) with values in range [0, 1] and type float32
source = torch.rand(1, 3, 640, 640, dtype=torch.float32)

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define a path to a CSV file with images, URLs, videos and directories
source = "path/to/file.csv"

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define path to video file
source = "path/to/video.mp4"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define path to directory containing images and videos for inference
source = "path/to/dir"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define a glob search for all JPG files in a directory
source = "path/to/dir/*.jpg"

# OR define a recursive glob search for all JPG files including subdirectories
source = "path/to/dir/**/*.jpg"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define source as YouTube video URL
source = "https://youtu.be/LNwODJXcvt4"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Single stream with batch-size 1 inference
source = "rtsp://example.com/media.mp4"  # RTSP, RTMP, TCP, or IP streaming address

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Multiple streams with batched inference (e.g., batch-size 8 for 8 streams)
source = "path/to/list.streams"  # *.streams text file with one streaming address per line

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

rtsp://example.com/media1.mp4
rtsp://example.com/media2.mp4
rtmp://example2.com/live
tcp://192.168.1.100:554
...

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on the source
results = model(source=0, stream=True)  # generator of Results objects

Argumentos de Inferência

model.predict() aceita vários argumentos que podem ser passados no tempo de inferência para substituir os padrões:

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

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

Argumentos de inferência:

Argumentos de visualização:

Formatos de Imagem e Vídeo

O YOLO11 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 exemplos de comandos 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() Ultralytics retornarão uma lista de Results objetos:

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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

Results Os objetos têm os seguintes atributos:

Results objetos têm os seguintes métodos:

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

Boxes

Boxes objeto pode ser usado para indexar, manipular e converter bounding boxes para diferentes formatos.

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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 o Boxes métodos e propriedades da classe, incluindo seu nome, tipo e descrição:

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

Máscaras

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

from ultralytics import YOLO

# Load a pretrained YOLO11n-seg Segment model
model = YOLO("yolo11n-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 o Masks métodos e propriedades da classe, incluindo seu nome, tipo e descrição:

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

Keypoints

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

from ultralytics import YOLO

# Load a pretrained YOLO11n-pose Pose model
model = YOLO("yolo11n-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 o Keypoints métodos e propriedades da classe, incluindo seu nome, tipo e descrição:

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

Probs

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

from ultralytics import YOLO

# Load a pretrained YOLO11n-cls Classify model
model = YOLO("yolo11n-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 que resume os métodos e propriedades para a Probs classe:

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

OBB

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n-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 o OBB métodos e propriedades da classe, incluindo seu nome, tipo e descrição:

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

Plotando Resultados

O plot() método em Results objetos facilita a visualização das 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 NumPy, permitindo fácil exibição ou salvamento.

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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")

plot() Parâmetros do Método

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

Inferência Thread-Safe

Garantir a segurança de threads durante a inferência é crucial quando você está executando vários modelos YOLO em paralelo em diferentes threads. A inferência thread-safe garante que as previsõ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 um aplicativo multi-threaded, é importante instanciar objetos de modelo separados para cada thread ou empregar armazenamento thread-local 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=("yolo11n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo11n.pt", "image2.jpg")).start()

Para uma análise aprofundada da inferência thread-safe com modelos YOLO e instruções passo a passo, consulte nosso Guia de Inferência Thread-Safe YOLO. Este guia fornecerá todas as informações necessárias para evitar armadilhas comuns e garantir que sua inferência multi-threaded seja executada sem problemas.

Fonte de Streaming for-loop

Aqui está um script python usando OpenCV (cv2) e YOLO para executar a 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("yolo11n.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á previsõ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, segmentação e classificação em tempo real. Seu modo de previsão 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, também oferece modos de processamento em lote e streaming. Para mais detalhes sobre seus recursos, confira o modo de previsão do Ultralytics YOLO.

Como posso executar a 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 model.predict() chamada. 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 otimizar 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 transmissão gera um gerador eficiente em termos de memória de Results em vez de carregar todos os fotogramas na memória. Para processar vídeos longos ou grandes conjuntos de dados, o modo de transmissão é particularmente útil. Saiba mais sobre modo de fluxo contínuo.

Quais argumentos de inferência o Ultralytics YOLO suporta?

O model.predict() em YOLO suporta vários argumentos, tais como conf, iou, imgsz, devicee mais. Estes argumentos permitem-lhe personalizar o processo de inferência, definindo parâmetros como os limiares de confiança, o tamanho da imagem e o dispositivo utilizado para o cálculo. As descrições pormenorizadas destes argumentos podem ser encontradas na secção argumentos de inferência secção.

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

Depois de efetuar a inferência com YOLO, o Results contêm métodos para visualizar e guardar imagens anotadas. É possível utilizar métodos como result.show() e result.save(filename="result.jpg") para visualizar e guardar os resultados. Para obter uma lista completa desses métodos, consulte a trabalhar com resultados secção.

📅 Criado há 1 ano ✏️ Atualizado há 5 dias

Comentários