Previsão de modelos com Ultralytics YOLO

Introdução

No mundo da aprendizagem automática e da visão computacional, o processo de dar sentido aos dados visuais é designado por "inferência" ou "previsão". Ultralytics YOLO11 oferece uma poderosa funcionalidade conhecida como modo de previsão, concebida para inferência de alto desempenho e em tempo real numa vasta gama de fontes de dados.

Ver: Como extrair os resultados do modelo Ultralytics YOLO para projectos personalizados.

Aplicações no mundo real

Fabrico	Desporto	Segurança
Deteção de peças sobressalentes de veículos	Deteção de jogadores de futebol	Deteção de quedas de pessoas

Porquê utilizar Ultralytics YOLO para a inferência?

Eis por que razão deve considerar o modo de previsão do YOLO11 para as suas várias necessidades de inferência:

• Versatilidade: Capaz de fazer inferências sobre imagens, vídeos e até transmissões em direto.
• Desempenho: Concebido para processamento em tempo real e a alta velocidade sem sacrificar a precisão.
• Facilidade de utilização: interfaces intuitivas Python e CLI para uma rápida implementação e teste.
• Altamente personalizável: Várias definições e parâmetros para ajustar o comportamento de inferência do modelo de acordo com os seus requisitos específicos.

Principais caraterísticas do modo de previsão

YOLO11foi concebido para ser robusto e versátil, apresentando

• Compatibilidade com várias fontes de dados: Quer os seus dados se apresentem sob a forma de imagens individuais, uma coleção de imagens, ficheiros de vídeo ou fluxos de vídeo em tempo real, o modo de previsão tem tudo o que precisa.
• Modo de transmissão em fluxo contínuo: Utilize a funcionalidade de transmissão para criar um gerador de memória eficiente de Results objectos. Active esta opção 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 num único lote, acelerando ainda mais o tempo de inferência.
• Facilidade de integração: Integre-se facilmente com pipelines de dados existentes e outros componentes de software, graças à sua API flexível.

Ultralytics YOLO devolvem uma lista Python de Results ou um gerador Python eficiente em termos de memória de objectos Results objectos 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

YOLO11 pode processar diferentes tipos de fontes de entrada para inferência, como mostra a 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 utilizada no modo de fluxo contínuo com o argumento stream=True ✅. O modo de transmissão em fluxo é benéfico para o processamento de vídeos ou transmissões em direto, uma vez que cria um gerador de resultados em vez de carregar todos os fotogramas na memória.

Abaixo encontram-se exemplos de código para a utilização de 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 momento da inferência para substituir as predefinições:

from ultralytics import YOLO

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

# Run inference on 'bus.jpg' with arguments
model.predict("bus.jpg", save=True, imgsz=320, conf=0.5)

Argumentos de inferência:

Argumentos de visualização:

Formatos de imagem e vídeo

YOLO11 suporta vários formatos de imagem e vídeo, conforme especificado em ultralytics/data/utils .py. Consulte as tabelas abaixo para obter os sufixos válidos e exemplos de comandos de previsão.

Imagens

A tabela seguinte contém os formatos de imagem válidos para Ultralytics .

Vídeos

A tabela seguinte contém os formatos de vídeo válidos para Ultralytics .

Trabalhar com resultados

Todos Ultralytics predict() devolverá uma lista de Results objectos:

from ultralytics import YOLO

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

# Run inference on an image
results = model("bus.jpg")  # list of 1 Results object
results = model(["bus.jpg", "zidane.jpg"])  # list of 2 Results objects

Results têm os seguintes atributos:

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

Para mais informações, consultar o Results documentação da classe.

Caixas

Boxes pode ser utilizado para indexar, manipular e converter caixas delimitadoras em diferentes formatos.

from ultralytics import YOLO

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

# Run inference on an image
results = model("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 o seu nome, tipo e descrição:

Para mais informações, consultar o Boxes documentação da classe.

Máscaras

Masks pode ser utilizado 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("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 o seu nome, tipo e descrição:

Para mais informações, consultar o Masks documentação da classe.

Pontos-chave

Keypoints pode ser utilizado 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("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 o seu nome, tipo e descrição:

Para mais informações, consultar o Keypoints documentação da classe.

Provas

Probs objeto pode ser utilizado para indexar, obter top1 e top5 índices e pontuações 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("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 o Probs classe:

Para mais informações, consultar o Probs documentação da classe.

OBB

OBB pode ser utilizado 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("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 o seu nome, tipo e descrição:

Para mais informações, consultar o OBB documentação da classe.

Traçar resultados

O plot() método em Results facilita a visualização das previsões ao sobrepor objectos detectados (tais como caixas delimitadoras, máscaras, pontos-chave e probabilidades) à imagem original. Este método devolve a imagem anotada como uma matriz NumPy, permitindo uma fácil visualização ou gravação.

from PIL import Image

from ultralytics import YOLO

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

# Run inference on 'bus.jpg'
results = model(["bus.jpg", "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() suporta vários argumentos para personalizar a saída:

Inferência Thread-Safe

Garantir a segurança do thread durante a inferência é crucial quando se está a executar vários modelos YOLO em paralelo em diferentes threads. A inferência thread-safe garante que as previsões de cada thread são isoladas e não interferem umas com as outras, evitando condições de corrida e garantindo resultados consistentes e fiáveis.

Ao utilizar modelos YOLO numa aplicação multithread, é importante instanciar objectos de modelo separados para cada thread ou utilizar 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=("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 os modelos YOLO e instruções passo a passo, consulte o nosso YOLO Guia de inferência thread-safe. Este guia fornecerá todas as informações necessárias para evitar armadilhas comuns e garantir que sua inferência multithread seja executada sem problemas.

Fonte de transmissão em fluxo contínuo 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 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 executa previsões em cada fotograma do vídeo, visualiza os resultados e apresenta-os numa janela. O ciclo pode ser encerrado premindo 'q'.

FAQ

O que é Ultralytics YOLO e o seu modo de previsão para inferência em tempo real?

Ultralytics YOLO é um modelo topo de gama para deteção, segmentação e classificação de objectos em tempo real. O seu modo de previsão permite aos utilizadores realizar inferências a alta velocidade em várias fontes de dados, como imagens, vídeos e transmissões em direto. Concebido para desempenho e versatilidade, também oferece modos de processamento em lote e de transmissão. Para mais pormenores sobre as suas funcionalidades, consulte Ultralytics YOLO predict mode.

Como é que posso efetuar inferência utilizando Ultralytics YOLO em diferentes fontes de dados?

Ultralytics YOLO pode processar uma vasta gama de fontes de dados, incluindo imagens individuais, vídeos, diretórios, URLs e fluxos. É possível especificar a fonte de dados no campo model.predict() chamada. Por exemplo, utilizar 'image.jpg' para uma imagem local ou 'https://ultralytics.com/images/bus.jpg' para um URL. Veja os exemplos detalhados de vários fontes de inferência na documentação.

Como posso otimizar a velocidade de inferência de YOLO e a utilização da memória?

Para otimizar a velocidade de inferência e gerir a memória de forma eficiente, pode utilizar o modo de transmissão 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.

Que argumentos de inferência é que 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 é que posso visualizar e guardar os resultados das previsões de 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.

📅C riado há 1 ano ✏️ Atualizado há 1 mês

Comentários