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

Observa: Como extrair os resultados do modelo Ultralytics YOLOv8 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 porque deves considerar o modo de previsão do YOLOv8 para as tuas várias necessidades de inferência:

• Versatilidade: Capaz de fazer inferências em imagens, vídeos e até mesmo em transmissões ao vivo.
• 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 teus requisitos específicos.

Principais características do Modo de previsão

YOLOv8O modo de previsão do sistema foi concebido para ser robusto e versátil, apresentando:

• Compatibilidade com várias fontes de dados: Quer os teus 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 precisas.
• Modo de transmissão em fluxo contínuo: Utiliza a funcionalidade de transmissão para criar um gerador de memória eficiente de Results objectos. Para o ativar, define 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.
• Fácil de integrar: Integra-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('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.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('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.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

YOLOv8 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 usada 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 estão exemplos de código para a utilização de cada tipo de fonte:

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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

import torch
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.pt')

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

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

# Run inference on the source
results = model(source, 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 YOLOv8n model
model = YOLO('yolov8n.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

YOLOv8 suporta vários formatos de imagem e vídeo, conforme especificado em ultralytics/data/utils .py. Vê as tabelas abaixo para 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 YOLOv8n model
model = YOLO('yolov8n.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, consulta 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 YOLOv8n model
model = YOLO('yolov8n.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 tens uma tabela para o Boxes métodos e propriedades da classe, incluindo o seu nome, tipo e descrição:

Para mais informações, consulta 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 YOLOv8n-seg Segment model
model = YOLO('yolov8n-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 tens uma tabela para o Masks métodos e propriedades da classe, incluindo o seu nome, tipo e descrição:

Para mais informações, consulta 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 YOLOv8n-pose Pose model
model = YOLO('yolov8n-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 tens uma tabela para o Keypoints métodos e propriedades da classe, incluindo o seu nome, tipo e descrição:

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

Provas

Probs pode ser utilizado para indexar, obter top1 e top5 índices e pontuações de classificação.

from ultralytics import YOLO

# Load a pretrained YOLOv8n-cls Classify model
model = YOLO('yolov8n-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 tens uma tabela que resume os métodos e as propriedades do Probs classe:

Para mais informações, consulta 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 YOLOv8n model
model = YOLO('yolov8n-obb.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.obb)  # print the OBB object containing the oriented detection bounding boxes

Aqui tens uma tabela para o OBB métodos e propriedades da classe, incluindo o seu nome, tipo e descrição:

Para mais informações, consulta 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 (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 YOLOv8n model
model = YOLO('yolov8n.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 segura de threads

Garantir a segurança do thread durante a inferência é crucial quando estás 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 ultralytics import YOLO
from threading import Thread

def thread_safe_predict(image_path):
    """Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
    local_model = YOLO("yolov8n.pt")
    results = local_model.predict(image_path)
    # Process results


# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

Para uma análise aprofundada da inferência thread-safe com os modelos YOLO e instruções passo a passo, consulta 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 funcione sem problemas.

Fonte de transmissão em fluxo contínuo for-loop

Aqui tens um script Python que utiliza o OpenCV (cv2) e YOLOv8 para executar a inferência em quadros de vídeo. Este script assume que já instalaste os pacotes necessários (opencv-python e ultralytics).

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.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 YOLOv8 inference on the frame
        results = model(frame)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLOv8 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'.

Comentários