HongChuang/ultralytics-ascend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

Add Docs languages zh, es, ru, pt, fr, de, ja, ko (#6316)

Browse source 
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
Glenn Jocher 2023-11-13 18:18:31 +01:00 • committed by GitHub
parent e3a538bbde
commit 48e70f0921
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
144 changed files with 17632 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

94
docs/pt/modes/benchmark.md Normal file
View file

@ -0,0 +1,94 @@
---
comments: true
description: Aprenda a avaliar a velocidade e a precisão do YOLOv8 em diversos formatos de exportação; obtenha informações sobre métricas mAP50-95, accuracy_top5 e mais.
keywords: Ultralytics, YOLOv8, benchmarking, perfilagem de velocidade, perfilagem de precisão, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formatos de exportação YOLO
---
# Benchmarking de Modelos com o Ultralytics YOLO
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecossistema Ultralytics YOLO e integrações">
## Introdução
Uma vez que seu modelo esteja treinado e validado, o próximo passo lógico é avaliar seu desempenho em diversos cenários do mundo real. O modo de benchmark no Ultralytics YOLOv8 serve a esse propósito, oferecendo uma estrutura robusta para avaliar a velocidade e a precisão do seu modelo em uma gama de formatos de exportação.
## Por Que o Benchmarking é Crucial?
- **Decisões Informadas:** Obtenha insights sobre o equilíbrio entre velocidade e precisão.
- **Alocação de Recursos:** Entenda como diferentes formatos de exportação se comportam em diferentes hardwares.
- **Otimização:** Aprenda qual formato de exportação oferece o melhor desempenho para o seu caso específico.
- **Eficiência de Custos:** Faça uso mais eficiente dos recursos de hardware com base nos resultados do benchmark.
### Métricas Chave no Modo de Benchmark
- **mAP50-95:** Para detecção de objetos, segmentação e estimativa de pose.
- **accuracy_top5:** Para classificação de imagens.
- **Tempo de Inferência:** Tempo levado para cada imagem em milissegundos.
### Formatos de Exportação Suportados
- **ONNX:** Para desempenho ótimo em CPU
- **TensorRT:** Para eficiência máxima em GPU
- **OpenVINO:** Para otimização em hardware Intel
- **CoreML, TensorFlow SavedModel e Mais:** Para uma variedade de necessidades de implantação.
!!! dica "Dica"
* Exporte para ONNX ou OpenVINO para acelerar até 3x a velocidade em CPU.
* Exporte para TensorRT para acelerar até 5x em GPU.
## Exemplos de Uso
Execute benchmarks do YOLOv8n em todos os formatos de exportação suportados incluindo ONNX, TensorRT etc. Consulte a seção Argumentos abaixo para ver uma lista completa de argumentos de exportação.
!!! exemplo ""
=== "Python"
```python
from ultralytics.utils.benchmarks import benchmark
# Benchmark na GPU
benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0)
```
=== "CLI"
```bash
yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
```
## Argumentos
Argumentos como `model`, `data`, `imgsz`, `half`, `device` e `verbose` proporcionam aos usuários flexibilidade para ajustar os benchmarks às suas necessidades específicas e comparar o desempenho de diferentes formatos de exportação com facilidade.
| Chave | Valor | Descrição |
|-----------|---------|----------------------------------------------------------------------------------------|
| `model` | `None` | caminho para o arquivo do modelo, ou seja, yolov8n.pt, yolov8n.yaml |
| `data` | `None` | caminho para o YAML com dataset de benchmarking (sob o rótulo `val`) |
| `imgsz` | `640` | tamanho da imagem como um escalar ou lista (h, w), ou seja, (640, 480) |
| `half` | `False` | quantização FP16 |
| `int8` | `False` | quantização INT8 |
| `device` | `None` | dispositivo para execução, ou seja, dispositivo cuda=0 ou device=0,1,2,3 ou device=cpu |
| `verbose` | `False` | não continuar em erro (bool), ou limiar mínimo para val (float) |
## Formatos de Exportação
Os benchmarks tentarão executar automaticamente em todos os possíveis formatos de exportação listados abaixo.
| Formato | Argumento `format` | Modelo | Metadados | Argumentos |
|-----------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------|
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
| [Modelo Salvo do TF](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
| [GraphDef do TF](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
Veja os detalhes completos de `exportação` na página [Export](https://docs.ultralytics.com/modes/export/).

108
docs/pt/modes/export.md Normal file
View file

@ -0,0 +1,108 @@
---
comments: true
description: Guia passo a passo sobre como exportar seus modelos YOLOv8 para vários formatos como ONNX, TensorRT, CoreML e mais para implantação. Explore agora!
keywords: YOLO, YOLOv8, Ultralytics, Exportação de modelo, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exportar modelo
---
# Exportação de Modelo com Ultralytics YOLO
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecossistema Ultralytics YOLO e integrações">
## Introdução
O objetivo final de treinar um modelo é implantá-lo para aplicações no mundo real. O modo de exportação no Ultralytics YOLOv8 oferece uma ampla gama de opções para exportar seu modelo treinado para diferentes formatos, tornando-o implantável em várias plataformas e dispositivos. Este guia abrangente visa orientá-lo através das nuances da exportação de modelos, mostrando como alcançar a máxima compatibilidade e performance.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/WbomGeoOT_k?si=aGmuyooWftA0ue9X"
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 Exportar Modelo Treinado Customizado do Ultralytics YOLOv8 e Executar Inferência ao Vivo na Webcam.
</p>
## Por Que Escolher o Modo de Exportação do YOLOv8?
- **Versatilidade:** Exporte para múltiplos formatos incluindo ONNX, TensorRT, CoreML e mais.
- **Performance:** Ganhe até 5x aceleração em GPU com TensorRT e 3x aceleração em CPU com ONNX ou OpenVINO.
- **Compatibilidade:** Torne seu modelo universalmente implantável em numerosos ambientes de hardware e software.
- **Facilidade de Uso:** Interface de linha de comando simples e API Python para exportação rápida e direta de modelos.
### Principais Recursos do Modo de Exportação
Aqui estão algumas das funcionalidades de destaque:
- **Exportação com Um Clique:** Comandos simples para exportação em diferentes formatos.
- **Exportação em Lote:** Exporte modelos capazes de inferência em lote.
- **Inferência Otimizada:** Modelos exportados são otimizados para tempos de inferência mais rápidos.
- **Vídeos Tutoriais:** Guias e tutoriais detalhados para uma experiência de exportação tranquila.
!!! dica "Dica"
* Exporte para ONNX ou OpenVINO para até 3x aceleração em CPU.
* Exporte para TensorRT para até 5x aceleração em GPU.
## Exemplos de Uso
Exporte um modelo YOLOv8n para um formato diferente como ONNX ou TensorRT. Veja a seção de Argumentos abaixo para uma lista completa dos argumentos de exportação.
!!! exemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.pt') # carrega um modelo oficial
model = YOLO('caminho/para/best.pt') # carrega um modelo treinado personalizado
# Exportar o modelo
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n.pt format=onnx # exporta modelo oficial
yolo export model=caminho/para/best.pt format=onnx # exporta modelo treinado personalizado
```
## Argumentos
Configurações de exportação para modelos YOLO referem-se às várias configurações e opções usadas para salvar ou exportar o modelo para uso em outros ambientes ou plataformas. Essas configurações podem afetar a performance, tamanho e compatibilidade do modelo com diferentes sistemas. Algumas configurações comuns de exportação de YOLO incluem o formato do arquivo de modelo exportado (por exemplo, ONNX, TensorFlow SavedModel), o dispositivo em que o modelo será executado (por exemplo, CPU, GPU) e a presença de recursos adicionais como máscaras ou múltiplos rótulos por caixa. Outros fatores que podem afetar o processo de exportação incluem a tarefa específica para a qual o modelo está sendo usado e os requisitos ou restrições do ambiente ou plataforma alvo. É importante considerar e configurar cuidadosamente essas configurações para garantir que o modelo exportado seja otimizado para o caso de uso pretendido e possa ser usado eficazmente no ambiente alvo.
| Chave | Valor | Descrição |
|-------------|-----------------|---------------------------------------------------------------------|
| `format` | `'torchscript'` | formato para exportação |
| `imgsz` | `640` | tamanho da imagem como escalar ou lista (h, w), ou seja, (640, 480) |
| `keras` | `False` | usar Keras para exportação TF SavedModel |
| `optimize` | `False` | TorchScript: otimizar para mobile |
| `half` | `False` | quantização FP16 |
| `int8` | `False` | quantização INT8 |
| `dynamic` | `False` | ONNX/TensorRT: eixos dinâmicos |
| `simplify` | `False` | ONNX/TensorRT: simplificar modelo |
| `opset` | `None` | ONNX: versão do opset (opcional, padrão para a mais recente) |
| `workspace` | `4` | TensorRT: tamanho do espaço de trabalho (GB) |
| `nms` | `False` | CoreML: adicionar NMS |
## Formatos de Exportação
Os formatos de exportação disponíveis para YOLOv8 estão na tabela abaixo. Você pode exportar para qualquer formato usando o argumento `format`, ou seja, `format='onnx'` ou `format='engine'`.
| Formato | Argumento `format` | Modelo | Metadados | Argumentos |
|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------|
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |

73
docs/pt/modes/index.md Normal file
View file

@ -0,0 +1,73 @@
---
comments: true
description: Da treinamento a rastreamento, aproveite ao máximo o YOLOv8 da Ultralytics. Obtenha insights e exemplos para cada modo suportado, incluindo validação, exportação e benchmarking.
keywords: Ultralytics, YOLOv8, Aprendizado de Máquina, Detecção de Objetos, Treinamento, Validação, Predição, Exportação, Rastreamento, Benchmarking
---
# Modos Ultralytics YOLOv8
<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
O Ultralytics YOLOv8 não é apenas mais um modelo de detecção de objetos; é um framework versátil projetado para cobrir todo o ciclo de vida dos modelos de aprendizado de máquina — desde a ingestão de dados e treinamento do modelo até a validação, implantação e rastreamento no mundo real. Cada modo serve a um propósito específico e é projetado para oferecer a flexibilidade e eficiência necessárias para diferentes tarefas e casos de uso.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/j8uQc0qB91s?si=dhnGKgqvs7nPgeaM"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>Assista:</strong> Tutorial dos Modos Ultralytics: Treinar, Validar, Prever, Exportar e Benchmark.
</p>
### Visão Geral dos Modos
Entender os diferentes **modos** que o Ultralytics YOLOv8 suporta é crítico para tirar o máximo proveito de seus modelos:
- **Modo Treino**: Ajuste fino do seu modelo em conjuntos de dados personalizados ou pré-carregados.
- **Modo Validação (Val)**: Um checkpoint pós-treinamento para validar o desempenho do modelo.
- **Modo Predição (Predict)**: Libere o poder preditivo do seu modelo em dados do mundo real.
- **Modo Exportação (Export)**: Prepare seu modelo para implantação em vários formatos.
- **Modo Rastreamento (Track)**: Estenda seu modelo de detecção de objetos para aplicações de rastreamento em tempo real.
- **Modo Benchmarking**: Analise a velocidade e precisão do seu modelo em diversos ambientes de implantação.
Este guia abrangente visa fornecer uma visão geral e insights práticos para cada modo, ajudando você a aproveitar o potencial total do YOLOv8.
## [Treinar](train.md)
O modo Treinar é utilizado para treinar um modelo YOLOv8 em um conjunto de dados personalizado. Neste modo, o modelo é treinado usando o conjunto de dados especificado e os hiperparâmetros escolhidos. O processo de treinamento envolve otimizar os parâmetros do modelo para que ele possa prever com precisão as classes e localizações de objetos em uma imagem.
[Exemplos de Treino](train.md){ .md-button .md-button--primary}
## [Validar](val.md)
O modo Validar é utilizado para validar um modelo YOLOv8 após ter sido treinado. Neste modo, o modelo é avaliado em um conjunto de validação para medir sua precisão e desempenho de generalização. Este modo pode ser usado para ajustar os hiperparâmetros do modelo para melhorar seu desempenho.
[Exemplos de Validação](val.md){ .md-button .md-button--primary}
## [Prever](predict.md)
O modo Prever é utilizado para fazer previsões usando um modelo YOLOv8 treinado em novas imagens ou vídeos. Neste modo, o modelo é carregado de um arquivo de checkpoint, e o usuário pode fornecer imagens ou vídeos para realizar a inferência. O modelo prevê as classes e localizações dos objetos nas imagens ou vídeos fornecidos.
[Exemplos de Predição](predict.md){ .md-button .md-button--primary}
## [Exportar](export.md)
O modo Exportar é utilizado para exportar um modelo YOLOv8 para um formato que possa ser utilizado para implantação. Neste modo, o modelo é convertido para um formato que possa ser utilizado por outras aplicações de software ou dispositivos de hardware. Este modo é útil ao implantar o modelo em ambientes de produção.
[Exemplos de Exportação](export.md){ .md-button .md-button--primary}
## [Rastrear](track.md)
O modo Rastrear é utilizado para rastrear objetos em tempo real usando um modelo YOLOv8. Neste modo, o modelo é carregado de um arquivo de checkpoint, e o usuário pode fornecer um fluxo de vídeo ao vivo para realizar o rastreamento de objetos em tempo real. Este modo é útil para aplicações como sistemas de vigilância ou carros autônomos.
[Exemplos de Rastreamento](track.md){ .md-button .md-button--primary}
## [Benchmark](benchmark.md)
O modo Benchmark é utilizado para fazer um perfil da velocidade e precisão de vários formatos de exportação para o YOLOv8. Os benchmarks fornecem informações sobre o tamanho do formato exportado, suas métricas `mAP50-95` (para detecção de objetos, segmentação e pose) ou `accuracy_top5` (para classificação), e o tempo de inferência em milissegundos por imagem em diversos formatos de exportação, como ONNX, OpenVINO, TensorRT e outros. Essas informações podem ajudar os usuários a escolher o formato de exportação ótimo para seu caso de uso específico, com base em seus requisitos de velocidade e precisão.
[Exemplos de Benchmark](benchmark.md){ .md-button .md-button--primary}

226
docs/pt/modes/predict.md Normal file
View file

@ -0,0 +1,226 @@
---
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](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Detecção de Jogador de Futebol](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Detecção de Queda de Pessoas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) |
| 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:
!!! exemplo "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.
!!! dica "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:
!!! exemplo "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

200
docs/pt/modes/track.md Normal file
View file

@ -0,0 +1,200 @@
---
comments: true
description: Aprenda a usar o Ultralytics YOLO para rastreamento de objetos em fluxos de vídeo. Guias para usar diferentes rastreadores e personalizar configurações de rastreador.
keywords: Ultralytics, YOLO, rastreamento de objetos, fluxos de vídeo, BoT-SORT, ByteTrack, guia em Python, guia CLI
---
# Rastreamento de Múltiplos Objetos com Ultralytics YOLO
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418637-1d6250fd-1515-4c10-a844-a32818ae6d46.png" alt="Exemplos de rastreamento de múltiplos objetos">
Rastreamento de objetos no âmbito da análise de vídeo é uma tarefa crucial que não apenas identifica a localização e classe dos objetos dentro do quadro, mas também mantém um ID único para cada objeto detectado à medida que o vídeo avança. As aplicações são ilimitadas — variando desde vigilância e segurança até análises esportivas em tempo real.
## Por Que Escolher Ultralytics YOLO para Rastreamento de Objetos?
A saída dos rastreadores da Ultralytics é consistente com a detecção de objetos padrão, mas com o valor agregado dos IDs dos objetos. Isso facilita o rastreamento de objetos em fluxos de vídeo e a realização de análises subsequentes. Aqui está o porquê de considerar usar Ultralytics YOLO para suas necessidades de rastreamento de objetos:
- **Eficiência:** Processa fluxos de vídeo em tempo real sem comprometer a precisão.
- **Flexibilidade:** Suporta múltiplos algoritmos de rastreamento e configurações.
- **Facilidade de Uso:** Simples API em Python e opções CLI para rápida integração e implantação.
- **Personalização:** Fácil de usar com modelos YOLO treinados personalizados, permitindo integração em aplicações específicas de domínio.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/hHyHmOtmEgs?si=VNZtXmm45Nb9s-N-"
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>Assistir:</strong> Detecção e Rastreamento de Objetos com Ultralytics YOLOv8.
</p>
## Aplicações no Mundo Real
| Transporte | Varejo | Aquicultura |
|:------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------------------------:|
| ![Rastreamento de Veículos](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Rastreamento de Pessoas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Rastreamento de Peixes](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) |
| Rastreamento de Veículos | Rastreamento de Pessoas | Rastreamento de Peixes |
## Características em Destaque
Ultralytics YOLO estende suas funcionalidades de detecção de objetos para fornecer rastreamento de objetos robusto e versátil:
- **Rastreamento em Tempo Real:** Acompanha objetos de forma contínua em vídeos de alta taxa de quadros.
- **Suporte a Múltiplos Rastreadores:** Escolha dentre uma variedade de algoritmos de rastreamento estabelecidos.
- **Configurações de Rastreador Personalizáveis:** Adapte o algoritmo de rastreamento para atender requisitos específicos ajustando vários parâmetros.
## Rastreadores Disponíveis
Ultralytics YOLO suporta os seguintes algoritmos de rastreamento. Eles podem ser ativados passando o respectivo arquivo de configuração YAML, como `tracker=tracker_type.yaml`:
* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Use `botsort.yaml` para ativar este rastreador.
* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Use `bytetrack.yaml` para ativar este rastreador.
O rastreador padrão é o BoT-SORT.
## Rastreamento
Para executar o rastreador em fluxos de vídeo, use um modelo Detect, Segment ou Pose treinado, como YOLOv8n, YOLOv8n-seg e YOLOv8n-pose.
!!! exemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo oficial ou personalizado
model = YOLO('yolov8n.pt') # Carregar um modelo Detect oficial
model = YOLO('yolov8n-seg.pt') # Carregar um modelo Segment oficial
model = YOLO('yolov8n-pose.pt') # Carregar um modelo Pose oficial
model = YOLO('caminho/para/melhor.pt') # Carregar um modelo treinado personalizado
# Realizar rastreamento com o modelo
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Rastreamento com rastreador padrão
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Rastreamento com o rastreador ByteTrack
```
=== "CLI"
```bash
# Realizar rastreamento com vários modelos usando a interface de linha de comando
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Modelo Detect oficial
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Modelo Segment oficial
yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Modelo Pose oficial
yolo track model=caminho/para/melhor.pt source="https://youtu.be/LNwODJXcvt4" # Modelo treinado personalizado
# Rastrear usando o rastreador ByteTrack
yolo track model=caminho/para/melhor.pt tracker="bytetrack.yaml"
```
Como pode ser visto no uso acima, o rastreamento está disponível para todos os modelos Detect, Segment e Pose executados em vídeos ou fontes de streaming.
## Configuração
### Argumentos de Rastreamento
A configuração de rastreamento compartilha propriedades com o modo Predict, como `conf`, `iou`, e `show`. Para mais configurações, consulte a página de [Predict](https://docs.ultralytics.com/modes/predict/) model page.
!!! exemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Configurar os parâmetros de rastreamento e executar o rastreador
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
```
=== "CLI"
```bash
# Configurar parâmetros de rastreamento e executar o rastreador usando a interface de linha de comando
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
```
### Seleção de Rastreador
A Ultralytics também permite que você use um arquivo de configuração de rastreador modificado. Para fazer isso, simplesmente faça uma cópia de um arquivo de configuração de rastreador (por exemplo, `custom_tracker.yaml`) de [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) e modifique quaisquer configurações (exceto `tracker_type`) conforme suas necessidades.
!!! exemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar o modelo e executar o rastreador com um arquivo de configuração personalizado
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
```
=== "CLI"
```bash
# Carregar o modelo e executar o rastreador com um arquivo de configuração personalizado usando a interface de linha de comando
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
```
Para uma lista completa de argumentos de rastreamento, consulte a página [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers).
## Exemplos em Python
### Loop de Persistência de Rastreamentos
Aqui está um script em Python usando OpenCV (`cv2`) e YOLOv8 para executar rastreamento de objetos em quadros de vídeo. Este script ainda pressupõe que você já instalou os pacotes necessários (`opencv-python` e `ultralytics`). O argumento `persist=True` indica ao rastreador que a imagem ou quadro atual é o próximo de uma sequência e que espera rastreamentos da imagem anterior na imagem atual.
!!! exemplo "Loop de fluxo com rastreamento"
```python
import cv2
from ultralytics import YOLO
# Carregar o modelo YOLOv8
model = YOLO('yolov8n.pt')
# Abrir o arquivo de vídeo
video_path = "caminho/para/video.mp4"
cap = cv2.VideoCapture(video_path)
# Repetir através dos quadros de vídeo
while cap.isOpened():
# Ler um quadro do vídeo
success, frame = cap.read()
if success:
# Executar rastreamento YOLOv8 no quadro, persistindo rastreamentos entre quadros
results = model.track(frame, persist=True)
# Visualizar os resultados no quadro
annotated_frame = results[0].plot()
# Exibir o quadro anotado
cv2.imshow("Rastreamento YOLOv8", annotated_frame)
# Interromper o loop se 'q' for pressionado
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Interromper o loop se o fim do vídeo for atingido
break
# Liberar o objeto de captura de vídeo e fechar a janela de exibição
cap.release()
cv2.destroyAllWindows()
```
Note a mudança de `model(frame)` para `model.track(frame)`, que habilita o rastreamento de objetos ao invés de detecção simples. Este script modificado irá executar o rastreador em cada quadro do vídeo, visualizar os resultados e exibi-los em uma janela. O loop pode ser encerrado pressionando 'q'.
## Contribuir com Novos Rastreadores
Você é proficiente em rastreamento de múltiplos objetos e implementou ou adaptou com sucesso um algoritmo de rastreamento com Ultralytics YOLO? Convidamos você a contribuir para nossa seção de Rastreadores em [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! Suas aplicações do mundo real e soluções podem ser inestimáveis para usuários trabalhando em tarefas de rastreamento.
Ao contribuir para esta seção, você ajuda a expandir o escopo de soluções de rastreamento disponíveis dentro do framework Ultralytics YOLO, adicionando outra camada de funcionalidade e utilidade para a comunidade.
Para iniciar sua contribuição, por favor, consulte nosso [Guia de Contribuição](https://docs.ultralytics.com/help/contributing) para instruções completas sobre como enviar um Pedido de Pull (PR) 🛠️. Estamos ansiosos para ver o que você traz para a mesa!
Juntos, vamos aprimorar as capacidades de rastreamento do ecossistema Ultralytics YOLO 🙏!

206
docs/pt/modes/train.md Normal file
View file

@ -0,0 +1,206 @@
---
comments: true
description: Guia passo a passo para treinar modelos YOLOv8 com a YOLO da Ultralytics, incluindo exemplos de treinamento com uma única GPU e múltiplas GPUs
keywords: Ultralytics, YOLOv8, YOLO, detecção de objetos, modo de treino, conjunto de dados personalizado, treinamento com GPU, multi-GPU, hiperparâmetros, exemplos de CLI, exemplos em Python
---
# Treinamento de Modelos com a YOLO da Ultralytics
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecossistema e integrações da YOLO da Ultralytics">
## Introdução
O treinamento de um modelo de aprendizado profundo envolve fornecer dados e ajustar seus parâmetros para que ele possa fazer previsões precisas. O modo de treino na YOLOv8 da Ultralytics é projetado para um treinamento eficaz e eficiente de modelos de detecção de objetos, aproveitando totalmente as capacidades do hardware moderno. Este guia visa cobrir todos os detalhes que você precisa para começar a treinar seus próprios modelos usando o robusto conjunto de recursos da YOLOv8.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
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 Treinar um modelo YOLOv8 no Seu Conjunto de Dados Personalizado no Google Colab.
</p>
## Por Que Escolher a YOLO da Ultralytics para Treinamento?
Aqui estão algumas razões convincentes para optar pelo modo de Treino da YOLOv8:
- **Eficiência:** Aproveite ao máximo seu hardware, seja em um setup com uma única GPU ou expandindo para múltiplas GPUs.
- **Versatilidade:** Treine em conjuntos de dados personalizados, além dos já disponíveis, como COCO, VOC e ImageNet.
- **Facilidade de Uso:** Interfaces de linha de comando (CLI) e em Python simples, porém poderosas, para uma experiência de treinamento direta.
- **Flexibilidade de Hiperparâmetros:** Uma ampla gama de hiperparâmetros personalizáveis para ajustar o desempenho do modelo.
### Principais Recursos do Modo de Treino
Os seguintes são alguns recursos notáveis ​​do modo de Treino da YOLOv8:
- **Download Automático de Datasets:** Datasets padrões como COCO, VOC e ImageNet são baixados automaticamente na primeira utilização.
- **Suporte a Multi-GPU:** Escalone seus esforços de treinamento de maneira uniforme entre várias GPUs para acelerar o processo.
- **Configuração de Hiperparâmetros:** Opção de modificar hiperparâmetros através de arquivos de configuração YAML ou argumentos de CLI.
- **Visualização e Monitoramento:** Acompanhamento em tempo real das métricas de treinamento e visualização do processo de aprendizagem para obter melhores insights.
!!! dica "Dica"
* Conjuntos de dados YOLOv8 como COCO, VOC, ImageNet e muitos outros são baixados automaticamente na primeira utilização, ou seja, `yolo train data=coco.yaml`
## Exemplos de Uso
Treine o YOLOv8n no conjunto de dados COCO128 por 100 épocas com tamanho de imagem de 640. O dispositivo de treinamento pode ser especificado usando o argumento `device`. Se nenhum argumento for passado, a GPU `device=0` será usado se disponível, caso contrário, `device=cpu` será usado. Veja a seção Argumentos abaixo para uma lista completa dos argumentos de treinamento.
!!! exemplo "Exemplo de Treinamento em Uma Única GPU e CPU"
O dispositivo é determinado automaticamente. Se uma GPU estiver disponível, ela será usada, caso contrário, o treinamento começará na CPU.
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.yaml') # construir um novo modelo a partir do YAML
model = YOLO('yolov8n.pt') # carregar um modelo pré-treinado (recomendado para treinamento)
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construir a partir do YAML e transferir pesos
# Treinar o modelo
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
```
=== "CLI"
```bash
# Construir um novo modelo a partir do YAML e começar o treinamento do zero
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
# Começar o treinamento a partir de um modelo *.pt pré-treinado
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
# Construir um novo modelo a partir do YAML, transferir pesos pré-treinados para ele e começar o treinamento
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
```
### Treinamento com Multi-GPU
O treinamento com múltiplas GPUs permite uma utilização mais eficiente dos recursos de hardware disponíveis, distribuindo a carga de treinamento entre várias GPUs. Esse recurso está disponível por meio da API do Python e da interface de linha de comando. Para habilitar o treinamento com várias GPUs, especifique os IDs dos dispositivos de GPU que deseja usar.
!!! exemplo "Exemplo de Treinamento com Multi-GPU"
Para treinar com 2 GPUs, dispositivos CUDA 0 e 1 use os seguintes comandos. Expanda para GPUs adicionais conforme necessário.
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.pt') # carregar um modelo pré-treinado (recomendado para treinamento)
# Treinar o modelo com 2 GPUs
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
```
=== "CLI"
```bash
# Começar o treinamento a partir de um modelo *.pt pré-treinado usando as GPUs 0 e 1
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
```
### Treinamento com Apple M1 e M2 MPS
Com a integração do suporte para os chips Apple M1 e M2 nos modelos YOLO da Ultralytics, agora é possível treinar seus modelos em dispositivos que utilizam o poderoso framework Metal Performance Shaders (MPS). O MPS oferece uma forma de alto desempenho de executar tarefas de computação e processamento de imagens no silício personalizado da Apple.
Para habilitar o treinamento nos chips Apple M1 e M2, você deve especificar 'mps' como seu dispositivo ao iniciar o processo de treinamento. Abaixo está um exemplo de como você pode fazer isso em Python e via linha de comando:
!!! exemplo "Exemplo de Treinamento com MPS"
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.pt') # carregar um modelo pré-treinado (recomendado para treinamento)
# Treinar o modelo com MPS
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
```
=== "CLI"
```bash
# Começar o treinamento a partir de um modelo *.pt pré-treinado usando MPS
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
```
Ao aproveitar o poder computacional dos chips M1/M2, isso possibilita o processamento mais eficiente das tarefas de treinamento. Para orientações mais detalhadas e opções avançadas de configuração, consulte a [documentação do PyTorch MPS](https://pytorch.org/docs/stable/notes/mps.html).
## Registro de Logs
Ao treinar um modelo YOLOv8, você pode achar valioso acompanhar o desempenho do modelo ao longo do tempo. É aqui que o registro de logs se torna útil. O YOLO da Ultralytics oferece suporte para três tipos de loggers - Comet, ClearML e TensorBoard.
Para usar um logger, selecione-o no menu suspenso no trecho de código acima e execute-o. O logger escolhido será instalado e inicializado.
### Comet
[Comet](https://www.comet.ml/site/) é uma plataforma que permite a cientistas de dados e desenvolvedores rastrear, comparar, explicar e otimizar experimentos e modelos. Oferece funcionalidades como métricas em tempo real, diffs de código e acompanhamento de hiperparâmetros.
Para usar o Comet:
!!! exemplo ""
=== "Python"
```python
# pip install comet_ml
import comet_ml
comet_ml.init()
```
Lembre-se de fazer login na sua conta Comet no site deles e obter sua chave de API. Você precisará adicionar isso às suas variáveis de ambiente ou ao seu script para registrar seus experimentos.
### ClearML
[ClearML](https://www.clear.ml/) é uma plataforma de código aberto que automatiza o rastreamento de experimentos e ajuda com o compartilhamento eficiente de recursos. É projetada para ajudar as equipes a gerenciar, executar e reproduzir seus trabalhos de ML de maneira mais eficiente.
Para usar o ClearML:
!!! exemplo ""
=== "Python"
```python
# pip install clearml
import clearml
clearml.browser_login()
```
Após executar este script, você precisará fazer login na sua conta ClearML no navegador e autenticar sua sessão.
### TensorBoard
[TensorBoard](https://www.tensorflow.org/tensorboard) é um kit de ferramentas de visualização para TensorFlow. Permite visualizar o seu gráfico TensorFlow, plotar métricas quantitativas sobre a execução do seu gráfico e mostrar dados adicionais como imagens que passam por ele.
Para usar o TensorBoard em [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb):
!!! exemplo ""
=== "CLI"
```bash
load_ext tensorboard
tensorboard --logdir ultralytics/runs # substitua pelo diretório 'runs'
```
Para usar o TensorBoard localmente, execute o comando abaixo e veja os resultados em http://localhost:6006/:
!!! exemplo ""
=== "CLI"
```bash
tensorboard --logdir ultralytics/runs # substitua pelo diretório 'runs'
```
Isso irá carregar o TensorBoard e direcioná-lo para o diretório onde seus logs de treinamento estão salvos.
Depois de configurar o seu logger, você pode então prosseguir com o treinamento do seu modelo. Todas as métricas de treinamento serão registradas automaticamente na sua plataforma escolhida, e você pode acessar esses logs para monitorar o desempenho do seu modelo ao longo do tempo, comparar diferentes modelos e identificar áreas para melhoria.

86
docs/pt/modes/val.md Normal file
View file

@ -0,0 +1,86 @@
---
comments: true
description: Guia para Validação de Modelos YOLOv8. Aprenda como avaliar o desempenho dos seus modelos YOLO utilizando configurações e métricas de validação com exemplos em Python e CLI.
keywords: Ultralytics, Documentação YOLO, YOLOv8, validação, avaliação de modelo, hiperparâmetros, precisão, métricas, Python, CLI
---
# Validação de Modelos 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
A validação é um passo crítico no pipeline de aprendizado de máquina, permitindo que você avalie a qualidade dos seus modelos treinados. O modo Val no Ultralytics YOLOv8 fornece um robusto conjunto de ferramentas e métricas para avaliar o desempenho dos seus modelos de detecção de objetos. Este guia serve como um recurso completo para entender como usar efetivamente o modo Val para garantir que seus modelos sejam precisos e confiáveis.
## Por Que Validar com o Ultralytics YOLO?
Aqui estão as vantagens de usar o modo Val no YOLOv8:
- **Precisão:** Obtenha métricas precisas como mAP50, mAP75 e mAP50-95 para avaliar seu modelo de forma abrangente.
- **Conveniência:** Utilize recursos integrados que lembram as configurações de treinamento, simplificando o processo de validação.
- **Flexibilidade:** Valide seu modelo com os mesmos ou diferentes conjuntos de dados e tamanhos de imagem.
- **Ajuste de Hiperparâmetros:** Utilize as métricas de validação para refinar seu modelo e obter um desempenho melhor.
### Principais Recursos do Modo Val
Estas são as funcionalidades notáveis oferecidas pelo modo Val do YOLOv8:
- **Configurações Automatizadas:** Os modelos lembram suas configurações de treinamento para validação direta.
- **Suporte Multi-Métrico:** Avalie seu modelo com base em uma variedade de métricas de precisão.
- **API em Python e CLI:** Escolha entre a interface de linha de comando ou API em Python com base na sua preferência de validação.
- **Compatibilidade de Dados:** Funciona perfeitamente com conjuntos de dados usados durante a fase de treinamento, bem como conjuntos de dados personalizados.
!!! tip "Dica"
* Os modelos YOLOv8 lembram automaticamente suas configurações de treinamento, então você pode validar um modelo no mesmo tamanho de imagem e no conjunto de dados original facilmente com apenas `yolo val model=yolov8n.pt` ou `model('yolov8n.pt').val()`
## Exemplos de Uso
Validar a precisão do modelo YOLOv8n treinado no conjunto de dados COCO128. Nenhum argumento precisa ser passado, pois o `model` retém os dados de treinamento e argumentos como atributos do modelo. Veja a seção de Argumentos abaixo para uma lista completa dos argumentos de exportação.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.pt') # carregar um modelo oficial
model = YOLO('path/to/best.pt') # carregar um modelo personalizado
# Validar o modelo
metrics = model.val() # nenhum argumento necessário, conjunto de dados e configurações lembrados
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # uma lista contém map50-95 de cada categoria
```
=== "CLI"
```bash
yolo detect val model=yolov8n.pt # validar modelo oficial
yolo detect val model=path/to/best.pt # validar modelo personalizado
```
## Argumentos
As configurações de validação para os modelos YOLO referem-se aos vários hiperparâmetros e configurações usados para avaliar o desempenho do modelo em um conjunto de dados de validação. Essas configurações podem afetar o desempenho, velocidade e precisão do modelo. Algumas configurações comuns de validação do YOLO incluem o tamanho do lote, a frequência com que a validação é realizada durante o treinamento e as métricas usadas para avaliar o desempenho do modelo. Outros fatores que podem afetar o processo de validação incluem o tamanho e a composição do conjunto de dados de validação e a tarefa específica para a qual o modelo está sendo usado. É importante ajustar e experimentar cuidadosamente essas configurações para garantir que o modelo apresente um bom desempenho no conjunto de dados de validação e para detectar e prevenir o sobreajuste.
| Chave | Valor | Descrição |
|---------------|---------|-----------------------------------------------------------------------------------|
| `data` | `None` | caminho para o arquivo de dados, ex. coco128.yaml |
| `imgsz` | `640` | tamanho das imagens de entrada como inteiro |
| `batch` | `16` | número de imagens por lote (-1 para AutoBatch) |
| `save_json` | `False` | salvar resultados em arquivo JSON |
| `save_hybrid` | `False` | salvar versão híbrida das etiquetas (etiquetas + previsões adicionais) |
| `conf` | `0.001` | limite de confiança do objeto para detecção |
| `iou` | `0.6` | limiar de interseção sobre união (IoU) para NMS |
| `max_det` | `300` | número máximo de detecções por imagem |
| `half` | `True` | usar precisão meia (FP16) |
| `device` | `None` | dispositivo para execução, ex. dispositivo cuda=0/1/2/3 ou device=cpu |
| `dnn` | `False` | usar OpenCV DNN para inferência ONNX |
| `plots` | `False` | mostrar gráficos durante o treinamento |
| `rect` | `False` | val retangular com cada lote colado para minimizar o preenchimento |
| `split` | `val` | divisão do conjunto de dados para usar na validação, ex. 'val', 'test' ou 'train' |
|