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 definindostream=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=False
No 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.
Executar a inferência no conteúdo do ecrã atual como uma captura de ecrã.
Executar inferência numa imagem ou vídeo alojado remotamente através de URL.
Executar a inferência numa imagem aberta com Python Imaging Library (PIL).
Executar a inferência numa imagem lida com o OpenCV.
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.
Executar a inferência num ficheiro de vídeo. Ao utilizar stream=True
Se o utilizador tiver uma memória de trabalho, pode criar um gerador de objectos Resultados para reduzir a utilização da memória.
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/**/*
.
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=True
Se o utilizador tiver um vídeo longo, pode criar um gerador de objectos de resultados para reduzir a utilização de memória.
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
.
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
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 False Se `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 True apresenta 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 None A 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
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
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
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
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
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
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
, device
e 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.