You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
227 lines
14 KiB
227 lines
14 KiB
--- |
|
comments: true |
|
description: Descubra como usar o modo predict do YOLOv8 para diversas tarefas. Aprenda sobre diferentes fontes de inferência, como imagens, vídeos e formatos de dados. |
|
keywords: Ultralytics, YOLOv8, modo predict, fontes de inferência, tarefas de previsão, modo de streaming, processamento de imagens, processamento de vídeo, aprendizado de máquina, IA |
|
--- |
|
|
|
# Predição de Modelo com Ultralytics YOLO |
|
|
|
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecossistema e integrações do Ultralytics YOLO"> |
|
|
|
## Introdução |
|
|
|
No mundo do aprendizado de máquina e visão computacional, o processo de fazer sentido a partir de dados visuais é chamado de 'inferência' ou 'predição'. O Ultralytics YOLOv8 oferece um recurso poderoso conhecido como **modo predict** que é personalizado para inferência em tempo real de alto desempenho em uma ampla gama de fontes de dados. |
|
|
|
<p align="center"> |
|
<br> |
|
<iframe width="720" height="405" src="https://www.youtube.com/embed/QtsI0TnwDZs?si=ljesw75cMO2Eas14" |
|
title="Reprodutor de vídeo do YouTube" frameborder="0" |
|
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
|
allowfullscreen> |
|
</iframe> |
|
<br> |
|
<strong>Assista:</strong> Como Extrair as Saídas do Modelo Ultralytics YOLOv8 para Projetos Personalizados. |
|
</p> |
|
|
|
## Aplicações no Mundo Real |
|
|
|
| Manufatura | Esportes | Segurança | |
|
|:-----------------------------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------------------------------:| |
|
|  |  |  | |
|
| Detecção de Peças de Reposição de Veículo | Detecção de Jogador de Futebol | Detecção de Queda de Pessoas | |
|
|
|
## Por Que Usar o Ultralytics YOLO para Inferência? |
|
|
|
Aqui está o porquê de você considerar o modo predict do YOLOv8 para suas diversas necessidades de inferência: |
|
|
|
- **Versatilidade:** Capaz de fazer inferências em imagens, vídeos e até transmissões ao vivo. |
|
- **Desempenho:** Projetado para processamento em tempo real e de alta velocidade sem sacrificar a precisão. |
|
- **Facilidade de Uso:** Interfaces Python e CLI intuitivas para implantação e testes rápidos. |
|
- **Altamente Customizável:** Várias configurações e parâmetros para ajustar o comportamento de inferência do modelo de acordo com suas necessidades específicas. |
|
|
|
### Recursos Chave do Modo Predict |
|
|
|
O modo predict do YOLOv8 é projetado para ser robusto e versátil, apresentando: |
|
|
|
- **Compatibilidade com Múltiplas Fontes de Dados:** Se seus dados estão na forma de imagens individuais, uma coleção de imagens, arquivos de vídeo ou transmissões de vídeo em tempo real, o modo predict atende a todas as necessidades. |
|
- **Modo de Streaming:** Use o recurso de streaming para gerar um gerador eficiente de memória de objetos `Results`. Ative isso 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 em um único lote, acelerando ainda mais o tempo de inferência. |
|
- **Integração Amigável:** Integração fácil com pipelines de dados existentes e outros componentes de software, graças à sua API flexível. |
|
|
|
Os modelos Ultralytics YOLO retornam ou uma lista de objetos `Results` em Python, ou um gerador em Python eficiente de memória de objetos `Results` quando `stream=True` é passado para o modelo durante a inferência: |
|
|
|
!!! Example "Predict" |
|
|
|
=== "Retorna uma lista com `stream=False`" |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo |
|
model = YOLO('yolov8n.pt') # modelo YOLOv8n pré-treinado |
|
|
|
# Executa a inferência em lote em uma lista de imagens |
|
results = model(['im1.jpg', 'im2.jpg']) # retorna uma lista de objetos Results |
|
|
|
# Processa a lista de resultados |
|
for result in results: |
|
boxes = result.boxes # Objeto Boxes para saídas de bbox |
|
masks = result.masks # Objeto Masks para saídas de máscaras de segmentação |
|
keypoints = result.keypoints # Objeto Keypoints para saídas de pose |
|
probs = result.probs # Objeto Probs para saídas de classificação |
|
``` |
|
|
|
=== "Retorna um gerador com `stream=True`" |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo |
|
model = YOLO('yolov8n.pt') # modelo YOLOv8n pré-treinado |
|
|
|
# Executa a inferência em lote em uma lista de imagens |
|
results = model(['im1.jpg', 'im2.jpg'], stream=True) # retorna um gerador de objetos Results |
|
|
|
# Processa o gerador de resultados |
|
for result in results: |
|
boxes = result.boxes # Objeto Boxes para saídas de bbox |
|
masks = result.masks # Objeto Masks para saídas de máscaras de segmentação |
|
keypoints = result.keypoints # Objeto Keypoints para saídas de pose |
|
probs = result.probs # Objeto Probs para saídas de classificação |
|
``` |
|
|
|
## Fontes de Inferência |
|
|
|
O YOLOv8 pode processar diferentes tipos de fontes de entrada para inferência, conforme mostrado na tabela abaixo. As fontes incluem imagens estáticas, transmissões de vídeo e vários formatos de dados. A tabela também indica se cada fonte pode ser usada no modo de streaming com o argumento `stream=True` ✅. O modo de streaming é benéfico para processar vídeos ou transmissões ao vivo, pois cria um gerador de resultados em vez de carregar todos os quadros na memória. |
|
|
|
!!! Tip "Dica" |
|
|
|
Use `stream=True` para processar vídeos longos ou grandes conjuntos de dados para gerenciar a memória de forma eficiente. Quando `stream=False`, os resultados de todos os quadros ou pontos de dados são armazenados na memória, o que pode aumentar rapidamente e causar erros de falta de memória para grandes entradas. Em contraste, `stream=True` utiliza um gerador, que mantém apenas os resultados do quadro atual ou ponto de dados na memória, reduzindo significativamente o consumo de memória e prevenindo problemas de falta dela. |
|
|
|
| Fonte | Argumento | Tipo | Notas | |
|
|-----------------|--------------------------------------------|-----------------|-------------------------------------------------------------------------------------------------------------------------| |
|
| imagem | `'image.jpg'` | `str` ou `Path` | Arquivo de imagem único. | |
|
| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL para uma imagem. | |
|
| captura de tela | `'screen'` | `str` | Captura uma captura de tela. | |
|
| PIL | `Image.open('im.jpg')` | `PIL.Image` | Formato HWC com canais RGB. | |
|
| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Formato HWC com canais BGR `uint8 (0-255)`. | |
|
| numpy | `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` | Arquivo CSV contendo caminhos para imagens, vídeos ou diretórios. | |
|
| vídeo ✅ | `'video.mp4'` | `str` ou `Path` | Arquivo de vídeo em formatos como MP4, AVI, etc. | |
|
| diretório ✅ | `'path/'` | `str` ou `Path` | Caminho para um diretório contendo imagens ou vídeos. | |
|
| glob ✅ | `'path/*.jpg'` | `str` | Padrão glob para combinar vários arquivos. Use o caractere `*` como curinga. | |
|
| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL para um vídeo do YouTube. | |
|
| stream ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL para protocolos de streaming como RTSP, RTMP, TCP ou um endereço IP. | |
|
| multi-stream ✅ | `'list.streams'` | `str` ou `Path` | Arquivo de texto `*.streams` com uma URL de stream por linha, ou seja, 8 streams serão executados em lote de tamanho 8. | |
|
|
|
Abaixo estão exemplos de código para usar cada tipo de fonte: |
|
|
|
!!! Example "Fontes de previsão" |
|
|
|
=== "imagem" |
|
Executa a inferência em um arquivo de imagem. |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo YOLOv8n pré-treinado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Define o caminho para o arquivo de imagem |
|
source = 'caminho/para/imagem.jpg' |
|
|
|
# Executa a inferência na fonte |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "captura de tela" |
|
Executa a inferência no conteúdo atual da tela como uma captura de tela. |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo YOLOv8n pré-treinado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Define a captura de tela atual como fonte |
|
source = 'screen' |
|
|
|
# Executa a inferência na fonte |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "URL" |
|
Executa a inferência em uma imagem ou vídeo hospedado remotamente via URL. |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo YOLOv8n pré-treinado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Define a URL remota da imagem ou vídeo |
|
source = 'https://ultralytics.com/images/bus.jpg' |
|
|
|
# Executa a inferência na fonte |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "PIL" |
|
Executa a inferência em uma imagem aberta com a Biblioteca de Imagens do Python (PIL). |
|
```python |
|
from PIL import Image |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo YOLOv8n pré-treinado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Abre uma imagem usando PIL |
|
source = Image.open('caminho/para/imagem.jpg') |
|
|
|
# Executa a inferência na fonte |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "OpenCV" |
|
Executa a inferência em uma imagem lida com OpenCV. |
|
```python |
|
import cv2 |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo YOLOv8n pré-treinado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Lê uma imagem usando OpenCV |
|
source = cv2.imread('caminho/para/imagem.jpg') |
|
|
|
# Executa a inferência na fonte |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "numpy" |
|
Executa a inferência em uma imagem representada como um array numpy. |
|
```python |
|
import numpy as np |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo YOLOv8n pré-treinado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Cria um array random de numpy com forma HWC (640, 640, 3) com valores no intervalo [0, 255] e tipo uint8 |
|
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') |
|
|
|
# Executa a inferência na fonte |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "torch" |
|
Executa a inferência em uma imagem representada como um tensor PyTorch. |
|
```python |
|
import torch |
|
from ultralytics import YOLO |
|
|
|
# Carrega um modelo YOLOv8n pré-treinado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Cria um tensor random de torch com forma BCHW (1, 3, 640, 640) com valores no intervalo [0, 1] e tipo float32 |
|
source = torch.rand(1, 3, 640, 640, dtype=torch.float32) |
|
|
|
# Executa a inferência na fonte |
|
results = model(source) # lista de objetos Results |
|
```
|
|
|