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

127
docs/pt/datasets/index.md Normal file
View file

@ -0,0 +1,127 @@
---
comments: true
description: Explore diversos conjuntos de dados de visão computacional suportados pela Ultralytics para detecção de objetos, segmentação, estimativa de pose, classificação de imagens e rastreamento de múltiplos objetos.
keywords: visão computacional, conjuntos de dados, Ultralytics, YOLO, detecção de objetos, segmentação de instância, estimativa de pose, classificação de imagens, rastreamento de múltiplos objetos
---
# Visão Geral de Conjuntos de Dados
A Ultralytics oferece suporte para diversos conjuntos de dados para facilitar tarefas de visão computacional, como detecção, segmentação de instância, estimativa de pose, classificação e rastreamento de múltiplos objetos. Abaixo está uma lista dos principais conjuntos de dados da Ultralytics, seguidos por um resumo de cada tarefa de visão computacional e os respectivos conjuntos de dados.
!!! note
🚧 Nossa documentação multilíngue está atualmente em construção e estamos trabalhando arduamente para melhorá-la. Obrigado pela sua paciência! 🙏
## [Conjuntos de Dados de Detecção](../../datasets/detect/index.md)
A técnica de detecção de objetos com caixas delimitadoras envolve detectar e localizar objetos em uma imagem desenhando uma caixa delimitadora ao redor de cada objeto.
- [Argoverse](../../datasets/detect/argoverse.md): Um conjunto de dados contendo dados de rastreamento 3D e previsão de movimento de ambientes urbanos com anotações detalhadas.
- [COCO](../../datasets/detect/coco.md): Um conjunto de dados em grande escala projetado para detecção de objetos, segmentação e legendagem com mais de 200 mil imagens etiquetadas.
- [COCO8](../../datasets/detect/coco8.md): Contém as primeiras 4 imagens do COCO train e COCO val, adequado para testes rápidos.
- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Um conjunto de dados de imagens de espiga de trigo coletadas ao redor do mundo para tarefas de detecção e localização de objetos.
- [Objects365](../../datasets/detect/objects365.md): Um conjunto de dados de alta qualidade de grande escala para detecção de objetos com 365 categorias e mais de 600 mil imagens anotadas.
- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Um conjunto de dados abrangente do Google com 1,7 milhão de imagens de treino e 42 mil imagens de validação.
- [SKU-110K](../../datasets/detect/sku-110k.md): Um conjunto de dados apresentando detecção de objetos densos em ambientes de varejo com mais de 11 mil imagens e 1,7 milhão de caixas delimitadoras.
- [VisDrone](../../datasets/detect/visdrone.md): Um conjunto de dados que contém informação de detecção de objetos e rastreamento de múltiplos objetos a partir de imagens capturadas por drones com mais de 10 mil imagens e sequências de vídeo.
- [VOC](../../datasets/detect/voc.md): O conjunto de dados Visual Object Classes (VOC) Pascal para detecção de objetos e segmentação com 20 classes de objetos e mais de 11 mil imagens.
- [xView](../../datasets/detect/xview.md): Um conjunto de dados para detecção de objetos em imagens aéreas com 60 categorias de objetos e mais de 1 milhão de objetos anotados.
## [Conjuntos de Dados de Segmentação de Instância](../../datasets/segment/index.md)
A segmentação de instância é uma técnica de visão computacional que identifica e localiza objetos em uma imagem ao nível de pixel.
- [COCO](../../datasets/segment/coco.md): Um conjunto de dados em grande escala projetado para detecção de objetos, tarefas de segmentação e legendagem com mais de 200 mil imagens etiquetadas.
- [COCO8-seg](../../datasets/segment/coco8-seg.md): Um conjunto de dados menor para tarefas de segmentação de instâncias, contendo um subconjunto de 8 imagens COCO com anotações de segmentação.
## [Estimativa de Pose](../../datasets/pose/index.md)
A estimativa de pose é uma técnica usada para determinar a pose do objeto em relação à câmera ou ao sistema de coordenadas do mundo.
- [COCO](../../datasets/pose/coco.md): Um conjunto de dados em grande escala com anotações de pose humana projetado para tarefas de estimativa de pose.
- [COCO8-pose](../../datasets/pose/coco8-pose.md): Um conjunto de dados menor para tarefas de estimativa de pose, contendo um subconjunto de 8 imagens COCO com anotações de pose humana.
- [Tiger-pose](../../datasets/pose/tiger-pose.md): Um conjunto de dados compacto consistindo de 263 imagens focadas em tigres, anotadas com 12 pontos-chave por tigre para tarefas de estimativa de pose.
## [Classificação](../../datasets/classify/index.md)
Classificação de imagens é uma tarefa de visão computacional que envolve categorizar uma imagem em uma ou mais classes ou categorias predefinidas com base em seu conteúdo visual.
- [Caltech 101](../../datasets/classify/caltech101.md): Um conjunto de dados contendo imagens de 101 categorias de objetos para tarefas de classificação de imagens.
- [Caltech 256](../../datasets/classify/caltech256.md): Uma versão estendida do Caltech 101 com 256 categorias de objetos e imagens mais desafiadoras.
- [CIFAR-10](../../datasets/classify/cifar10.md): Um conjunto de dados de 60 mil imagens coloridas de 32x32 em 10 classes, com 6 mil imagens por classe.
- [CIFAR-100](../../datasets/classify/cifar100.md): Uma versão estendida do CIFAR-10 com 100 categorias de objetos e 600 imagens por classe.
- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Um conjunto de dados consistindo de 70 mil imagens em escala de cinza de 10 categorias de moda para tarefas de classificação de imagens.
- [ImageNet](../../datasets/classify/imagenet.md): Um conjunto de dados em grande escala para detecção de objetos e classificação de imagens com mais de 14 milhões de imagens e 20 mil categorias.
- [ImageNet-10](../../datasets/classify/imagenet10.md): Um subconjunto menor do ImageNet com 10 categorias para experimentação e teste mais rápidos.
- [Imagenette](../../datasets/classify/imagenette.md): Um subconjunto menor do ImageNet que contém 10 classes facilmente distinguíveis para treinamento e teste mais rápidos.
- [Imagewoof](../../datasets/classify/imagewoof.md): Um subconjunto do ImageNet mais desafiador contendo 10 categorias de raças de cães para tarefas de classificação de imagens.
- [MNIST](../../datasets/classify/mnist.md): Um conjunto de dados de 70 mil imagens em escala de cinza de dígitos manuscritos para tarefas de classificação de imagens.
## [Caixas Delimitadoras Orientadas (OBB)](../../datasets/obb/index.md)
As Caixas Delimitadoras Orientadas (OBB) é um método em visão computacional para detectar objetos angulados em imagens usando caixas delimitadoras rotacionadas, muitas vezes aplicado em imagens aéreas e de satélite.
- [DOTAv2](../../datasets/obb/dota-v2.md): Um popular conjunto de dados de imagens aéreas OBB com 1,7 milhão de instâncias e 11.268 imagens.
## [Rastreamento de Múltiplos Objetos](../../datasets/track/index.md)
O rastreamento de múltiplos objetos é uma técnica de visão computacional que envolve detectar e rastrear vários objetos ao longo do tempo em uma sequência de vídeo.
- [Argoverse](../../datasets/detect/argoverse.md): Um conjunto de dados contendo dados de rastreamento 3D e previsão de movimento de ambientes urbanos com anotações ricas para tarefas de rastreamento de múltiplos objetos.
- [VisDrone](../../datasets/detect/visdrone.md): Um conjunto de dados que contém informação de detecção de objetos e rastreamento de múltiplos objetos a partir de imagens capturadas por drones com mais de 10 mil imagens e sequências de vídeo.
## Contribuir com Novos Conjuntos de Dados
Contribuir com um novo conjunto de dados envolve várias etapas para garantir que ele se alinhe bem com a infraestrutura existente. Abaixo estão as etapas necessárias:
### Etapas para Contribuir com um Novo Conjunto de Dados
1. **Coletar Imagens**: Reúna as imagens que pertencem ao conjunto de dados. Estas podem ser coletadas de várias fontes, como bancos de dados públicos ou sua própria coleção.
2. **Anotar Imagens**: Anote essas imagens com caixas delimitadoras, segmentos ou pontos-chave, dependendo da tarefa.
3. **Exportar Anotações**: Converta essas anotações no formato de arquivo *.txt YOLO que a Ultralytics suporta.
4. **Organizar Conjunto de Dados**: Organize seu conjunto de dados na estrutura de pastas correta. Você deve ter diretórios de topo `train/` e `val/`, e dentro de cada um, um subdiretório `images/` e `labels/`.
```
conjunto_de_dados/
├── train/
│ ├── images/
│ └── labels/
└── val/
├── images/
└── labels/
```
5. **Criar um Arquivo `data.yaml`**: No diretório raiz do seu conjunto de dados, crie um arquivo `data.yaml` que descreva o conjunto de dados, as classes e outras informações necessárias.
6. **Otimizar Imagens (Opcional)**: Se você quiser reduzir o tamanho do conjunto de dados para um processamento mais eficiente, pode otimizar as imagens usando o código abaixo. Isso não é obrigatório, mas recomendado para tamanhos menores de conjunto de dados e velocidades de download mais rápidas.
7. **Compactar Conjunto de Dados**: Compacte toda a pasta do conjunto de dados em um arquivo zip.
8. **Documentar e PR**: Crie uma página de documentação descrevendo seu conjunto de dados e como ele se encaixa no framework existente. Depois disso, submeta um Pull Request (PR). Consulte [Diretrizes de Contribuição da Ultralytics](https://docs.ultralytics.com/help/contributing) para mais detalhes sobre como submeter um PR.
### Exemplo de Código para Otimizar e Compactar um Conjunto de Dados
!!! example "Otimizar e Compactar um Conjunto de Dados"
=== "Python"
```python
from pathlib import Path
from ultralytics.data.utils import compress_one_image
from ultralytics.utils.downloads import zip_directory
# Definir diretório do conjunto de dados
path = Path('caminho/para/conjunto_de_dados')
# Otimizar imagens no conjunto de dados (opcional)
for f in path.rglob('*.jpg'):
compress_one_image(f)
# Compactar conjunto de dados em 'caminho/para/conjunto_de_dados.zip'
zip_directory(path)
```
Seguindo esses passos, você poderá contribuir com um novo conjunto de dados que se integra bem com a estrutura existente da Ultralytics.

82
docs/pt/index.md Normal file
View file

@ -0,0 +1,82 @@
---
comments: true
description: Explore um guia completo do Ultralytics YOLOv8, um modelo de detecção de objetos e segmentação de imagens de alta velocidade e precisão. Tutoriais de instalação, previsão, treinamento e muito mais.
keywords: Ultralytics, YOLOv8, detecção de objetos, segmentação de imagens, aprendizado de máquina, aprendizado profundo, visão computacional, instalação do YOLOv8, previsão do YOLOv8, treinamento do YOLOv8, história do YOLO, licenças do YOLO
---
<div align="center">
<p>
<a href="https://yolovision.ultralytics.com" target="_blank">
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Banner Ultralytics YOLO"></a>
</p>
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="GitHub da Ultralytics"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="LinkedIn da Ultralytics"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Twitter da Ultralytics"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://youtube.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="YouTube da Ultralytics"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="TikTok da Ultralytics"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Instagram da Ultralytics"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Discord da Ultralytics"></a>
<br>
<br>
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml/badge.svg" alt="Integração Contínua da Ultralytics"></a>
<a href="https://codecov.io/github/ultralytics/ultralytics"><img src="https://codecov.io/github/ultralytics/ultralytics/branch/main/graph/badge.svg?token=HHW7IIVFVY" alt="Cobertura de Código da Ultralytics"></a>
<a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="Citação do YOLOv8"></a>
<a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Contagem de Pulls no Docker"></a>
<br>
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Executar no Gradient"/></a>
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Abrir no Colab"></a>
<a href="https://www.kaggle.com/ultralytics/yolov8"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Abrir no Kaggle"></a>
</div>
Apresentamos o [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), a mais recente versão do aclamado modelo de detecção de objetos em tempo real e segmentação de imagens. O YOLOv8 é baseado nos mais recentes avanços do aprendizado profundo e visão computacional, oferecendo um desempenho sem paralelo em termos de velocidade e precisão. Seu design simplificado o torna adequado para várias aplicações e facilmente adaptável a diferentes plataformas de hardware, desde dispositivos de borda até APIs na nuvem.
Explore os Documentos do YOLOv8, um recurso abrangente projetado para ajudá-lo a entender e utilizar suas características e capacidades. Seja você um praticante experiente de aprendizado de máquina ou novo no campo, este hub tem como objetivo maximizar o potencial do YOLOv8 em seus projetos
!!! note
🚧 Nossa documentação em vários idiomas está atualmente em construção e estamos trabalhando arduamente para aprimorá-la. Agradecemos sua paciência! 🙏
## Por Onde Começar
- **Instalar** `ultralytics` com pip e começar a funcionar em minutos &nbsp; [:material-clock-fast: Começar](quickstart.md){ .md-button }
- **Prever** novas imagens e vídeos com o YOLOv8 &nbsp; [:octicons-image-16: Prever em Imagens](modes/predict.md){ .md-button }
- **Treinar** um novo modelo YOLOv8 em seu próprio conjunto de dados personalizado &nbsp; [:fontawesome-solid-brain: Treinar um Modelo](modes/train.md){ .md-button }
- **Explorar** tarefas do YOLOv8 como segmentar, classificar, estimar pose e rastrear &nbsp; [:material-magnify-expand: Explorar Tarefas](tasks/index.md){ .md-button }
<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>Assistir:</strong> Como Treinar um Modelo YOLOv8 em Seu Conjunto de Dados Personalizado no <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb" target="_blank">Google Colab</a>.
</p>
## YOLO: Uma Breve História
[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), um popular modelo de detecção de objetos e segmentação de imagens, foi desenvolvido por Joseph Redmon e Ali Farhadi na Universidade de Washington. Lançado em 2015, o YOLO rapidamente ganhou popularidade por sua alta velocidade e precisão.
- [YOLOv2](https://arxiv.org/abs/1612.08242), lançado em 2016, aprimorou o modelo original incorporando normalização em lote, caixas âncora e aglomerados dimensionais.
- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), lançado em 2018, melhorou ainda mais o desempenho do modelo usando uma rede dorsal mais eficiente, múltiplas âncoras e pooling piramidal espacial.
- [YOLOv4](https://arxiv.org/abs/2004.10934) foi lançado em 2020, introduzindo inovações como a ampliação de dados Mosaic, uma nova cabeça de detecção sem âncoras e uma nova função de perda.
- [YOLOv5](https://github.com/ultralytics/yolov5) melhorou ainda mais o desempenho do modelo e adicionou novos recursos, como otimização de hiperparâmetros, rastreamento integrado de experimentos e exportação automática para formatos de exportação populares.
- [YOLOv6](https://github.com/meituan/YOLOv6) foi disponibilizado em código aberto por [Meituan](https://about.meituan.com/) em 2022 e está em uso em muitos dos robôs autônomos de entrega da empresa.
- [YOLOv7](https://github.com/WongKinYiu/yolov7) adicionou tarefas adicionais, como estimativa de pose no conjunto de dados de keypoints COCO.
- [YOLOv8](https://github.com/ultralytics/ultralytics), a mais recente versão do YOLO pela Ultralytics. Como um modelo de última geração, o YOLOv8 baseia-se no sucesso das versões anteriores, introduzindo novos recursos e melhorias para desempenho, flexibilidade e eficiência aprimorados. O YOLOv8 suporta uma gama completa de tarefas de IA de visão, incluindo [detecção](tasks/detect.md), [segmentação](tasks/segment.md), [estimativa de pose](tasks/pose.md), [rastreamento](modes/track.md) e [classificação](tasks/classify.md). Essa versatilidade permite que os usuários aproveitem as capacidades do YOLOv8 em diversas aplicações e domínios.
## Licenças YOLO: Como o YOLO da Ultralytics é licenciado?
A Ultralytics oferece duas opções de licença para acomodar casos de uso diversos:
- **Licença AGPL-3.0**: Essa licença de código aberto [aprovada pela OSI](https://opensource.org/licenses/) é ideal para estudantes e entusiastas, promovendo colaboração aberta e compartilhamento de conhecimento. Veja o arquivo [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) para mais detalhes.
- **Licença Empresarial**: Projetada para uso comercial, esta licença permite a integração perfeita do software Ultralytics e modelos de IA em bens e serviços comerciais, contornando os requisitos de código aberto da AGPL-3.0. Se o seu cenário envolver a incorporação de nossas soluções em uma oferta comercial, entre em contato através do [Licenciamento da Ultralytics](https://ultralytics.com/license).
Nossa estratégia de licenciamento é projetada para garantir que qualquer melhoria em nossos projetos de código aberto retorne à comunidade. Mantemos os princípios de código aberto próximos ao nosso coração ❤️, e nossa missão é garantir que nossas contribuições possam ser utilizadas e expandidas de formas que beneficiem todos.

94
docs/pt/models/index.md Normal file
View file

@ -0,0 +1,94 @@
---
comments: true
description: Explore a diversificada gama de modelos da família YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS e RT-DETR suportados pela Ultralytics. Comece com exemplos de uso tanto para CLI quanto para Python.
keywords: Ultralytics, documentação, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modelos, arquiteturas, Python, CLI
---
# Modelos Suportados pela Ultralytics
Bem-vindo à documentação de modelos da Ultralytics! Oferecemos suporte para uma ampla gama de modelos, cada um adaptado para tarefas específicas como [detecção de objetos](../tasks/detect.md), [segmentação de instâncias](../tasks/segment.md), [classificação de imagens](../tasks/classify.md), [estimativa de pose](../tasks/pose.md) e [rastreamento de múltiplos objetos](../modes/track.md). Se você está interessado em contribuir com sua arquitetura de modelo para a Ultralytics, confira nosso [Guia de Contribuição](../../help/contributing.md).
!!! note
🚧 Nossa documentação multilíngue está atualmente em construção e estamos trabalhando duro para melhorá-la. Obrigado pela sua paciência! 🙏
## Modelos em Destaque
Aqui estão alguns dos principais modelos suportados:
1. **[YOLOv3](../../models/yolov3.md)**: A terceira iteração da família de modelos YOLO, originalmente por Joseph Redmon, conhecida por suas capacidades eficientes de detecção de objetos em tempo real.
2. **[YOLOv4](../../models/yolov4.md)**: Uma atualização nativa do darknet para o YOLOv3, lançada por Alexey Bochkovskiy em 2020.
3. **[YOLOv5](../../models/yolov5.md)**: Uma versão aprimorada da arquitetura YOLO pela Ultralytics, oferecendo melhores trade-offs de desempenho e velocidade comparado às versões anteriores.
4. **[YOLOv6](../../models/yolov6.md)**: Lançado pela [Meituan](https://about.meituan.com/) em 2022, e em uso em muitos dos robôs autônomos de entrega da empresa.
5. **[YOLOv7](../../models/yolov7.md)**: Modelos YOLO atualizados lançados em 2022 pelos autores do YOLOv4.
6. **[YOLOv8](../../models/yolov8.md)**: A versão mais recente da família YOLO, com capacidades aprimoradas como segmentação de instâncias, estimativa de pose/pontos-chave e classificação.
7. **[Segment Anything Model (SAM)](../../models/sam.md)**: Modelo de Segment Everything (SAM) do Meta.
8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)**: MobileSAM para aplicações móveis, pela Universidade Kyung Hee.
9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)**: FastSAM pelo Grupo de Análise de Imagem e Vídeo, Instituto de Automação, Academia Chinesa de Ciências.
10. **[YOLO-NAS](../../models/yolo-nas.md)**: Modelos YOLO de Pesquisa de Arquitetura Neural (NAS).
11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)**: Modelos do Transformer de Detecção em Tempo Real (RT-DETR) da PaddlePaddle da Baidu.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/MWq1UxqTClU?si=nHAW-lYDzrz68jR0"
title="Reprodutor de vídeos do YouTube" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>Assista:</strong> Execute modelos YOLO da Ultralytics em apenas algumas linhas de código.
</p>
## Começando: Exemplos de Uso
!!! example ""
=== "Python"
Modelos `*.pt` pré-treinados com PyTorch, bem como arquivos de configuração `*.yaml`, podem ser passados para as classes `YOLO()`, `SAM()`, `NAS()` e `RTDETR()` para criar uma instância de modelo em Python:
```python
from ultralytics import YOLO
# Carregar um modelo YOLOv8n pré-treinado no COCO
model = YOLO('yolov8n.pt')
# Exibir informações do modelo (opcional)
model.info()
# Treinar o modelo no conjunto de dados de exemplo COCO8 por 100 épocas
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
# Executar inferência com o modelo YOLOv8n na imagem 'bus.jpg'
results = model('path/to/bus.jpg')
```
=== "CLI"
Comandos CLI estão disponíveis para executar diretamente os modelos:
```bash
# Carregar um modelo YOLOv8n pré-treinado no COCO e treiná-lo no conjunto de dados de exemplo COCO8 por 100 épocas
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
# Carregar um modelo YOLOv8n pré-treinado no COCO e executar inferência na imagem 'bus.jpg'
yolo predict model=yolov8n.pt source=path/to/bus.jpg
```
## Contribuindo com Novos Modelos
Interessado em contribuir com o seu modelo para a Ultralytics? Ótimo! Estamos sempre abertos à expansão de nosso portfólio de modelos.
1. **Fork no Repositório**: Comece fazendo um fork do [repositório GitHub da Ultralytics](https://github.com/ultralytics/ultralytics).
2. **Clone o Seu Fork**: Clone o seu fork para a sua máquina local e crie uma nova branch para trabalhar.
3. **Implemente Seu Modelo**: Adicione o seu modelo seguindo os padrões de codificação e diretrizes fornecidos em nosso [Guia de Contribuição](../../help/contributing.md).
4. **Teste Completamente**: Certifique-se de testar seu modelo rigorosamente, isoladamente e como parte do pipeline.
5. **Crie um Pull Request**: Uma vez que esteja satisfeito com seu modelo, crie um pull request para o repositório principal para revisão.
6. **Revisão de Código & Merge**: Após a revisão, se o seu modelo atender os nossos critérios, ele será combinado com o repositório principal.
Para etapas detalhadas, consulte nosso [Guia de Contribuição](../../help/contributing.md).

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

187
docs/pt/quickstart.md Normal file
View file

@ -0,0 +1,187 @@
---
comments: true
description: Explore os diversos métodos para instalar o Ultralytics usando pip, conda, git e Docker. Aprenda a usar o Ultralytics com a interface de linha de comando ou dentro dos seus projetos Python.
keywords: Instalação do Ultralytics, pip install Ultralytics, Docker install Ultralytics, interface de linha de comando do Ultralytics, interface Python do Ultralytics
---
## Instalação do Ultralytics
O Ultralytics oferece diversos métodos de instalação, incluindo pip, conda e Docker. Instale o YOLOv8 através do pacote `ultralytics` pip para a versão estável mais recente ou clonando o [repositório GitHub do Ultralytics](https://github.com/ultralytics/ultralytics) para obter a versão mais atualizada. O Docker pode ser usado para executar o pacote em um contêiner isolado, evitando a instalação local.
!!! example "Instalar"
=== "Pip install (recomendado)"
Instale o pacote `ultralytics` usando pip, ou atualize uma instalação existente executando `pip install -U ultralytics`. Visite o Índice de Pacotes Python (PyPI) para mais detalhes sobre o pacote `ultralytics`: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
[![PyPI version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
```bash
# Instalar o pacote ultralytics do PyPI
pip install ultralytics
```
Você também pode instalar o pacote `ultralytics` diretamente do [repositório](https://github.com/ultralytics/ultralytics) GitHub. Isso pode ser útil se você desejar a versão de desenvolvimento mais recente. Certifique-se de ter a ferramenta de linha de comando Git instalada no seu sistema. O comando `@main` instala a branch `main` e pode ser modificado para outra branch, ou seja, `@my-branch`, ou removido completamente para padrão na branch `main`.
```bash
# Instalar o pacote ultralytics do GitHub
pip install git+https://github.com/ultralytics/ultralytics.git@main
```
=== "Conda install"
Conda é um gerenciador de pacotes alternativo ao pip que também pode ser usado para instalação. Visite Anaconda para mais detalhes em [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). O repositório de feedstock do Ultralytics para atualizar o pacote conda está em [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
[![Conda Recipe](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics)
```bash
# Instalar o pacote ultralytics usando conda
conda install -c conda-forge ultralytics
```
!!! note
Se você está instalando em um ambiente CUDA a prática recomendada é instalar `ultralytics`, `pytorch` e `pytorch-cuda` no mesmo comando para permitir que o gerenciador de pacotes conda resolva quaisquer conflitos, ou instalar `pytorch-cuda` por último para permitir que ele substitua o pacote específico para CPU `pytorch`, se necessário.
```bash
# Instalar todos os pacotes juntos usando conda
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
```
### Imagem Docker Conda
As imagens Docker Conda do Ultralytics também estão disponíveis em [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Estas imagens são baseadas em [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) e são um modo simples de começar a usar `ultralytics` em um ambiente Conda.
```bash
# Definir o nome da imagem como uma variável
t=ultralytics/ultralytics:latest-conda
# Puxar a imagem mais recente do ultralytics do Docker Hub
sudo docker pull $t
# Executar a imagem ultralytics em um contêiner com suporte a GPU
sudo docker run -it --ipc=host --gpus all $t # todas as GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # especificar GPUs
```
=== "Git clone"
Clone o repositório `ultralytics` se você está interessado em contribuir para o desenvolvimento ou deseja experimentar com o código-fonte mais recente. Após clonar, navegue até o diretório e instale o pacote em modo editável `-e` usando pip.
```bash
# Clonar o repositório ultralytics
git clone https://github.com/ultralytics/ultralytics
# Navegar para o diretório clonado
cd ultralytics
# Instalar o pacote em modo editável para desenvolvimento
pip install -e .
```
Veja o arquivo [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) do `ultralytics` para uma lista de dependências. Note que todos os exemplos acima instalam todas as dependências necessárias.
!!! tip "Dica"
Os requisitos do PyTorch variam pelo sistema operacional e pelos requisitos de CUDA, então é recomendado instalar o PyTorch primeiro seguindo as instruções em [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
<a href="https://pytorch.org/get-started/locally/">
<img width="800" alt="Instruções de Instalação do PyTorch" src="https://user-images.githubusercontent.com/26833433/228650108-ab0ec98a-b328-4f40-a40d-95355e8a84e3.png">
</a>
## Use o Ultralytics com CLI
A interface de linha de comando (CLI) do Ultralytics permite comandos simples de uma única linha sem a necessidade de um ambiente Python. O CLI não requer personalização ou código Python. Você pode simplesmente rodar todas as tarefas do terminal com o comando `yolo`. Confira o [Guia CLI](../usage/cli.md) para aprender mais sobre o uso do YOLOv8 pela linha de comando.
!!! example
=== "Sintaxe"
Os comandos `yolo` do Ultralytics usam a seguinte sintaxe:
```bash
yolo TAREFA MODO ARGUMENTOS
Onde TAREFA (opcional) é um entre [detect, segment, classify]
MODO (obrigatório) é um entre [train, val, predict, export, track]
ARGUMENTOS (opcional) são qualquer número de pares personalizados 'arg=valor' como 'imgsz=320' que substituem os padrões.
```
Veja todos os ARGUMENTOS no guia completo de [Configuração](../usage/cfg.md) ou com `yolo cfg`
=== "Train"
Treinar um modelo de detecção por 10 épocas com uma taxa de aprendizado inicial de 0.01
```bash
yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
```
=== "Predict"
Prever um vídeo do YouTube usando um modelo de segmentação pré-treinado com tamanho de imagem 320:
```bash
yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
```
=== "Val"
Validar um modelo de detecção pré-treinado com tamanho de lote 1 e tamanho de imagem 640:
```bash
yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
```
=== "Export"
Exportar um modelo de classificação YOLOv8n para formato ONNX com tamanho de imagem 224 por 128 (nenhuma TAREFA necessária)
```bash
yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
```
=== "Special"
Executar comandos especiais para ver versão, visualizar configurações, rodar verificações e mais:
```bash
yolo help
yolo checks
yolo version
yolo settings
yolo copy-cfg
yolo cfg
```
!!! warning "Aviso"
Argumentos devem ser passados como pares `arg=valor`, separados por um sinal de igual `=` e delimitados por espaços ` ` entre pares. Não use prefixos de argumentos `--` ou vírgulas `,` entre os argumentos.
- `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` &nbsp; ✅
- `yolo predict model yolov8n.pt imgsz 640 conf 0.25` &nbsp; ❌
- `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` &nbsp; ❌
[Guia CLI](../usage/cli.md){ .md-button .md-button--primary}
## Use o Ultralytics com Python
A interface Python do YOLOv8 permite uma integração tranquila em seus projetos Python, tornando fácil carregar, executar e processar a saída do modelo. Projetada com simplicidade e facilidade de uso em mente, a interface Python permite que os usuários implementem rapidamente detecção de objetos, segmentação e classificação em seus projetos. Isto torna a interface Python do YOLOv8 uma ferramenta inestimável para qualquer pessoa buscando incorporar essas funcionalidades em seus projetos Python.
Por exemplo, os usuários podem carregar um modelo, treiná-lo, avaliar o seu desempenho em um conjunto de validação e até exportá-lo para o formato ONNX com apenas algumas linhas de código. Confira o [Guia Python](../usage/python.md) para aprender mais sobre o uso do YOLOv8 dentro dos seus projetos Python.
!!! example
```python
from ultralytics import YOLO
# Criar um novo modelo YOLO do zero
model = YOLO('yolov8n.yaml')
# Carregar um modelo YOLO pré-treinado (recomendado para treinamento)
model = YOLO('yolov8n.pt')
# Treinar o modelo usando o conjunto de dados 'coco128.yaml' por 3 épocas
results = model.train(data='coco128.yaml', epochs=3)
# Avaliar o desempenho do modelo no conjunto de validação
results = model.val()
# Realizar detecção de objetos em uma imagem usando o modelo
results = model('https://ultralytics.com/images/bus.jpg')
# Exportar o modelo para formato ONNX
success = model.export(format='onnx')
```
[Guia Python](../usage/python.md){.md-button .md-button--primary}

172
docs/pt/tasks/classify.md Normal file
View file

@ -0,0 +1,172 @@
---
comments: true
description: Aprenda sobre modelos YOLOv8 Classify para classificação de imagens. Obtenha informações detalhadas sobre Lista de Modelos Pré-treinados e como Treinar, Validar, Prever e Exportar modelos.
keywords: Ultralytics, YOLOv8, Classificação de Imagem, Modelos Pré-treinados, YOLOv8n-cls, Treinamento, Validação, Previsão, Exportação de Modelo
---
# Classificação de Imagens
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418606-adf35c62-2e11-405d-84c6-b84e7d013804.png" alt="Exemplos de classificação de imagens">
A classificação de imagens é a tarefa mais simples das três e envolve classificar uma imagem inteira em uma de um conjunto de classes pré-definidas.
A saída de um classificador de imagem é um único rótulo de classe e uma pontuação de confiança. A classificação de imagem é útil quando você precisa saber apenas a qual classe uma imagem pertence e não precisa conhecer a localização dos objetos dessa classe ou o formato exato deles.
!!! tip "Dica"
Os modelos YOLOv8 Classify usam o sufixo `-cls`, ou seja, `yolov8n-cls.pt` e são pré-treinados na [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
Aqui são mostrados os modelos pré-treinados YOLOv8 Classify. Modelos de Detecção, Segmentação e Pose são pré-treinados no dataset [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), enquanto que os modelos de Classificação são pré-treinados no dataset [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
[Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) são baixados automaticamente do último lançamento da Ultralytics [release](https://github.com/ultralytics/assets/releases) no primeiro uso.
| Modelo | Tamanho<br><sup>(pixels) | acurácia<br><sup>top1 | acurácia<br><sup>top5 | Velocidade<br><sup>CPU ONNX<br>(ms) | Velocidade<br><sup>A100 TensorRT<br>(ms) | parâmetros<br><sup>(M) | FLOPs<br><sup>(B) a 640 |
|----------------------------------------------------------------------------------------------|--------------------------|-----------------------|-----------------------|-------------------------------------|------------------------------------------|------------------------|-------------------------|
| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
- Os valores de **acc** são as acurácias dos modelos no conjunto de validação do dataset [ImageNet](https://www.image-net.org/).
<br>Reproduza com `yolo val classify data=path/to/ImageNet device=0`
- **Velocidade** média observada sobre imagens de validação da ImageNet usando uma instância [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
<br>Reproduza com `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
## Treino
Treine o modelo YOLOv8n-cls no dataset MNIST160 por 100 épocas com tamanho de imagem 64. Para uma lista completa de argumentos disponíveis, veja a página de [Configuração](../../usage/cfg.md).
!!! exemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-cls.yaml') # construir um novo modelo a partir do YAML
model = YOLO('yolov8n-cls.pt') # carregar um modelo pré-treinado (recomendado para treino)
model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construir a partir do YAML e transferir pesos
# Treinar o modelo
results = model.train(data='mnist160', epochs=100, imgsz=64)
```
=== "CLI"
```bash
# Construir um novo modelo a partir do YAML e começar treino do zero
yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
# Começar treino de um modelo pré-treinado *.pt
yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
# Construir um novo modelo do YAML, transferir pesos pré-treinados e começar treino
yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
```
### Formato do dataset
O formato do dataset de classificação YOLO pode ser encontrado em detalhes no [Guia de Datasets](../../datasets/classify/index.md).
## Val
Valide a acurácia do modelo YOLOv8n-cls treinado no dataset MNIST160. Não é necessário passar argumento, pois o `modelo` retém seus dados de treinamento e argumentos como atributos do modelo.
!!! exemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-cls.pt') # carregar um modelo oficial
model = YOLO('path/to/best.pt') # carregar um modelo personalizado
# Validar o modelo
metrics = model.val() # sem argumentos necessários, dataset e configurações lembrados
metrics.top1 # acurácia top1
metrics.top5 # acurácia top5
```
=== "CLI"
```bash
yolo classify val model=yolov8n-cls.pt # validar modelo oficial
yolo classify val model=path/to/best.pt # validar modelo personalizado
```
## Previsão
Use um modelo YOLOv8n-cls treinado para realizar previsões em imagens.
!!! exemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-cls.pt') # carregar um modelo oficial
model = YOLO('path/to/best.pt') # carregar um modelo personalizado
# Prever com o modelo
results = model('https://ultralytics.com/images/bus.jpg') # prever em uma imagem
```
=== "CLI"
```bash
yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # prever com modelo oficial
yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # prever com modelo personalizado
```
Veja detalhes completos do modo de `previsão` na página [Predict](https://docs.ultralytics.com/modes/predict/).
## Exportar
Exporte um modelo YOLOv8n-cls para um formato diferente, como ONNX, CoreML, etc.
!!! exemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-cls.pt') # carregar um modelo oficial
model = YOLO('path/to/best.pt') # carregar um modelo treinado personalizado
# Exportar o modelo
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n-cls.pt format=onnx # exportar modelo oficial
yolo export model=path/to/best.pt format=onnx # exportar modelo treinado personalizado
```
Os formatos de exportação YOLOv8-cls disponíveis estão na tabela abaixo. Você pode prever ou validar diretamente nos modelos exportados, ou seja, `yolo predict model=yolov8n-cls.onnx`. Exemplos de uso são mostrados para seu modelo após a conclusão da exportação.
| Formato | Argumento `format` | Modelo | Metadata | Argumentos |
|--------------------------------------------------------------------|--------------------|-------------------------------|----------|-----------------------------------------------------|
| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - |
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` |
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` |
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` |
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` |
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` |
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` |
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` |
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` |
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` |
Veja detalhes completos da `exportação` na página [Export](https://docs.ultralytics.com/modes/export/).

185
docs/pt/tasks/detect.md Normal file
View file

@ -0,0 +1,185 @@
---
comments: true
description: Documentação oficial do YOLOv8 por Ultralytics. Aprenda como treinar, validar, predizer e exportar modelos em vários formatos. Incluindo estatísticas detalhadas de desempenho.
keywords: YOLOv8, Ultralytics, detecção de objetos, modelos pré-treinados, treinamento, validação, predição, exportação de modelos, COCO, ImageNet, PyTorch, ONNX, CoreML
---
# Detecção de Objetos
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418624-5785cb93-74c9-4541-9179-d5c6782d491a.png" alt="Exemplos de detecção de objetos">
Detecção de objetos é uma tarefa que envolve identificar a localização e a classe de objetos em uma imagem ou fluxo de vídeo.
A saída de um detector de objetos é um conjunto de caixas delimitadoras que cercam os objetos na imagem, junto com rótulos de classe e pontuações de confiança para cada caixa. A detecção de objetos é uma boa escolha quando você precisa identificar objetos de interesse em uma cena, mas não precisa saber exatamente onde o objeto está ou seu formato exato.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/5ku7npMrW40?si=6HQO1dDXunV8gekh"
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> Detecção de Objetos com Modelo Pre-treinado Ultralytics YOLOv8.
</p>
!!! tip "Dica"
Os modelos YOLOv8 Detect são os modelos padrão do YOLOv8, ou seja, `yolov8n.pt` e são pré-treinados no [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
Os modelos pré-treinados YOLOv8 Detect são mostrados aqui. Os modelos Detect, Segment e Pose são pré-treinados no dataset [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), enquanto os modelos Classify são pré-treinados no dataset [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
Os [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) são baixados automaticamente a partir do último lançamento da Ultralytics [release](https://github.com/ultralytics/assets/releases) no primeiro uso.
| Modelo | Tamanho<br><sup>(pixels) | mAP<sup>val<br>50-95 | Velocidade<br><sup>CPU ONNX<br>(ms) | Velocidade<br><sup>A100 TensorRT<br>(ms) | Parâmetros<br><sup>(M) | FLOPs<br><sup>(B) |
|--------------------------------------------------------------------------------------|--------------------------|----------------------|-------------------------------------|------------------------------------------|------------------------|-------------------|
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
- Os valores de **mAP<sup>val</sup>** são para um único modelo e uma única escala no dataset [COCO val2017](http://cocodataset.org).
<br>Reproduza usando `yolo val detect data=coco.yaml device=0`
- A **Velocidade** é média tirada sobre as imagens do COCO val num [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
instância.
<br>Reproduza usando `yolo val detect data=coco128.yaml batch=1 device=0|cpu`
## Treinar
Treine o YOLOv8n no dataset COCO128 por 100 épocas com tamanho de imagem 640. Para uma lista completa de argumentos disponíveis, veja a página [Configuração](../../usage/cfg.md).
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.yaml') # construir um novo modelo pelo YAML
model = YOLO('yolov8n.pt') # carregar um modelo pré-treinado (recomendado para treinamento)
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construir pelo YAML e transferir pesos
# Treinar o modelo
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
```
=== "CLI"
```bash
# Construir um novo modelo pelo 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 pré-treinado *.pt
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
# Construir um novo modelo pelo YAML, transferir pesos pré-treinados e começar o treinamento
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
```
### Formato do Dataset
O formato do dataset de detecção do YOLO pode ser encontrado em detalhes no [Guia de Datasets](../../datasets/detect/index.md). Para converter seu dataset existente de outros formatos (como COCO, etc.) para o formato YOLO, por favor utilize a ferramenta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) da Ultralytics.
## Validar
Valide a precisão do modelo YOLOv8n treinado no dataset COCO128. Não é necessário passar nenhum argumento, pois o `modelo` mantém seus `dados` de treino e argumentos como atributos do modelo.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.pt') # carregar um modelo oficial
model = YOLO('caminho/para/best.pt') # carregar um modelo personalizado
# Validar o modelo
metrics = model.val() # sem a necessidade de argumentos, dataset e configurações lembradas
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 # validação do modelo oficial
yolo detect val model=caminho/para/best.pt # validação do modelo personalizado
```
## Predizer
Use um modelo YOLOv8n treinado para fazer predições em imagens.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.pt') # carregar um modelo oficial
model = YOLO('caminho/para/best.pt') # carregar um modelo personalizado
# Predizer com o modelo
results = model('https://ultralytics.com/images/bus.jpg') # predizer em uma imagem
```
=== "CLI"
```bash
yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # predizer com modelo oficial
yolo detect predict model=caminho/para/best.pt source='https://ultralytics.com/images/bus.jpg' # predizer com modelo personalizado
```
Veja os detalhes completos do modo `predict` na página [Predição](https://docs.ultralytics.com/modes/predict/).
## Exportar
Exporte um modelo YOLOv8n para um formato diferente, como ONNX, CoreML, etc.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n.pt') # carregar um modelo oficial
model = YOLO('caminho/para/best.pt') # carregar um modelo treinado personalizado
# Exportar o modelo
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n.pt format=onnx # exportar modelo oficial
yolo export model=caminho/para/best.pt format=onnx # exportar modelo treinado personalizado
```
Os formatos de exportação YOLOv8 disponíveis estão na tabela abaixo. Você pode fazer predições ou validar diretamente em modelos exportados, ou seja, `yolo predict model=yolov8n.onnx`. Exemplos de uso são mostrados para o seu modelo após a exportação ser concluída.
| 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` |
Veja os detalhes completos de `exportar` na página [Exportação](https://docs.ultralytics.com/modes/export/).

55
docs/pt/tasks/index.md Normal file
View file

@ -0,0 +1,55 @@
---
comments: true
description: Aprenda sobre as principais tarefas de visão computacional que o YOLOv8 pode realizar, incluindo detecção, segmentação, classificação e estimativa de pose. Entenda seus usos em seus projetos de IA.
keywords: Ultralytics, YOLOv8, Detecção, Segmentação, Classificação, Estimativa de Pose, Framework de IA, Tarefas de Visão Computacional
---
# Tarefas do Ultralytics YOLOv8
<br>
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png" alt="Tarefas suportadas pelo Ultralytics YOLO">
YOLOv8 é um framework de IA que suporta múltiplas tarefas de **visão computacional**. O framework pode ser usado para realizar [detecção](detect.md), [segmentação](segment.md), [classificação](classify.md) e estimativa de [pose](pose.md). Cada uma dessas tarefas tem um objetivo e caso de uso diferente.
!!! note
🚧 Nossa documentação multilíngue está atualmente em construção e estamos trabalhando para aprimorá-la. Agradecemos sua paciência! 🙏
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/NAs-cfq9BDw"
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> Explore as Tarefas do Ultralytics YOLO: Detecção de Objetos, Segmentação, Rastreamento e Estimativa de Pose.
</p>
## [Detecção](detect.md)
A detecção é a principal tarefa suportada pelo YOLOv8. Envolve detectar objetos em uma imagem ou quadro de vídeo e desenhar caixas delimitadoras ao redor deles. Os objetos detectados são classificados em diferentes categorias com base em suas características. YOLOv8 pode detectar múltiplos objetos em uma única imagem ou quadro de vídeo com alta precisão e velocidade.
[Exemplos de Detecção](detect.md){ .md-button .md-button--primary}
## [Segmentação](segment.md)
Segmentação é uma tarefa que envolve segmentar uma imagem em diferentes regiões com base no conteúdo da imagem. Cada região recebe um rótulo com base em seu conteúdo. Essa tarefa é útil em aplicações como segmentação de imagens e imagiologia médica. YOLOv8 usa uma variante da arquitetura U-Net para realizar a segmentação.
[Exemplos de Segmentação](segment.md){ .md-button .md-button--primary}
## [Classificação](classify.md)
Classificação é uma tarefa que envolve classificar uma imagem em diferentes categorias. YOLOv8 pode ser usado para classificar imagens com base em seu conteúdo. Utiliza uma variante da arquitetura EfficientNet para realizar a classificação.
[Exemplos de Classificação](classify.md){ .md-button .md-button--primary}
## [Pose](pose.md)
A detecção de pose/pontos-chave é uma tarefa que envolve detectar pontos específicos em uma imagem ou quadro de vídeo. Esses pontos são chamados de keypoints e são usados para rastrear movimento ou estimar poses. YOLOv8 pode detectar keypoints em uma imagem ou quadro de vídeo com alta precisão e velocidade.
[Exemplos de Pose](pose.md){ .md-button .md-button--primary}
## Conclusão
YOLOv8 suporta múltiplas tarefas, incluindo detecção, segmentação, classificação e detecção de keypoints. Cada uma dessas tarefas tem objetivos e casos de uso diferentes. Ao entender as diferenças entre essas tarefas, você pode escolher a tarefa apropriada para sua aplicação de visão computacional.

188
docs/pt/tasks/pose.md Normal file
View file

@ -0,0 +1,188 @@
---
comments: true
description: Aprenda a usar o Ultralytics YOLOv8 para tarefas de estimativa de pose. Encontre modelos pré-treinados, aprenda a treinar, validar, prever e exportar seu próprio modelo.
keywords: Ultralytics, YOLO, YOLOv8, estimativa de pose, detecção de pontos-chave, detecção de objetos, modelos pré-treinados, aprendizado de máquina, inteligência artificial
---
# Estimativa de Pose
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png" alt="Exemplos de estimativa de pose">
A estimativa de pose é uma tarefa que envolve identificar a localização de pontos específicos em uma imagem, geralmente referidos como pontos-chave. Os pontos-chave podem representar várias partes do objeto como articulações, pontos de referência ou outras características distintas. As localizações dos pontos-chave são geralmente representadas como um conjunto de coordenadas 2D `[x, y]` ou 3D `[x, y, visível]`.
A saída de um modelo de estimativa de pose é um conjunto de pontos que representam os pontos-chave em um objeto na imagem, geralmente junto com os escores de confiança para cada ponto. A estimativa de pose é uma boa escolha quando você precisa identificar partes específicas de um objeto em uma cena, e sua localização relativa entre si.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ"
title="Reprodutor de vídeo YouTube" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>Assista:</strong> Estimativa de Pose com Ultralytics YOLOv8.
</p>
!!! tip "Dica"
Modelos YOLOv8 _pose_ usam o sufixo `-pose`, isto é `yolov8n-pose.pt`. Esses modelos são treinados no conjunto de dados [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) e são adequados para uma variedade de tarefas de estimativa de pose.
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
Os modelos YOLOv8 Pose pré-treinados são mostrados aqui. Os modelos Detect, Segment e Pose são pré-treinados no conjunto de dados [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), enquanto os modelos Classify são pré-treinados no conjunto de dados [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
[Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) são baixados automaticamente do último lançamento da Ultralytics [release](https://github.com/ultralytics/assets/releases) no primeiro uso.
| Modelo | tamanho<br><sup>(pixels) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | Velocidade<br><sup>CPU ONNX<br>(ms) | Velocidade<br><sup>A100 TensorRT<br>(ms) | parâmetros<br><sup>(M) | FLOPs<br><sup>(B) |
|------------------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------|-------------------------------------|------------------------------------------|------------------------|-------------------|
| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
- **mAP<sup>val</sup>** valores são para um único modelo em escala única no conjunto de dados [COCO Keypoints val2017](http://cocodataset.org)
.
<br>Reproduza `yolo val pose data=coco-pose.yaml device=0`
- **Velocidade** média em imagens COCO val usando uma instância [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
.
<br>Reproduza `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`
## Treinar
Treine um modelo YOLOv8-pose no conjunto de dados COCO128-pose.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-pose.yaml') # construir um novo modelo a partir do YAML
model = YOLO('yolov8n-pose.pt') # carregar um modelo pré-treinado (recomendado para treinamento)
model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # construir a partir do YAML e transferir pesos
# Treinar o modelo
results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
```
=== "CLI"
```bash
# Construir um novo modelo a partir do YAML e começar o treinamento do zero
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
# Começar treinamento de um modelo *.pt pré-treinado
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.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 pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
```
### Formato do conjunto de dados
O formato do conjunto de dados de pose YOLO pode ser encontrado em detalhes no [Guia de Conjuntos de Dados](../../datasets/pose/index.md). Para converter seu conjunto de dados existente de outros formatos (como COCO etc.) para o formato YOLO, por favor, use a ferramenta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) da Ultralytics.
## Validar
Valide a acurácia do modelo YOLOv8n-pose treinado no conjunto de dados COCO128-pose. Não é necessário passar nenhum argumento, pois o `model`
retém seus `data` de treinamento e argumentos como atributos do modelo.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-pose.pt') # carregar um modelo oficial
model = YOLO('caminho/para/melhor.pt') # carregar um modelo personalizado
# Validar o modelo
metrics = model.val() # nenhum argumento necessário, conjunto de dados e configurações lembradas
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 pose val model=yolov8n-pose.pt # validar modelo oficial
yolo pose val model=caminho/para/melhor.pt # validar modelo personalizado
```
## Prever
Use um modelo YOLOv8n-pose treinado para executar previsões em imagens.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-pose.pt') # carregar um modelo oficial
model = YOLO('caminho/para/melhor.pt') # carregar um modelo personalizado
# Prever com o modelo
results = model('https://ultralytics.com/images/bus.jpg') # prever em uma imagem
```
=== "CLI"
```bash
yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # prever com modelo oficial
yolo pose predict model=caminho/para/melhor.pt source='https://ultralytics.com/images/bus.jpg' # prever com modelo personalizado
```
Veja detalhes completos do modo `predict` na página [Prever](https://docs.ultralytics.com/modes/predict/).
## Exportar
Exporte um modelo YOLOv8n Pose para um formato diferente como ONNX, CoreML, etc.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-pose.pt') # carregar um modelo oficial
model = YOLO('caminho/para/melhor.pt') # carregar um modelo treinado personalizado
# Exportar o modelo
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n-pose.pt format=onnx # exportar modelo oficial
yolo export model=caminho/para/melhor.pt format=onnx # exportar modelo treinado personalizado
```
Os formatos de exportação YOLOv8-pose disponíveis estão na tabela abaixo. Você pode prever ou validar diretamente em modelos exportados, ou seja, `yolo predict model=yolov8n-pose.onnx`. Exemplos de uso são mostrados para o seu modelo após a conclusão da exportação.
| Formato | Argumento `format` | Modelo | Metadados | Argumentos |
|--------------------------------------------------------------------|--------------------|--------------------------------|-----------|-----------------------------------------------------|
| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - |
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` |
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` |
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` |
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` |
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `half`, `int8` |
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` |
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` |
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` |
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` |
Veja detalhes completos da `exportação` na página [Exportar](https://docs.ultralytics.com/modes/export/).

188
docs/pt/tasks/segment.md Normal file
View file

@ -0,0 +1,188 @@
---
comments: true
description: Aprenda a usar modelos de segmentação de instâncias com o Ultralytics YOLO. Instruções sobre treinamento, validação, previsão de imagem e exportação de modelo.
keywords: yolov8, segmentação de instâncias, Ultralytics, conjunto de dados COCO, segmentação de imagem, detecção de objeto, treinamento de modelo, validação de modelo, previsão de imagem, exportação de modelo
---
# Segmentação de Instâncias
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418644-7df320b8-098d-47f1-85c5-26604d761286.png" alt="Exemplos de segmentação de instâncias">
A segmentação de instâncias vai além da detecção de objetos e envolve a identificação de objetos individuais em uma imagem e a sua segmentação do resto da imagem.
A saída de um modelo de segmentação de instâncias é um conjunto de máscaras ou contornos que delineiam cada objeto na imagem, juntamente com rótulos de classe e pontuações de confiança para cada objeto. A segmentação de instâncias é útil quando você precisa saber não apenas onde os objetos estão em uma imagem, mas também qual é a forma exata deles.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/o4Zd-IeMlSY?si=37nusCzDTd74Obsp"
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> Executar Segmentação com o Modelo Treinado Ultralytics YOLOv8 em Python.
</p>
!!! tip "Dica"
Modelos YOLOv8 Segment usam o sufixo `-seg`, ou seja, `yolov8n-seg.pt` e são pré-treinados no [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
Os modelos Segment pré-treinados do YOLOv8 estão mostrados aqui. Os modelos Detect, Segment e Pose são pré-treinados no conjunto de dados [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), enquanto os modelos Classify são pré-treinados no conjunto de dados [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
[Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) são baixados automaticamente do último lançamento da Ultralytics [release](https://github.com/ultralytics/assets/releases) na primeira utilização.
| Modelo | Tamanho<br><sup>(pixels) | mAP<sup>box<br>50-95 | mAP<sup>máscara<br>50-95 | Velocidade<br><sup>CPU ONNX<br>(ms) | Velocidade<br><sup>A100 TensorRT<br>(ms) | Parâmetros<br><sup>(M) | FLOPs<br><sup>(B) |
|----------------------------------------------------------------------------------------------|--------------------------|----------------------|--------------------------|-------------------------------------|------------------------------------------|------------------------|-------------------|
| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
- Os valores de **mAP<sup>val</sup>** são para um único modelo em uma única escala no conjunto de dados [COCO val2017](http://cocodataset.org).
<br>Reproduza por meio de `yolo val segment data=coco.yaml device=0`
- **Velocidade** média em imagens COCO val usando uma instância [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
<br>Reproduza por meio de `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu`
## Treinar
Treine o modelo YOLOv8n-seg no conjunto de dados COCO128-seg por 100 épocas com tamanho de imagem 640. Para uma lista completa de argumentos disponíveis, consulte a página [Configuração](../../usage/cfg.md).
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-seg.yaml') # construir um novo modelo a partir do YAML
model = YOLO('yolov8n-seg.pt') # carregar um modelo pré-treinado (recomendado para treinamento)
model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # construir a partir do YAML e transferir os pesos
# Treinar o modelo
results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
```
=== "CLI"
```bash
# Construir um novo modelo a partir do YAML e começar o treinamento do zero
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
# Começar o treinamento a partir de um modelo *.pt pré-treinado
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.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 segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
```
### Formato do conjunto de dados
O formato do conjunto de dados de segmentação YOLO pode ser encontrado em detalhes no [Guia de Conjuntos de Dados](../../datasets/segment/index.md). Para converter seu conjunto de dados existente de outros formatos (como COCO etc.) para o formato YOLO, utilize a ferramenta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) da Ultralytics.
## Val
Valide a acurácia do modelo YOLOv8n-seg treinado no conjunto de dados COCO128-seg. Não é necessário passar nenhum argumento, pois o `modelo` retém seus `dados` de treino e argumentos como atributos do modelo.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-seg.pt') # carregar um modelo oficial
model = YOLO('path/to/best.pt') # carregar um modelo personalizado
# Validar o modelo
metrics = model.val() # sem necessidade de argumentos, conjunto de dados e configurações são lembrados
metrics.box.map # map50-95(B)
metrics.box.map50 # map50(B)
metrics.box.map75 # map75(B)
metrics.box.maps # uma lista contendo map50-95(B) de cada categoria
metrics.seg.map # map50-95(M)
metrics.seg.map50 # map50(M)
metrics.seg.map75 # map75(M)
metrics.seg.maps # uma lista contendo map50-95(M) de cada categoria
```
=== "CLI"
```bash
yolo segment val model=yolov8n-seg.pt # val modelo oficial
yolo segment val model=path/to/best.pt # val modelo personalizado
```
## Prever
Use um modelo YOLOv8n-seg treinado para realizar previsões em imagens.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-seg.pt') # carregar um modelo oficial
model = YOLO('path/to/best.pt') # carregar um modelo personalizado
# Realizar previsão com o modelo
results = model('https://ultralytics.com/images/bus.jpg') # prever em uma imagem
```
=== "CLI"
```bash
yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # previsão com modelo oficial
yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # previsão com modelo personalizado
```
Veja detalhes completos do modo `predict` na página [Prever](https://docs.ultralytics.com/modes/predict/).
## Exportar
Exporte um modelo YOLOv8n-seg para um formato diferente como ONNX, CoreML, etc.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carregar um modelo
model = YOLO('yolov8n-seg.pt') # carregar um modelo oficial
model = YOLO('path/to/best.pt') # carregar um modelo treinado personalizado
# Exportar o modelo
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n-seg.pt format=onnx # exportar modelo oficial
yolo export model=path/to/best.pt format=onnx # exportar modelo treinado personalizado
```
Os formatos de exportação disponíveis para YOLOv8-seg estão na tabela abaixo. Você pode prever ou validar diretamente em modelos exportados, ou seja, `yolo predict model=yolov8n-seg.onnx`. Exemplos de uso são mostrados para o seu modelo após a conclusão da exportação.
| Formato | Argumento `format` | Modelo | Metadados | Argumentos |
|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------|
| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - |
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` |
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` |
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` |
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` |
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `half`, `int8` |
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` |
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` |
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` |
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` |
Veja detalhes completos da `exportação` na página [Exportar](https://docs.ultralytics.com/modes/export/).