Saltar para o conteúdo

Previsão de modelos com Ultralytics YOLO

Ultralytics YOLO ecossistema e integrações

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
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:

Prever

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.

Dica

Utilização stream=True para o processamento de vídeos longos ou de grandes conjuntos de dados para gerir eficazmente a memória. Quando stream=FalseNo caso de entradas grandes, os resultados de todos os fotogramas ou pontos de dados são armazenados na memória, o que pode rapidamente aumentar e causar erros de memória. Em contrapartida, stream=True utiliza um gerador, que apenas mantém na memória os resultados da moldura ou do ponto de dados atual, reduzindo significativamente o consumo de memória e evitando problemas de falta de memória.

Fonte Exemplo Tipo Notas
imagem 'image.jpg' str ou Path Ficheiro de imagem único.
URL 'https://ultralytics.com/images/bus.jpg' str URL para uma imagem.
captura de ecrã 'screen' str Capturar uma imagem do ecrã.
PIL Image.open('image.jpg') PIL.Image Formato HWC com canais RGB.
OpenCV cv2.imread('image.jpg') np.ndarray Formato HWC com canais BGR uint8 (0-255).
numérico np.zeros((640,1280,3)) np.ndarray Formato HWC com canais BGR uint8 (0-255).
torch torch.zeros(16,3,320,640) torch.Tensor Formato BCHW com canais RGB float32 (0.0-1.0).
CSV 'sources.csv' str ou Path Ficheiro CSV que contém caminhos para imagens, vídeos ou diretórios.
vídeo ✅ 'video.mp4' str ou Path Ficheiro de vídeo em formatos como MP4, AVI, etc.
diretório ✅ 'path/' str ou Path Caminho para um diretório que contém imagens ou vídeos.
globo ✅ 'path/*.jpg' str Padrão global para corresponder a vários ficheiros. Utilizar o * como um caractere curinga.
YouTube ✅ 'https://youtu.be/LNwODJXcvt4' str URL para um vídeo do YouTube.
fluxo ✅ 'rtsp://example.com/media.mp4' str URL para protocolos de transmissão como RTSP, RTMP, TCP ou um endereço IP.
multi-fluxo ✅ 'list.streams' str ou Path *.streams ficheiro de texto com um URL de fluxo por linha, ou seja, 8 fluxos serão executados com o tamanho de lote 8.
Webcam ✅ 0 int Índice do dispositivo de câmara ligado para executar a inferência.

Abaixo encontram-se exemplos de código para a utilização de cada tipo de fonte:

Fontes de previsão

Executar a inferência num ficheiro de imagem.

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

Executar a inferência no conteúdo do ecrã atual como uma captura de ecrã.

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

Executar inferência numa imagem ou vídeo alojado remotamente através de URL.

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

Executar a inferência numa imagem aberta com Python Imaging Library (PIL).

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

Executar a inferência numa imagem lida com o OpenCV.

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

Executa a inferência numa imagem representada como uma matriz numpy.

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

Executar a inferência numa imagem representada como um PyTorch tensor.

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

Execute a inferência numa coleção de imagens, URLs, vídeos e diretórios listados num ficheiro CSV.

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

Executar a inferência num ficheiro de vídeo. Ao utilizar stream=TrueSe o utilizador tiver uma memória de trabalho, pode criar um gerador de objectos Resultados para reduzir a utilização da memória.

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

Execute a inferência em todas as imagens e vídeos de um diretório. Para capturar também imagens e vídeos em subdirectórios, utilize um padrão glob, ou seja path/to/dir/**/*.

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

Executar a inferência em todas as imagens e vídeos que correspondem a uma expressão glob com * caracteres.

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

Executar a inferência num vídeo do YouTube. Ao utilizar stream=TrueSe o utilizador tiver um vídeo longo, pode criar um gerador de objectos de resultados para reduzir a utilização de memória.

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

Utilize o modo de fluxo para executar a inferência em fluxos de vídeo em direto utilizando os protocolos RTSP, RTMP, TCP ou de endereço IP. Se for fornecido um único fluxo, o modelo executa a inferência com um tamanho do lote de 1. Para fluxos múltiplos, um .streams pode ser utilizado para efetuar inferência em lote, em que o tamanho do lote é determinado pelo número de fluxos fornecidos (por exemplo, tamanho do lote 8 para 8 fluxos).

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

Para a utilização de um único fluxo, o tamanho do lote é definido como 1 por defeito, permitindo um processamento eficiente em tempo real do fluxo de vídeo.

Para lidar com vários fluxos de vídeo em simultâneo, utilize um .streams ficheiro de texto que contém as fontes de fluxo contínuo. O modelo executará a inferência em lote, em que o tamanho do lote é igual ao número de fluxos. Esta configuração permite o processamento eficiente de vários feeds em simultâneo.

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

Exemplo .streams ficheiro de texto:

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

Cada linha do ficheiro representa uma fonte de fluxo contínuo, permitindo-lhe monitorizar e efetuar inferências em vários fluxos de vídeo ao mesmo tempo.

É possível executar a inferência num dispositivo de câmara ligado, passando o índice dessa câmara específica para source.

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:

Exemplo

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:

Argumento Tipo Predefinição Descrição
source str 'ultralytics/assets' Especifica a fonte de dados para inferência. Pode ser um caminho de imagem, ficheiro de vídeo, diretório, URL ou ID de dispositivo para feeds em direto. Suporta uma vasta gama de formatos e fontes, permitindo uma aplicação flexível em diferentes tipos de entrada.
conf float 0.25 Define o limite mínimo de confiança para as detecções. Os objectos detectados com confiança inferior a este limite serão ignorados. O ajuste deste valor pode ajudar a reduzir os falsos positivos.
iou float 0.7 Limiar de Intersecção sobre União (IoU) para Supressão Não Máxima (NMS). Valores mais baixos resultam em menos detecções através da eliminação de caixas sobrepostas, útil para reduzir duplicados.
imgsz int or tuple 640 Define o tamanho da imagem para inferência. Pode ser um único número inteiro 640 para redimensionamento quadrado ou uma tupla (altura, largura). O dimensionamento correto pode melhorar a deteção exatidão e velocidade de processamento.
half bool False Permite a inferência de meia-precisão (FP16), que pode acelerar a inferência de modelos em GPUs compatíveis com um impacto mínimo na precisão.
device str None Especifica o dispositivo para inferência (por exemplo, cpu, cuda:0 ou 0). Permite aos utilizadores selecionar entre CPU, um GPU específico, ou outros dispositivos de computação para a execução do modelo.
batch int 1 Especifica o tamanho do lote para inferência (só funciona quando a fonte é um diretório, ficheiro de vídeo ou .txt ficheiro). Uma maior dimensão do lote pode proporcionar um maior rendimento, reduzindo o tempo total necessário para a inferência.
max_det int 300 Número máximo de detecções permitidas por imagem. Limita o número total de objectos que o modelo pode detetar numa única inferência, evitando resultados excessivos em cenas densas.
vid_stride int 1 Passagem de fotogramas para entradas de vídeo. Permite saltar fotogramas em vídeos para acelerar o processamento à custa da resolução temporal. Um valor de 1 processa todos os fotogramas, valores mais elevados saltam fotogramas.
stream_buffer bool False Determina se os quadros de entrada devem ser colocados em fila de espera para fluxos de vídeo. Se FalseSe `Verdadeiro', quadros antigos são descartados para acomodar novos quadros (otimizado para aplicações em tempo real). Se `Verdadeiro', enfileira novos quadros em um buffer, garantindo que nenhum quadro seja pulado, mas causará latência se o FPS da inferência for menor que o FPS do fluxo.
visualize bool False Ativa a visualização das caraterísticas do modelo durante a inferência, fornecendo informações sobre o que o modelo está a "ver". Útil para depuração e interpretação de modelos.
augment bool False Permite o aumento do tempo de teste (TTA) para previsões, melhorando potencialmente a robustez da deteção à custa da velocidade de inferência.
agnostic_nms bool False Permite a Supressão Não Máxima (NMS) independente da classe, que funde caixas sobrepostas de classes diferentes. Útil em cenários de deteção multi-classe onde a sobreposição de classes é comum.
classes list[int] None Filtra as previsões para um conjunto de IDs de classe. Apenas as detecções pertencentes às classes especificadas serão retornadas. Útil para se concentrar em objectos relevantes em tarefas de deteção multi-classe.
retina_masks bool False Devolve máscaras de segmentação de alta resolução. As máscaras devolvidas (masks.data) corresponderão ao tamanho da imagem original se estiverem activados. Se estiverem desactivados, terão o tamanho de imagem utilizado durante a inferência.
embed list[int] None Especifica as camadas a partir das quais se devem extrair vectores de caraterísticas ou embeddings. Útil para tarefas a jusante como o agrupamento ou a pesquisa de semelhanças.
project str None Nome do diretório do projeto onde são guardados os resultados da previsão, se save está ativado.
name str None Nome da execução da previsão. Utilizado para criar um subdiretório dentro da pasta do projeto, onde os resultados da previsão são armazenados se save está ativado.

Argumentos de visualização:

Argumento Tipo Predefinição Descrição
show bool False Se Trueapresenta as imagens ou vídeos anotados numa janela. Útil para feedback visual imediato durante o desenvolvimento ou teste.
save bool False ou True Permite guardar as imagens ou vídeos anotados num ficheiro. Útil para documentação, análise posterior ou partilha de resultados. A predefinição é True quando se utiliza CLI e False quando se utiliza Python.
save_frames bool False Ao processar vídeos, guarda fotogramas individuais como imagens. Útil para extrair fotogramas específicos ou para uma análise detalhada fotograma a fotograma.
save_txt bool False Guarda os resultados da deteção num ficheiro de texto, seguindo o formato [class] [x_center] [y_center] [width] [height] [confidence]. Útil para integração com outras ferramentas de análise.
save_conf bool False Inclui pontuações de confiança nos ficheiros de texto guardados. Aumenta o detalhe disponível para pós-processamento e análise.
save_crop bool False Guarda imagens recortadas de detecções. Útil para aumentar o conjunto de dados, analisar ou criar conjuntos de dados específicos para objectos específicos.
show_labels bool True Apresenta etiquetas para cada deteção na saída visual. Proporciona uma compreensão imediata dos objectos detectados.
show_conf bool True Apresenta a pontuação de confiança para cada deteção ao lado da etiqueta. Dá uma ideia do grau de certeza do modelo para cada deteção.
show_boxes bool True Desenha caixas delimitadoras em torno dos objectos detectados. Essencial para a identificação visual e localização de objectos em imagens ou fotogramas de vídeo.
line_width None ou int None Especifica a largura da linha das caixas delimitadoras. Se NoneA largura da linha é ajustada automaticamente com base no tamanho da imagem. Proporciona uma personalização visual para maior clareza.

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 .

Nota

As imagens HEIC são suportadas apenas para inferência, não para formação.

Sufixos de imagem Exemplo de comando Prever Referência
.bmp yolo predict source=image.bmp Microsoft Formato de ficheiro BMP
.dng yolo predict source=image.dng Adobe DNG
.jpeg yolo predict source=image.jpeg JPEG
.jpg yolo predict source=image.jpg JPEG
.mpo yolo predict source=image.mpo Objeto com várias imagens
.png yolo predict source=image.png Gráficos de rede portáteis
.tif yolo predict source=image.tif Formato do ficheiro de imagem da etiqueta
.tiff yolo predict source=image.tiff Formato do ficheiro de imagem da etiqueta
.webp yolo predict source=image.webp WebP
.pfm yolo predict source=image.pfm Mapa de flutuação portátil
.HEIC yolo predict source=image.HEIC Formato de imagem de alta eficiência

Vídeos

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

Sufixos de vídeo Exemplo de comando Prever Referência
.asf yolo predict source=video.asf Formato de sistemas avançados
.avi yolo predict source=video.avi Intercalação de áudio e vídeo
.gif yolo predict source=video.gif Formato de intercâmbio de gráficos
.m4v yolo predict source=video.m4v MPEG-4 Parte 14
.mkv yolo predict source=video.mkv Matroska
.mov yolo predict source=video.mov Formato de ficheiro QuickTime
.mp4 yolo predict source=video.mp4 MPEG-4 Parte 14 - Wikipédia
.mpeg yolo predict source=video.mpeg MPEG-1 Parte 2
.mpg yolo predict source=video.mpg MPEG-1 Parte 2
.ts yolo predict source=video.ts Fluxo de transporte MPEG
.wmv yolo predict source=video.wmv Vídeo do Windows Media
.webm yolo predict source=video.webm Projeto WebM

Trabalhar com resultados

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

Resultados

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:

Atributo Tipo Descrição
orig_img numpy.ndarray A imagem original como uma matriz numpy.
orig_shape tuple A forma da imagem original no formato (altura, largura).
boxes Boxes, optional Um objeto Boxes que contém as caixas delimitadoras da deteção.
masks Masks, optional Um objeto Máscaras que contém as máscaras de deteção.
probs Probs, optional Um objeto Probs que contém as probabilidades de cada classe para a tarefa de classificação.
keypoints Keypoints, optional Um objeto Keypoints que contém os pontos-chave detectados para cada objeto.
obb OBB, optional Um objeto OBB que contém caixas delimitadoras orientadas.
speed dict Um dicionário de velocidades de pré-processamento, inferência e pós-processamento em milissegundos por imagem.
names dict Um dicionário de nomes de classes.
path str O caminho para o ficheiro de imagem.

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

Método Tipo de retorno Descrição
update() None Actualiza os atributos caixas, máscaras e probs do objeto Resultados.
cpu() Results Devolve uma cópia do objeto Results com todos os tensores na memória CPU .
numpy() Results Devolve uma cópia do objeto Results com todos os tensores como arrays numpy.
cuda() Results Devolve uma cópia do objeto Results com todos os tensores na memória GPU .
to() Results Devolve uma cópia do objeto Results com tensores no dispositivo e tipo d especificados.
new() Results Devolve um novo objeto Results com a mesma imagem, caminho e nomes.
plot() numpy.ndarray Plota os resultados da deteção. Devolve uma matriz numpy da imagem anotada.
show() None Mostrar resultados anotados no ecrã.
save() None Guardar os resultados anotados num ficheiro.
verbose() str Devolve a cadeia de registo para cada tarefa.
save_txt() None Guardar as previsões num ficheiro txt.
save_crop() None Guardar as previsões cortadas em save_dir/cls/file_name.jpg.
tojson() str Converte o objeto para o formato JSON.

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.

Caixas

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:

Nome Tipo Descrição
cpu() Método Mover o objeto para a memória CPU .
numpy() Método Converte o objeto para uma matriz numpy.
cuda() Método Mover o objeto para a memória CUDA .
to() Método Move o objeto para o dispositivo especificado.
xyxy Propriedade (torch.Tensor) Devolver as caixas no formato xyxy.
conf Propriedade (torch.Tensor) Devolve os valores de confiança das caixas.
cls Propriedade (torch.Tensor) Devolve os valores de classe das caixas.
id Propriedade (torch.Tensor) Devolve as IDs de faixa das caixas (se disponíveis).
xywh Propriedade (torch.Tensor) Devolver as caixas no formato xywh.
xyxyn Propriedade (torch.Tensor) Devolve as caixas no formato xyxy normalizado pelo tamanho da imagem original.
xywhn Propriedade (torch.Tensor) Devolve as caixas no formato xywh normalizado pelo tamanho da imagem original.

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.

Máscaras

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:

Nome Tipo Descrição
cpu() Método Devolve as máscaras tensor na memória CPU .
numpy() Método Devolve as máscaras tensor como uma matriz numpy.
cuda() Método Devolve as máscaras tensor na memória GPU .
to() Método Devolve as máscaras tensor com o dispositivo e o dtype especificados.
xyn Propriedade (torch.Tensor) Uma lista de segmentos normalizados representados como tensores.
xy Propriedade (torch.Tensor) Uma lista de segmentos em coordenadas de pixéis representados como tensores.

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

Pontos-chave

Keypoints pode ser utilizado para indexar, manipular e normalizar coordenadas.

Pontos-chave

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:

Nome Tipo Descrição
cpu() Método Devolve os pontos-chave tensor na memória CPU .
numpy() Método Devolve os pontos-chave tensor como uma matriz numpy.
cuda() Método Devolve os pontos-chave tensor na memória GPU .
to() Método Devolve os pontos-chave tensor com o dispositivo e o dtype especificados.
xyn Propriedade (torch.Tensor) Uma lista de pontos-chave normalizados representados como tensores.
xy Propriedade (torch.Tensor) Uma lista de pontos-chave em coordenadas de píxeis representados como tensores.
conf Propriedade (torch.Tensor) Devolve os valores de confiança dos pontos-chave, se disponíveis; caso contrário, nenhum.

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.

Provas

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:

Nome Tipo Descrição
cpu() Método Devolve uma cópia dos problemas tensor na memória CPU .
numpy() Método Devolve uma cópia do probs tensor como uma matriz numpy.
cuda() Método Devolve uma cópia dos problemas tensor na memória GPU .
to() Método Devolve uma cópia do probs tensor com o dispositivo e o dtype especificados.
top1 Propriedade (int) Índice da classe 1 superior.
top5 Propriedade (list[int]) Índices das 5 classes principais.
top1conf Propriedade (torch.Tensor) Confiança da classe 1 superior.
top5conf Propriedade (torch.Tensor) Confidências das 5 primeiras classes.

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.

OBB

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:

Nome Tipo Descrição
cpu() Método Mover o objeto para a memória CPU .
numpy() Método Converte o objeto para uma matriz numpy.
cuda() Método Mover o objeto para a memória CUDA .
to() Método Move o objeto para o dispositivo especificado.
conf Propriedade (torch.Tensor) Devolve os valores de confiança das caixas.
cls Propriedade (torch.Tensor) Devolve os valores de classe das caixas.
id Propriedade (torch.Tensor) Devolve as IDs de faixa das caixas (se disponíveis).
xyxy Propriedade (torch.Tensor) Devolve as caixas horizontais no formato xyxy.
xywhr Propriedade (torch.Tensor) Devolve as caixas rodadas no formato xywhr.
xyxyxyxy Propriedade (torch.Tensor) Devolve as caixas rodadas no formato xyxyxyxy.
xyxyxyxyn Propriedade (torch.Tensor) Devolve as caixas rodadas no formato xyxyxyxy normalizado pelo tamanho da imagem.

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.

Plotagem

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:

Argumento Tipo Descrição Predefinição
conf bool Incluir as pontuações de confiança da deteção. True
line_width float Largura da linha das caixas delimitadoras. Escala com o tamanho da imagem se None. None
font_size float Tamanho do tipo de letra do texto. Escala com o tamanho da imagem se None. None
font str Nome do tipo de letra para anotações de texto. 'Arial.ttf'
pil bool Devolver a imagem como um objeto PIL Image. False
img numpy.ndarray Imagem alternativa para a plotagem. Utiliza a imagem original se None. None
im_gpu torch.Tensor GPU-Imagem acelerada para uma plotagem mais rápida da máscara. Forma: (1, 3, 640, 640). None
kpt_radius int Raio para os pontos-chave desenhados. 5
kpt_line bool Ligar os pontos-chave com linhas. True
labels bool Incluir etiquetas de classe nas anotações. True
boxes bool Sobrepor caixas delimitadoras na imagem. True
masks bool Sobrepor máscaras na imagem. True
probs bool Incluir probabilidades de classificação. True
show bool Mostrar a imagem anotada diretamente utilizando o visualizador de imagens predefinido. False
save bool Guardar a imagem anotada num ficheiro especificado por filename. False
filename str Caminho e nome do ficheiro para guardar a imagem anotada, se save é True. None
color_mode str Especifica o modo de cor, por exemplo, 'instância' ou 'classe'. 'class'

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:

Inferência Thread-Safe

Instanciar um único modelo dentro de cada thread para inferência thread-safe:

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

Fluxo para o loop

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