Previsão de modelos com Ultralytics YOLO

Introdução

In the world of machine learning and computer vision, the process of making sense out of visual data is called 'inference' or 'prediction'. Ultralytics YOLO11 offers a powerful feature known as predict mode that is tailored for high-performance, real-time inference on a wide range of data sources.

Observa: How to Extract the Outputs from Ultralytics YOLO Model for Custom Projects.

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?

Here's why you should consider YOLO11's predict mode for your various inference needs:

• Versatilidade: Capaz de fazer inferências em imagens, vídeos e até mesmo em transmissões ao vivo.
• Performance: Engineered for real-time, high-speed processing without sacrificing accuracy.
• 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

YOLO11's predict mode is designed to be robust and versatile, featuring:

• 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("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 can process different types of input sources for inference, as shown in the table below. The sources include static images, video streams, and various data formats. The table also indicates whether each source can be used in streaming mode with the argument 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 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 supports various image and video formats, as specified in ultralytics/data/utils.py. See the tables below for the valid suffixes and example predict commands.

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, 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 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 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 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 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 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 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 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 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 YOLO11n model
model = YOLO("yolo11n-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 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 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 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, 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) and YOLO to run inference on video frames. This script assumes you have already installed the necessary packages (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

What is Ultralytics YOLO and its predict mode for real-time inference?

Ultralytics YOLO is a state-of-the-art model for real-time object detection, segmentation, and classification. Its predict mode allows users to perform high-speed inference on various data sources such as images, videos, and live streams. Designed for performance and versatility, it also offers batch processing and streaming modes. For more details on its features, check out the Ultralytics YOLO predict mode.

How can I run inference using Ultralytics YOLO on different data sources?

Ultralytics YOLO can process a wide range of data sources, including individual images, videos, directories, URLs, and streams. You can specify the data source in the model.predict() chama. Por exemplo, utiliza 'image.jpg' para uma imagem local ou 'https://ultralytics.com/images/bus.jpg' para um URL. Vê os exemplos detalhados de vários fontes de inferência na documentação.

How do I optimize YOLO inference speed and memory usage?

Para otimizar a velocidade de inferência e gerir a memória de forma eficiente, podes utilizar o modo de transmissão definindo stream=True no método de chamada do preditor. O modo de streaming gera um gerador de memória eficiente de Results em vez de carregar todos os quadros na memória. Para processar vídeos longos ou grandes conjuntos de dados, o modo de transmissão é particularmente útil. Sabe mais sobre modo de transmissão.

What inference arguments does Ultralytics YOLO support?

O model.predict() method in YOLO supports various arguments such as conf, iou, imgsz, devicee mais. Estes argumentos permitem-te personalizar o processo de inferência, definindo parâmetros como limiares de confiança, tamanho da imagem e o dispositivo utilizado para o cálculo. Podes encontrar descrições detalhadas destes argumentos na secção argumentos de inferência secção.

How can I visualize and save the results of YOLO predictions?

After running inference with YOLO, the Results contêm métodos para apresentar e guardar imagens anotadas. Podes 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, consulta a trabalhar com resultados secção.

📅 Created 11 months ago ✏️ Updated 9 days ago

Comentários