Ultralytics YOLO27:
Get Started

Carregando YOLOv5 do PyTorch Hub#

📚 Este guia explica como carregar YOLOv5 🚀 do PyTorch Hub em https://pytorch.org/hub/ultralytics_yolov5.

Antes de começar#

Instale requirements.txt em um ambiente Python>=3.8.0, incluindo PyTorch>=1.8. Os modelos e conjuntos de dados são baixados automaticamente da versão mais recente do YOLOv5 (release).

pip install -r https://raw.githubusercontent.com/ultralytics/yolov5/master/requirements.txt
Dica

Não é necessário clonar ultralytics/yolov5 — o PyTorch Hub obtém o código automaticamente.

Carregar YOLOv5 com o PyTorch Hub#

Exemplo simples#

Este exemplo carrega um modelo YOLOv5s pré-treinado do PyTorch Hub como model e fornece uma imagem para inferência. 'yolov5s' é um modelo YOLOv5 pequeno e rápido. Para ver os detalhes de todos os modelos disponíveis, consulte o README.

import torch

# Model
model = torch.hub.load("ultralytics/yolov5", "yolov5s")

# Image
im = "https://ultralytics.com/images/zidane.jpg"

# Inference
results = model(im)

results.pandas().xyxy[0]
# xmin    ymin    xmax   ymax  confidence  class    name
# 0  749.50   43.50  1148.0  704.5    0.874023      0  person
# 1  433.50  433.50   517.5  714.5    0.687988     27     tie
# 2  114.75  195.75  1095.0  708.0    0.624512      0  person
# 3  986.00  304.00  1028.0  420.0    0.286865     27     tie

Exemplo detalhado#

Este exemplo mostra inferência em lote com fontes de imagem PIL e OpenCV. results pode ser impresso no console, salvo em runs/hub, exibido na tela em ambientes compatíveis e retornado como tensores ou DataFrames do pandas.

import cv2
import torch
from PIL import Image

# Model
model = torch.hub.load("ultralytics/yolov5", "yolov5s")

# Images
for f in "zidane.jpg", "bus.jpg":
    torch.hub.download_url_to_file(f"https://ultralytics.com/images/{f}", f)  # download 2 images
im1 = Image.open("zidane.jpg")  # PIL image
im2 = cv2.imread("bus.jpg")[..., ::-1]  # OpenCV image (BGR to RGB)

# Inference
results = model([im1, im2], size=640)  # batch of images

# Results
results.print()
results.save()  # or .show()

results.xyxy[0]  # im1 predictions (tensor)
results.pandas().xyxy[0]  # im1 predictions (pandas)
#      xmin    ymin    xmax   ymax  confidence  class    name
# 0  749.50   43.50  1148.0  704.5    0.874023      0  person
# 1  433.50  433.50   517.5  714.5    0.687988     27     tie
# 2  114.75  195.75  1095.0  708.0    0.624512      0  person
# 3  986.00  304.00  1028.0  420.0    0.286865     27     tie
YOLO inference results on zidane.jpg YOLO inference results on bus.jpg

Para ver todas as opções de inferência, consulte o método forward de AutoShape() do YOLOv5.

Configurações de inferência#

Os modelos YOLOv5 têm vários atributos de inferência, como limite de confiança, limite de IoU etc., que podem ser definidos por meio de:

model.conf = 0.25  # limite de confiança do NMS
model.iou = 0.45  # limite de IoU do NMS
model.agnostic = False  # NMS independente da classe
model.multi_label = False  # NMS com vários rótulos por caixa
model.classes = None  # (lista opcional) filtrar por classe, por exemplo, = [0, 15, 16] para pessoas, gatos e cães no COCO
model.max_det = 1000  # número máximo de detecções por imagem
model.amp = False  # inferência com precisão mista automática (AMP)

results = model(im, size=320)  # tamanho de inferência personalizado

Dispositivo#

Depois de criados, os modelos podem ser transferidos para qualquer dispositivo:

model.cpu()  # CPU
model.cuda()  # GPU
model.to(device)  # por exemplo, device=torch.device(0)

Os modelos também podem ser criados diretamente em qualquer device:

model = torch.hub.load("ultralytics/yolov5", "yolov5s", device="cpu")  # carregar na CPU
Dica

As imagens de entrada são transferidas automaticamente para o dispositivo correto do modelo antes da inferência.

Silenciar saídas#

Os modelos podem ser carregados sem exibir saídas com _verbose=False:

model = torch.hub.load("ultralytics/yolov5", "yolov5s", _verbose=False)  # carregar sem exibir saídas

Canais de entrada#

Para carregar um modelo YOLOv5s pré-treinado com 4 canais de entrada em vez dos 3 padrão:

model = torch.hub.load("ultralytics/yolov5", "yolov5s", channels=4)

Nesse caso, o modelo será composto por pesos pré-treinados exceto pela primeira camada de entrada, que não terá mais o mesmo formato da camada de entrada pré-treinada. A camada de entrada continuará inicializada com pesos aleatórios.

Número de classes#

Para carregar um modelo YOLOv5s pré-treinado com 10 classes de saída em vez das 80 padrão:

model = torch.hub.load("ultralytics/yolov5", "yolov5s", classes=10)

Nesse caso, o modelo será composto por pesos pré-treinados exceto pelas camadas de saída, que não terão mais o mesmo formato das camadas de saída pré-treinadas. As camadas de saída continuarão inicializadas com pesos aleatórios.

Forçar novo carregamento#

Se você tiver problemas com as etapas acima, definir force_reload=True pode ajudar, descartando o cache existente e forçando o download de uma nova cópia da versão mais recente do YOLOv5 pelo PyTorch Hub. As cópias em cache ficam em ~/.cache/torch/hub; excluir essa pasta produz o mesmo efeito.

model = torch.hub.load("ultralytics/yolov5", "yolov5s", force_reload=True)  # forçar novo carregamento

Inferência por captura de tela#

Para executar inferência na tela do seu computador:

import torch
from PIL import ImageGrab

# Model
model = torch.hub.load("ultralytics/yolov5", "yolov5s")

# Image
im = ImageGrab.grab()  # fazer uma captura de tela

# Inference
results = model(im)

Inferência com várias GPUs#

Os modelos YOLOv5 podem ser carregados em várias GPUs em paralelo com inferência em threads:

import threading

import torch

def run(model, im):
    """Performs inference on an image using a given model and saves the output; model must support `.save()` method."""
    results = model(im)
    results.save()

# Models
model0 = torch.hub.load("ultralytics/yolov5", "yolov5s", device=0)
model1 = torch.hub.load("ultralytics/yolov5", "yolov5s", device=1)

# Inference
threading.Thread(target=run, args=[model0, "https://ultralytics.com/images/zidane.jpg"], daemon=True).start()
threading.Thread(target=run, args=[model1, "https://ultralytics.com/images/bus.jpg"], daemon=True).start()

Treinamento#

Para carregar um modelo YOLOv5 para treinamento, em vez de inferência, defina autoshape=False. Para carregar um modelo com pesos inicializados aleatoriamente (para treinar do zero), use pretrained=False. Nesse caso, você precisa fornecer seu próprio script de treinamento. Como alternativa, consulte nosso tutorial de treinamento com dados personalizados do YOLOv5 para treinar o modelo.

import torch

model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False)  # carregar pré-treinado
model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False, pretrained=False)  # carregar do zero

Resultados em Base64#

Para usar com serviços de API. Consulte o exemplo da API REST do Flask para ver os detalhes.

import base64
from io import BytesIO

from PIL import Image

results = model(im)  # inference

results.ims  # array das imagens originais (como array np) fornecidas ao modelo para inferência
results.render()  # atualiza results.ims com caixas e rótulos
for im in results.ims:
    buffered = BytesIO()
    im_base64 = Image.fromarray(im)
    im_base64.save(buffered, format="JPEG")
    print(base64.b64encode(buffered.getvalue()).decode("utf-8"))  # imagem codificada em base64 com resultados

Resultados recortados#

Os resultados podem ser retornados e salvos como recortes das detecções:

results = model(im)  # inference
crops = results.crop(save=True)  # dicionário de detecções recortadas

Resultados em Pandas#

Os resultados podem ser retornados como DataFrames do Pandas:

results = model(im)  # inference
results.pandas().xyxy[0]  # DataFrame do Pandas
Saída do pandas (clique para expandir) 
print(results.pandas().xyxy[0])
# xmin    ymin    xmax   ymax  confidence  class    name
# 0  749.50   43.50  1148.0  704.5    0.874023      0  person
# 1  433.50  433.50   517.5  714.5    0.687988     27     tie
# 2  114.75  195.75  1095.0  708.0    0.624512      0  person
# 3  986.00  304.00  1028.0  420.0    0.286865     27     tie

Resultados ordenados#

Os resultados podem ser ordenados por coluna; por exemplo, para ordenar os dígitos detectados em placas da esquerda para a direita (eixo x):

results = model(im)  # inference
results.pandas().xyxy[0].sort_values("xmin")  # ordenados da esquerda para a direita

Resultados em JSON#

Os resultados podem ser retornados no formato JSON depois de convertidos em DataFrames .pandas() usando o método .to_json(). O formato JSON pode ser modificado com o argumento orient. Consulte a documentação de .to_json() do pandas para ver os detalhes.

results = model(im)  # inference
results.pandas().xyxy[0].to_json(orient="records")  # previsões JSON de img1
Saída JSON (clique para expandir) 
[
    {
        "xmin": 749.5,
        "ymin": 43.5,
        "xmax": 1148.0,
        "ymax": 704.5,
        "confidence": 0.8740234375,
        "class": 0,
        "name": "person"
    },
    {
        "xmin": 433.5,
        "ymin": 433.5,
        "xmax": 517.5,
        "ymax": 714.5,
        "confidence": 0.6879882812,
        "class": 27,
        "name": "tie"
    },
    {
        "xmin": 115.25,
        "ymin": 195.75,
        "xmax": 1096.0,
        "ymax": 708.0,
        "confidence": 0.6254882812,
        "class": 0,
        "name": "person"
    },
    {
        "xmin": 986.0,
        "ymin": 304.0,
        "xmax": 1028.0,
        "ymax": 420.0,
        "confidence": 0.2873535156,
        "class": 27,
        "name": "tie"
    }
]

Modelos personalizados#

Este exemplo carrega um modelo YOLOv5s personalizado, treinado em VOC com 20 classes, 'best.pt', usando o PyTorch Hub.

import torch

model = torch.hub.load("ultralytics/yolov5", "custom", path="path/to/best.pt")  # modelo local
model = torch.hub.load("path/to/yolov5", "custom", path="path/to/best.pt", source="local")  # repositório local

Modelos TensorRT, ONNX e OpenVINO#

O PyTorch Hub é compatível com inferência na maioria dos formatos de exportação do YOLOv5, incluindo modelos treinados com dados personalizados. Consulta o tutorial de exportação para TFLite, ONNX, CoreML e TensorRT para saber mais sobre como exportar modelos.

Dica
  • O TensorRT pode ser 2 a 5 vezes mais rápido do que o PyTorch nos benchmarks de GPU.
  • O ONNX e o OpenVINO podem ser 2 a 3 vezes mais rápidos do que o PyTorch nos benchmarks de CPU.
import torch

model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.pt")  # PyTorch
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.torchscript")  # TorchScript
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.onnx")  # ONNX
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s_openvino_model/")  # OpenVINO
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.engine")  # TensorRT
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.mlpackage")  # CoreML (apenas macOS)
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.tflite")  # TFLite
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s_paddle_model/")  # PaddlePaddle

Ambientes compatíveis#

A Ultralytics oferece uma variedade de ambientes prontos para uso, cada um com dependências essenciais pré-instaladas, como CUDA, CUDNN, Python e PyTorch, para você começar seus projetos.

Estado do projeto#

YOLOv5 CI

Este emblema indica que todos os testes de Integração contínua (CI) das GitHub Actions da YOLOv5 estão a passar. Estes testes de CI verificam rigorosamente a funcionalidade e o desempenho da YOLOv5 em vários aspetos importantes: treino, validação, inferência, exportação e avaliação de desempenho. Os testes garantem um funcionamento consistente e fiável em macOS, Windows e Ubuntu e são realizados a cada 24 horas e sempre que é criado um novo commit.

Perguntas frequentes#

  • Não. torch.hub.load("ultralytics/yolov5", ...) transfere o código para ~/.cache/torch/hub e os pesos na primeira utilização. Só é necessário instalar os pacotes em requirements.txt.

  • Usa o ponto de entrada custom com o caminho do checkpoint: torch.hub.load("ultralytics/yolov5", "custom", path="runs/train/exp/weights/best.pt"). Adiciona source="local" e um caminho para um repositório local para carregar sem acesso à rede.

  • Sim. Passa o ficheiro exportado ao mesmo carregador custom e o YOLOv5 seleciona o backend correspondente pela extensão, por exemplo yolov5s.onnx, yolov5s.engine ou yolov5s_openvino_model/.

  • Passa force_reload=True para descartar o repositório em cache e obter o código mais recente, ou elimina ~/.cache/torch/hub manualmente. Assim, também obténs as novas versões do YOLOv5.

  • results.xyxy[0] devolve um tensor com linhas [x1, y1, x2, y2, confidence, class], results.pandas().xyxy[0] devolve um DataFrame com os nomes das classes e .to_json(orient="records") nesse DataFrame gera JSON.

Colaboradores
GLglenn-jocher3RAraimbekovm1PDpderrenger1

Comentários