Update https://docs.ultralytics.com/models (#6513)
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
GitHub
parent
0c4e97443b
commit
16a13a1ce0
178 changed files with 14224 additions and 561 deletions
193
docs/pt/models/fast-sam.md
Normal file
193
docs/pt/models/fast-sam.md
Normal file
|
|
@ -0,0 +1,193 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore o FastSAM, uma solução baseada em CNN para segmentação em tempo real de objetos em imagens. Melhor interação do usuário, eficiência computacional e adaptabilidade em tarefas de visão.
|
||||
keywords: FastSAM, aprendizado de máquina, solução baseada em CNN, segmentação de objetos, solução em tempo real, Ultralytics, tarefas de visão, processamento de imagens, aplicações industriais, interação do usuário
|
||||
---
|
||||
|
||||
# Fast Segment Anything Model (FastSAM)
|
||||
|
||||
O Fast Segment Anything Model (FastSAM) é uma solução inovadora baseada em CNN em tempo real para a tarefa de Segmentar Qualquer Coisa. Essa tarefa foi projetada para segmentar qualquer objeto dentro de uma imagem com base em várias possíveis instruções de interação do usuário. O FastSAM reduz significativamente as demandas computacionais, mantendo um desempenho competitivo, tornando-o uma escolha prática para uma variedade de tarefas de visão.
|
||||
|
||||
|
||||
|
||||
## Visão Geral
|
||||
|
||||
O FastSAM é projetado para abordar as limitações do [Segment Anything Model (SAM)](sam.md), um modelo Transformer pesado com requisitos substanciais de recursos computacionais. O FastSAM divide a tarefa de segmentar qualquer coisa em duas etapas sequenciais: segmentação de todas as instâncias e seleção guiada por instruções. A primeira etapa usa o [YOLOv8-seg](../tasks/segment.md) para produzir as máscaras de segmentação de todas as instâncias na imagem. Na segunda etapa, ele gera a região de interesse correspondente à instrução.
|
||||
|
||||
## Recursos Principais
|
||||
|
||||
1. **Solução em Tempo Real:** Aproveitando a eficiência computacional das CNNs, o FastSAM fornece uma solução em tempo real para a tarefa de segmentar qualquer coisa, tornando-o valioso para aplicações industriais que exigem resultados rápidos.
|
||||
|
||||
2. **Eficiência e Desempenho:** O FastSAM oferece uma redução significativa nas demandas computacionais e de recursos sem comprometer a qualidade do desempenho. Ele alcança um desempenho comparável ao SAM, mas com recursos computacionais drasticamente reduzidos, permitindo aplicações em tempo real.
|
||||
|
||||
3. **Segmentação Guiada por Instruções:** O FastSAM pode segmentar qualquer objeto dentro de uma imagem com base em várias possíveis instruções de interação do usuário, proporcionando flexibilidade e adaptabilidade em diferentes cenários.
|
||||
|
||||
4. **Baseado em YOLOv8-seg:** O FastSAM é baseado no [YOLOv8-seg](../tasks/segment.md), um detector de objetos equipado com um ramo de segmentação de instâncias. Isso permite que ele produza efetivamente as máscaras de segmentação de todas as instâncias em uma imagem.
|
||||
|
||||
5. **Resultados Competitivos em Bancos de Dados de Referência:** Na tarefa de proposta de objetos no MS COCO, o FastSAM alcança pontuações altas em uma velocidade significativamente mais rápida do que o [SAM](sam.md) em uma única NVIDIA RTX 3090, demonstrando sua eficiência e capacidade.
|
||||
|
||||
6. **Aplicações Práticas:** A abordagem proposta fornece uma nova solução prática para um grande número de tarefas de visão em alta velocidade, dezenas ou centenas de vezes mais rápido do que os métodos atuais.
|
||||
|
||||
7. **Viabilidade de Compressão do Modelo:** O FastSAM demonstra a viabilidade de um caminho que pode reduzir significativamente o esforço computacional, introduzindo uma prioridade artificial à estrutura, abrindo assim novas possibilidades para arquiteturas de modelos grandes para tarefas gerais de visão.
|
||||
|
||||
## Modelos Disponíveis, Tarefas Suportadas e Modos de Operação
|
||||
|
||||
Esta tabela apresenta os modelos disponíveis com seus pesos pré-treinados específicos, as tarefas que eles suportam e sua compatibilidade com diferentes modos de operação, como [Inferência](../modes/predict.md), [Validação](../modes/val.md), [Treinamento](../modes/train.md) e [Exportação](../modes/export.md), indicados por emojis ✅ para modos suportados e emojis ❌ para modos não suportados.
|
||||
|
||||
| Tipo de Modelo | Pesos Pré-treinados | Tarefas Suportadas | Inferência | Validação | Treinamento | Exportação |
|
||||
|----------------|---------------------|--------------------------------------------------|------------|-----------|-------------|------------|
|
||||
| FastSAM-s | `FastSAM-s.pt` | [Segmentação de Instâncias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
| FastSAM-x | `FastSAM-x.pt` | [Segmentação de Instâncias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
Os modelos FastSAM são fáceis de integrar em suas aplicações Python. A Ultralytics fornece uma API Python amigável ao usuário e comandos de linha de comando (CLI) para facilitar o desenvolvimento.
|
||||
|
||||
### Uso de Predição
|
||||
|
||||
Para realizar detecção de objetos em uma imagem, use o método `predict` conforme mostrado abaixo:
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import FastSAM
|
||||
from ultralytics.models.fastsam import FastSAMPrompt
|
||||
|
||||
# Definir uma fonte de inferência
|
||||
source = 'caminho/para/onibus.jpg'
|
||||
|
||||
# Criar um modelo FastSAM
|
||||
model = FastSAM('FastSAM-s.pt') # ou FastSAM-x.pt
|
||||
|
||||
# Executar inferência em uma imagem
|
||||
everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
|
||||
|
||||
# Preparar um objeto de Processo de Instruções
|
||||
prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
|
||||
|
||||
# Instrução: tudo
|
||||
ann = prompt_process.everything_prompt()
|
||||
|
||||
# Forma padrão (bbox) [0,0,0,0] -> [x1,y1,x2,y2]
|
||||
ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
|
||||
|
||||
# Instrução: texto
|
||||
ann = prompt_process.text_prompt(text='uma foto de um cachorro')
|
||||
|
||||
# Instrução: ponto
|
||||
# pontos padrão [[0,0]] [[x1,y1],[x2,y2]]
|
||||
# ponto_label padrão [0] [1,0] 0:fundo, 1:frente
|
||||
ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
|
||||
prompt_process.plot(annotations=ann, output='./')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
```bash
|
||||
# Carregar um modelo FastSAM e segmentar tudo com ele
|
||||
yolo segment predict model=FastSAM-s.pt source=caminho/para/onibus.jpg imgsz=640
|
||||
```
|
||||
|
||||
Este trecho de código demonstra a simplicidade de carregar um modelo pré-treinado e executar uma predição em uma imagem.
|
||||
|
||||
### Uso de Validação
|
||||
|
||||
A validação do modelo em um conjunto de dados pode ser feita da seguinte forma:
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import FastSAM
|
||||
|
||||
# Criar um modelo FastSAM
|
||||
model = FastSAM('FastSAM-s.pt') # ou FastSAM-x.pt
|
||||
|
||||
# Validar o modelo
|
||||
results = model.val(data='coco8-seg.yaml')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
```bash
|
||||
# Carregar um modelo FastSAM e validá-lo no conjunto de dados de exemplo COCO8 com tamanho de imagem 640
|
||||
yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
|
||||
```
|
||||
|
||||
Observe que o FastSAM suporta apenas detecção e segmentação de uma única classe de objeto. Isso significa que ele reconhecerá e segmentará todos os objetos como a mesma classe. Portanto, ao preparar o conjunto de dados, você precisará converter todos os IDs de categoria de objeto para 0.
|
||||
|
||||
## Uso Oficial do FastSAM
|
||||
|
||||
O FastSAM também está disponível diretamente no repositório [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM). Aqui está uma visão geral breve das etapas típicas que você pode seguir para usar o FastSAM:
|
||||
|
||||
### Instalação
|
||||
|
||||
1. Clone o repositório do FastSAM:
|
||||
```shell
|
||||
git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
|
||||
```
|
||||
|
||||
2. Crie e ative um ambiente Conda com Python 3.9:
|
||||
```shell
|
||||
conda create -n FastSAM python=3.9
|
||||
conda activate FastSAM
|
||||
```
|
||||
|
||||
3. Navegue até o repositório clonado e instale os pacotes necessários:
|
||||
```shell
|
||||
cd FastSAM
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
4. Instale o modelo CLIP:
|
||||
```shell
|
||||
pip install git+https://github.com/openai/CLIP.git
|
||||
```
|
||||
|
||||
### Exemplo de Uso
|
||||
|
||||
1. Baixe um [checkpoint do modelo](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing).
|
||||
|
||||
2. Use o FastSAM para inferência. Exemplos de comandos:
|
||||
|
||||
- Segmentar tudo em uma imagem:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
|
||||
```
|
||||
|
||||
- Segmentar objetos específicos usando uma instrução de texto:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "o cachorro amarelo"
|
||||
```
|
||||
|
||||
- Segmentar objetos dentro de uma caixa delimitadora (fornecer coordenadas da caixa no formato xywh):
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
|
||||
```
|
||||
|
||||
- Segmentar objetos próximos a pontos específicos:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
|
||||
```
|
||||
|
||||
Além disso, você pode experimentar o FastSAM através de um [demo no Colab](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) ou no [demo web do HuggingFace](https://huggingface.co/spaces/An-619/FastSAM) para ter uma experiência visual.
|
||||
|
||||
## Citações e Reconhecimentos
|
||||
|
||||
Gostaríamos de reconhecer os autores do FastSAM por suas contribuições significativas no campo da segmentação de instâncias em tempo real:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{zhao2023fast,
|
||||
title={Fast Segment Anything},
|
||||
author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
|
||||
year={2023},
|
||||
eprint={2306.12156},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
O artigo original do FastSAM pode ser encontrado no [arXiv](https://arxiv.org/abs/2306.12156). Os autores disponibilizaram seu trabalho publicamente, e o código pode ser acessado no [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). Agradecemos seus esforços em avançar o campo e tornar seu trabalho acessível à comunidade em geral.
|
||||
|
|
@ -1,37 +1,37 @@
|
|||
---
|
||||
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.
|
||||
description: Explore a ampla gama de modelos da família YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS e RT-DETR suportados pela Ultralytics. Comece com exemplos para uso tanto em CLI quanto em 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).
|
||||
Bem-vindo à documentação de modelos da Ultralytics! Oferecemos suporte para uma ampla variedade 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ê tem interesse em contribuir com sua arquitetura de modelo para a Ultralytics, confira nosso [Guia de Contribuição](../../help/contributing.md).
|
||||
|
||||
!!! Note "Nota"
|
||||
|
||||
🚧 Nossa documentação multilíngue está atualmente em construção e estamos trabalhando duro para melhorá-la. Obrigado pela sua paciência! 🙏
|
||||
🚧 Nossa documentação em vários idiomas está atualmente em construção, e estamos trabalhando arduamente para melhorá-la. Agradecemos 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.
|
||||
1. **[YOLOv3](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](yolov4.md)**: Uma atualização nativa para o darknet do YOLOv3, lançada por Alexey Bochkovskiy em 2020.
|
||||
3. **[YOLOv5](yolov5.md)**: Uma versão aprimorada da arquitetura YOLO pela Ultralytics, oferecendo melhor desempenho e compensações de velocidade em comparação com as versões anteriores.
|
||||
4. **[YOLOv6](yolov6.md)**: Lançado pela [Meituan](https://about.meituan.com/) em 2022, e em uso em muitos dos robôs autônomos de entregas da empresa.
|
||||
5. **[YOLOv7](yolov7.md)**: Modelos YOLO atualizados lançados em 2022 pelos autores do YOLOv4.
|
||||
6. **[YOLOv8](yolov8.md) NOVO 🚀**: A versão mais recente da família YOLO, apresentando capacidades aprimoradas, como segmentação de instâncias, estimativa de pose/pontos-chave e classificação.
|
||||
7. **[Segment Anything Model (SAM)](sam.md)**: Modelo Segment Anything (SAM) da Meta.
|
||||
8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: MobileSAM para aplicações móveis, pela Universidade Kyung Hee.
|
||||
9. **[Fast Segment Anything Model (FastSAM)](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](yolo-nas.md)**: Modelos de Pesquisa de Arquitetura Neural YOLO (NAS).
|
||||
11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)**: Modelos de Transformador de Detecção em Tempo Real (RT-DETR) do 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"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
|
|
@ -39,28 +39,32 @@ Aqui estão alguns dos principais modelos suportados:
|
|||
<strong>Assista:</strong> Execute modelos YOLO da Ultralytics em apenas algumas linhas de código.
|
||||
</p>
|
||||
|
||||
## Começando: Exemplos de Uso
|
||||
## Introdução: Exemplos de Uso
|
||||
|
||||
Este exemplo oferece exemplos simples de treinamento e inferência com YOLO. Para uma documentação completa sobre estes e outros [modos](../modes/index.md), veja as páginas de documentação de [Previsão](../modes/predict.md), [Treinamento](../modes/train.md), [Validação](../modes/val.md) e [Exportação](../modes/export.md).
|
||||
|
||||
Note que o exemplo abaixo é para modelos YOLOv8 [Detect](../tasks/detect.md) para detecção de objetos. Para tarefas suportadas adicionais, veja as documentações de [Segmentação](../tasks/segment.md), [Classificação](../tasks/classify.md) e [Pose](../tasks/pose.md).
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "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:
|
||||
Modelos `*.pt` pré-treinados em 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')
|
||||
modelo = YOLO('yolov8n.pt')
|
||||
|
||||
# Exibir informações do modelo (opcional)
|
||||
model.info()
|
||||
modelo.info()
|
||||
|
||||
# Treinar o modelo no conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
resultados = modelo.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')
|
||||
resultados = modelo('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
|
@ -77,18 +81,18 @@ Aqui estão alguns dos principais modelos suportados:
|
|||
|
||||
## 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.
|
||||
Interessado em contribuir com seu modelo para a Ultralytics? Ótimo! Estamos sempre abertos a expandir 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).
|
||||
1. **Fork do Repositório**: Comece fazendo um fork do [repositório no 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.
|
||||
2. **Clone Seu Fork**: Clone 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).
|
||||
3. **Implemente Seu Modelo**: Adicione seu modelo seguindo as normas e diretrizes de codificação fornecidas no nosso [Guia de Contribuição](../../help/contributing.md).
|
||||
|
||||
4. **Teste Completamente**: Certifique-se de testar seu modelo rigorosamente, isoladamente e como parte do pipeline.
|
||||
4. **Teste Cuidadosamente**: Assegure-se de testar seu modelo rigorosamente, tanto isoladamente quanto 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.
|
||||
5. **Crie um Pull Request**: Uma vez que estiver 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.
|
||||
6. **Revisão de Código & Mesclagem**: Após a revisão, se seu modelo atender aos nossos critérios, ele será integrado ao repositório principal.
|
||||
|
||||
Para etapas detalhadas, consulte nosso [Guia de Contribuição](../../help/contributing.md).
|
||||
|
|
|
|||
116
docs/pt/models/mobile-sam.md
Normal file
116
docs/pt/models/mobile-sam.md
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
---
|
||||
comments: true
|
||||
description: Saiba mais sobre o MobileSAM, sua implementação, comparação com o SAM original e como baixá-lo e testá-lo no framework Ultralytics. Melhore suas aplicações móveis hoje.
|
||||
keywords: MobileSAM, Ultralytics, SAM, aplicações móveis, Arxiv, GPU, API, codificador de imagens, decodificador de máscaras, download do modelo, método de teste
|
||||
---
|
||||
|
||||
|
||||
|
||||
# Segmentação Móvel de Qualquer Coisa (MobileSAM)
|
||||
|
||||
O artigo do MobileSAM agora está disponível no [arXiv](https://arxiv.org/pdf/2306.14289.pdf).
|
||||
|
||||
Uma demonstração do MobileSAM executando em uma CPU pode ser acessada neste [link de demonstração](https://huggingface.co/spaces/dhkim2810/MobileSAM). O desempenho em um Mac i5 CPU leva aproximadamente 3 segundos. Na demonstração do Hugging Face, a interface e CPUs de menor desempenho contribuem para uma resposta mais lenta, mas ela continua funcionando efetivamente.
|
||||
|
||||
O MobileSAM é implementado em vários projetos, incluindo [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling) e [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D).
|
||||
|
||||
O MobileSAM é treinado em uma única GPU com um conjunto de dados de 100 mil imagens (1% das imagens originais) em menos de um dia. O código para esse treinamento será disponibilizado no futuro.
|
||||
|
||||
## Modelos Disponíveis, Tarefas Suportadas e Modos de Operação
|
||||
|
||||
Esta tabela apresenta os modelos disponíveis com seus pesos pré-treinados específicos, as tarefas que eles suportam e sua compatibilidade com diferentes modos de operação, como [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) e [Export](../modes/export.md), indicados pelos emojis ✅ para os modos suportados e ❌ para os modos não suportados.
|
||||
|
||||
| Tipo de Modelo | Pesos Pré-treinados | Tarefas Suportadas | Inference | Validation | Training | Export |
|
||||
|----------------|---------------------|--------------------------------------------------|-----------|------------|----------|--------|
|
||||
| MobileSAM | `mobile_sam.pt` | [Segmentação de Instâncias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## Adaptação de SAM para MobileSAM
|
||||
|
||||
Como o MobileSAM mantém o mesmo pipeline do SAM original, incorporamos o pré-processamento original, pós-processamento e todas as outras interfaces. Consequentemente, aqueles que estão atualmente usando o SAM original podem fazer a transição para o MobileSAM com um esforço mínimo.
|
||||
|
||||
O MobileSAM tem um desempenho comparável ao SAM original e mantém o mesmo pipeline, exceto por uma mudança no codificador de imagens. Especificamente, substituímos o codificador de imagens ViT-H original (632M) por um ViT menor (5M). Em uma única GPU, o MobileSAM opera em cerca de 12 ms por imagem: 8 ms no codificador de imagens e 4 ms no decodificador de máscaras.
|
||||
|
||||
A tabela a seguir fornece uma comparação dos codificadores de imagens baseados em ViT:
|
||||
|
||||
| Codificador de Imagens | SAM Original | MobileSAM |
|
||||
|------------------------|--------------|-----------|
|
||||
| Parâmetros | 611M | 5M |
|
||||
| Velocidade | 452ms | 8ms |
|
||||
|
||||
Tanto o SAM original quanto o MobileSAM utilizam o mesmo decodificador de máscaras baseado em prompt:
|
||||
|
||||
| Decodificador de Máscaras | SAM Original | MobileSAM |
|
||||
|---------------------------|--------------|-----------|
|
||||
| Parâmetros | 3,876M | 3,876M |
|
||||
| Velocidade | 4ms | 4ms |
|
||||
|
||||
Aqui está a comparação de todo o pipeline:
|
||||
|
||||
| Pipeline Completo (Enc+Dec) | SAM Original | MobileSAM |
|
||||
|-----------------------------|--------------|-----------|
|
||||
| Parâmetros | 615M | 9,66M |
|
||||
| Velocidade | 456ms | 12ms |
|
||||
|
||||
O desempenho do MobileSAM e do SAM original é demonstrado usando tanto um ponto quanto uma caixa como prompts.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Com seu desempenho superior, o MobileSAM é aproximadamente 5 vezes menor e 7 vezes mais rápido que o FastSAM atual. Mais detalhes estão disponíveis na [página do projeto MobileSAM](https://github.com/ChaoningZhang/MobileSAM).
|
||||
|
||||
## Testando o MobileSAM no Ultralytics
|
||||
|
||||
Assim como o SAM original, oferecemos um método de teste simples no Ultralytics, incluindo modos para prompts de Ponto e Caixa.
|
||||
|
||||
### Download do Modelo
|
||||
|
||||
Você pode baixar o modelo [aqui](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt).
|
||||
|
||||
### Prompt de Ponto
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# Carregar o modelo
|
||||
model = SAM('mobile_sam.pt')
|
||||
|
||||
# Prever um segmento com base em um prompt de ponto
|
||||
model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
|
||||
```
|
||||
|
||||
### Prompt de Caixa
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# Carregar o modelo
|
||||
model = SAM('mobile_sam.pt')
|
||||
|
||||
# Prever um segmento com base em um prompt de caixa
|
||||
model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
|
||||
```
|
||||
|
||||
Implementamos `MobileSAM` e `SAM` usando a mesma API. Para obter mais informações sobre o uso, consulte a [página do SAM](sam.md).
|
||||
|
||||
## Citações e Agradecimentos
|
||||
|
||||
Se você achar o MobileSAM útil em sua pesquisa ou trabalho de desenvolvimento, considere citar nosso artigo:
|
||||
|
||||
!!! Citar ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{mobile_sam,
|
||||
title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications},
|
||||
author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon},
|
||||
journal={arXiv preprint arXiv:2306.14289},
|
||||
year={2023}
|
||||
}
|
||||
93
docs/pt/models/rtdetr.md
Normal file
93
docs/pt/models/rtdetr.md
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
---
|
||||
comments: true
|
||||
description: Descubra as características e benefícios do RT-DETR da Baidu, um detector de objetos em tempo real eficiente e adaptável baseado em Vision Transformers, incluindo modelos pré-treinados.
|
||||
keywords: RT-DETR, Baidu, Vision Transformers, detecção de objetos, desempenho em tempo real, CUDA, TensorRT, seleção de consulta IoU, Ultralytics, API Python, PaddlePaddle
|
||||
---
|
||||
|
||||
# RT-DETR da Baidu: Um Detector de Objetos em Tempo Real Baseado em Vision Transformers
|
||||
|
||||
## Visão Geral
|
||||
|
||||
O Real-Time Detection Transformer (RT-DETR), desenvolvido pela Baidu, é um detector de objetos de última geração que proporciona desempenho em tempo real mantendo alta precisão. Ele utiliza a potência dos Vision Transformers (ViT) para processar eficientemente recursos multiescala, separando a interação intra-escala e a fusão entre escalas. O RT-DETR é altamente adaptável, com suporte para ajuste flexível da velocidade de inferência usando diferentes camadas de decodificador sem a necessidade de retratamento. O modelo se destaca em backends acelerados como o CUDA com o TensorRT, superando muitos outros detectores de objetos em tempo real.
|
||||
|
||||
|
||||
**Visão geral do RT-DETR da Baidu.** O diagrama da arquitetura do modelo RT-DETR mostra as últimas três etapas da espinha dorsal {S3, S4, S5} como entrada para o codificador. O codificador híbrido eficiente transforma recursos multiescala em uma sequência de recursos de imagem por meio da interação de recursos intra-escala (AIFI) e do módulo de fusão de recursos entre escalas (CCFM). A seleção de consulta, consciente da IoU, é utilizada para selecionar um número fixo de recursos de imagem para servir como consultas de objeto iniciais para o decodificador. Por fim, o decodificador com cabeçotes de previsão auxiliares otimiza iterativamente as consultas de objeto para gerar caixas e pontuações de confiança ([fonte](https://arxiv.org/pdf/2304.08069.pdf)).
|
||||
|
||||
### Características Principais
|
||||
|
||||
- **Codificador Híbrido Eficiente:** O RT-DETR da Baidu utiliza um codificador híbrido eficiente para processar recursos multiescala por meio da separação da interação intra-escala e da fusão entre escalas. Esse design exclusivo baseado em Vision Transformers reduz os custos computacionais e permite a detecção de objetos em tempo real.
|
||||
- **Seleção de Consulta Consciente de IoU:** O RT-DETR da Baidu melhora a inicialização das consultas de objeto ao utilizar seleção de consulta consciente de IoU. Isso permite que o modelo foque nos objetos mais relevantes na cena, aprimorando a precisão da detecção.
|
||||
- **Velocidade de Inferência Adaptável:** O RT-DETR da Baidu suporta ajustes flexíveis da velocidade de inferência ao utilizar diferentes camadas de decodificador sem a necessidade de retratamento. Essa adaptabilidade facilita a aplicação prática em diversos cenários de detecção de objetos em tempo real.
|
||||
|
||||
## Modelos Pré-Treinados
|
||||
|
||||
A API Python do Ultralytics fornece modelos pré-treinados do RT-DETR do PaddlePaddle com diferentes escalas:
|
||||
|
||||
- RT-DETR-L: 53,0% de AP em COCO val2017, 114 FPS em GPU T4
|
||||
- RT-DETR-X: 54,8% de AP em COCO val2017, 74 FPS em GPU T4
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
Este exemplo fornece exemplos simples de treinamento e inferência com o RT-DETRR. Para obter documentação completa sobre esses e outros [modos](../modes/index.md), consulte as páginas de documentação [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) e [Export](../modes/export.md).
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import RTDETR
|
||||
|
||||
# Carregue um modelo RT-DETR-l pré-treinado no COCO
|
||||
model = RTDETR('rtdetr-l.pt')
|
||||
|
||||
# Exiba informações do modelo (opcional)
|
||||
model.info()
|
||||
|
||||
# Treine o modelo com o conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Execute a inferência com o modelo RT-DETR-l na imagem 'bus.jpg'
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Carregue um modelo RT-DETR-l pré-treinado no COCO e treine-o com o conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Carregue um modelo RT-DETR-l pré-treinado no COCO e execute a inferência na imagem 'bus.jpg'
|
||||
yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Tarefas e Modos Suportados
|
||||
|
||||
Esta tabela apresenta os tipos de modelo, os pesos pré-treinados específicos, as tarefas suportadas por cada modelo e os vários modos ([Train](../modes/train.md), [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)) que são suportados, indicados por emojis ✅.
|
||||
|
||||
| Tipo de Modelo | Pesos Pré-treinados | Tarefas Suportadas | Inferência | Validação | Treinamento | Exportação |
|
||||
|----------------------|---------------------|-------------------------------------------|------------|-----------|-------------|------------|
|
||||
| RT-DETR Grande | `rtdetr-l.pt` | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| RT-DETR Extra-Grande | `rtdetr-x.pt` | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
## Citações e Reconhecimentos
|
||||
|
||||
Se você utilizar o RT-DETR da Baidu em seu trabalho de pesquisa ou desenvolvimento, por favor cite o [artigo original](https://arxiv.org/abs/2304.08069):
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lv2023detrs,
|
||||
title={DETRs Beat YOLOs on Real-time Object Detection},
|
||||
author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu},
|
||||
year={2023},
|
||||
eprint={2304.08069},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
Gostaríamos de agradecer à Baidu e à equipe do [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) por criar e manter esse recurso valioso para a comunidade de visão computacional. Sua contribuição para o campo com o desenvolvimento do detector de objetos em tempo real baseado em Vision Transformers, RT-DETR, é muito apreciada.
|
||||
|
||||
*keywords: RT-DETR, Transformer, ViT, Vision Transformers, RT-DETR da Baidu, PaddlePaddle, modelos pré-treinados PaddlePaddle RT-DETR, uso do RT-DETR da Baidu, API Python do Ultralytics*
|
||||
226
docs/pt/models/sam.md
Normal file
226
docs/pt/models/sam.md
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore o Modelo de Segmentação de Qualquer Coisa (SAM) de última geração da Ultralytics que permite a segmentação de imagens em tempo real. Aprenda sobre a segmentação baseada em prompts, o desempenho de transferência zero e como utilizá-lo.
|
||||
keywords: Ultralytics, segmentação de imagem, Modelo de Segmentação de Qualquer Coisa, SAM, conjunto de dados SA-1B, desempenho em tempo real, transferência zero, detecção de objetos, análise de imagens, aprendizado de máquina
|
||||
---
|
||||
|
||||
# Modelo de Segmentação de Qualquer Coisa (SAM)
|
||||
|
||||
Bem-vindo à fronteira da segmentação de imagem com o Modelo de Segmentação de Qualquer Coisa, ou SAM. Este modelo revolucionário mudou o jogo ao introduzir a segmentação de imagem baseada em prompts com desempenho em tempo real, estabelecendo novos padrões no campo.
|
||||
|
||||
## Introdução ao SAM: O Modelo de Segmentação de Qualquer Coisa
|
||||
|
||||
O Modelo de Segmentação de Qualquer Coisa, ou SAM, é um modelo de segmentação de imagem de ponta que permite a segmentação baseada em prompts, proporcionando uma versatilidade incomparável em tarefas de análise de imagem. O SAM é o cerne da iniciativa Segment Anything, um projeto inovador que introduz um modelo, tarefa e conjunto de dados novos para a segmentação de imagem.
|
||||
|
||||
O design avançado do SAM permite que ele se adapte a novas distribuições de imagem e tarefas sem conhecimento prévio, um recurso conhecido como transferência zero. Treinado no abrangente [conjunto de dados SA-1B](https://ai.facebook.com/datasets/segment-anything/), que contém mais de 1 bilhão de máscaras espalhadas por 11 milhões de imagens cuidadosamente selecionadas, o SAM tem demonstrado um impressionante desempenho de transferência zero, superando os resultados totalmente supervisionados anteriores em muitos casos.
|
||||
|
||||
|
||||
Imagens de exemplo com máscaras sobrepostas do nosso conjunto de dados recém-introduzido, SA-1B. O SA-1B contém 11 milhões de imagens diversas, de alta resolução, licenciadas e com proteção de privacidade, e 1,1 bilhão de máscaras de segmentação de alta qualidade. Essas máscaras foram anotadas totalmente automaticamente pelo SAM, e, como verificado por classificações humanas e inúmeros experimentos, são de alta qualidade e diversidade. As imagens são agrupadas pelo número de máscaras por imagem para visualização (em média, há ∼100 máscaras por imagem).
|
||||
|
||||
## Recursos Principais do Modelo de Segmentação de Qualquer Coisa (SAM)
|
||||
|
||||
- **Tarefa de Segmentação Baseada em Prompts:** O SAM foi projetado com uma tarefa de segmentação baseada em prompts em mente, permitindo que ele gere máscaras de segmentação válidas a partir de qualquer prompt fornecido, como dicas espaciais ou textuais que identifiquem um objeto.
|
||||
- **Arquitetura Avançada:** O Modelo de Segmentação de Qualquer Coisa utiliza um poderoso codificador de imagens, um codificador de prompts e um decodificador de máscaras leve. Essa arquitetura única possibilita o uso flexível de prompts, cálculo de máscaras em tempo real e consciência de ambiguidade em tarefas de segmentação.
|
||||
- **O Conjunto de Dados SA-1B:** Introduzido pelo projeto Segment Anything, o conjunto de dados SA-1B apresenta mais de 1 bilhão de máscaras em 11 milhões de imagens. Como o maior conjunto de dados de segmentação até o momento, ele fornece ao SAM uma fonte diversificada e em grande escala de dados de treinamento.
|
||||
- **Desempenho de Transferência Zero:** O SAM apresenta um desempenho de transferência zero excepcional em diversas tarefas de segmentação, tornando-se uma ferramenta pronta para uso em aplicações diversas com necessidade mínima de engenharia de prompts.
|
||||
|
||||
Para obter uma visão mais aprofundada do Modelo de Segmentação de Qualquer Coisa e do conjunto de dados SA-1B, visite o [site do Segment Anything](https://segment-anything.com) e consulte o artigo de pesquisa [Segment Anything](https://arxiv.org/abs/2304.02643).
|
||||
|
||||
## Modelos Disponíveis, Tarefas Suportadas e Modos de Operação
|
||||
|
||||
Esta tabela apresenta os modelos disponíveis com seus pesos pré-treinados específicos, as tarefas suportadas por eles e sua compatibilidade com diferentes modos de operação, como [Inferência](../modes/predict.md), [Validação](../modes/val.md), [Treinamento](../modes/train.md) e [Exportação](../modes/export.md), indicados pelos emojis ✅ para modos suportados e ❌ para modos não suportados.
|
||||
|
||||
| Tipo de Modelo | Pesos Pré-Treinados | Tarefas Suportadas | Inferência | Validação | Treinamento | Exportação |
|
||||
|----------------|---------------------|--------------------------------------------------|------------|-----------|-------------|------------|
|
||||
| SAM base | `sam_b.pt` | [Segmentação de Instâncias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
| SAM large | `sam_l.pt` | [Segmentação de Instâncias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## Como Usar o SAM: Versatilidade e Poder na Segmentação de Imagens
|
||||
|
||||
O Modelo de Segmentação de Qualquer Coisa pode ser utilizado para uma variedade de tarefas secundárias que vão além dos dados de treinamento. Isso inclui detecção de bordas, geração de propostas de objeto, segmentação de instâncias e predição preliminar de texto para máscara. Com a engenharia de prompts, o SAM pode se adaptar rapidamente a novas tarefas e distribuições de dados de maneira inovadora, estabelecendo-se como uma ferramenta versátil e poderosa para todas as suas necessidades de segmentação de imagem.
|
||||
|
||||
### Exemplo de predição do SAM
|
||||
|
||||
!!! Example "Segmentar com prompts"
|
||||
|
||||
Segmenta a imagem com prompts fornecidos.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# Carregar o modelo
|
||||
modelo = SAM('sam_b.pt')
|
||||
|
||||
# Exibir informações do modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Executar inferência com prompt de bboxes
|
||||
modelo('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
|
||||
|
||||
# Executar inferência com prompt de pontos
|
||||
modelo('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
|
||||
```
|
||||
|
||||
!!! Example "Segmentar tudo"
|
||||
|
||||
Segmenta toda a imagem.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# Carregar o modelo
|
||||
modelo = SAM('sam_b.pt')
|
||||
|
||||
# Exibir informações do modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Executar inferência
|
||||
modelo('caminho/para/imagem.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Executar inferência com um modelo SAM
|
||||
yolo predict model=sam_b.pt source=caminho/para/imagem.jpg
|
||||
```
|
||||
|
||||
- A lógica aqui é segmentar toda a imagem se nenhum prompt (bboxes/pontos/máscaras) for especificado.
|
||||
|
||||
!!! Example "Exemplo do SAMPredictor"
|
||||
|
||||
Desta forma, você pode definir a imagem uma vez e executar inferência de prompts várias vezes sem executar o codificador de imagem várias vezes.
|
||||
|
||||
=== "Inferência com prompt"
|
||||
|
||||
```python
|
||||
from ultralytics.models.sam import Predictor as SAMPredictor
|
||||
|
||||
# Criar o SAMPredictor
|
||||
substituições = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
|
||||
predictor = SAMPredictor(substituições=substituições)
|
||||
|
||||
# Definir imagem
|
||||
predictor.set_image("ultralytics/assets/zidane.jpg") # definir com arquivo de imagem
|
||||
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # definir com np.ndarray
|
||||
results = predictor(bboxes=[439, 437, 524, 709])
|
||||
results = predictor(points=[900, 370], labels=[1])
|
||||
|
||||
# Redefinir imagem
|
||||
predictor.reset_image()
|
||||
```
|
||||
|
||||
Segmentar tudo com argumentos adicionais.
|
||||
|
||||
=== "Segmentar tudo"
|
||||
|
||||
```python
|
||||
from ultralytics.models.sam import Predictor as SAMPredictor
|
||||
|
||||
# Criar o SAMPredictor
|
||||
substituições = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
|
||||
predictor = SAMPredictor(substituições=substituições)
|
||||
|
||||
# Segmentar com argumentos adicionais
|
||||
results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64)
|
||||
```
|
||||
|
||||
- Mais argumentos adicionais para `Segmentar tudo` consulte a [Referência do `Predictor/generate`](../../reference/models/sam/predict.md).
|
||||
|
||||
## Comparação SAM vs. YOLOv8
|
||||
|
||||
Aqui, comparamos o menor modelo SAM-b da Meta com o menor modelo de segmentação da Ultralytics, [YOLOv8n-seg](../tasks/segment.md):
|
||||
|
||||
| Modelo | Tamanho | Parâmetros | Velocidade (CPU) |
|
||||
|-----------------------------------------------|-------------------------------|--------------------------------|--------------------------------------|
|
||||
| SAM-b da Meta | 358 MB | 94,7 M | 51096 ms/im |
|
||||
| [MobileSAM](mobile-sam.md) | 40,7 MB | 10,1 M | 46122 ms/im |
|
||||
| [FastSAM-s](fast-sam.md) com YOLOv8 como base | 23,7 MB | 11,8 M | 115 ms/im |
|
||||
| YOLOv8n-seg da Ultralytics | **6,7 MB** (53,4 vezes menor) | **3,4 M** (27,9 vezes a menos) | **59 ms/im** (866 vezes mais rápido) |
|
||||
|
||||
Essa comparação mostra as diferenças de ordem de magnitude nos tamanhos e velocidades dos modelos. Enquanto o SAM apresenta capacidades exclusivas para segmentação automática, ele não é um concorrente direto dos modelos de segmentação YOLOv8, que são menores, mais rápidos e mais eficientes.
|
||||
|
||||
Os testes foram executados em um MacBook Apple M2 de 2023 com 16GB de RAM. Para reproduzir este teste:
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import FastSAM, SAM, YOLO
|
||||
|
||||
# Perfil do SAM-b
|
||||
modelo = SAM('sam_b.pt')
|
||||
modelo.info()
|
||||
modelo('ultralytics/assets')
|
||||
|
||||
# Perfil do MobileSAM
|
||||
modelo = SAM('mobile_sam.pt')
|
||||
modelo.info()
|
||||
modelo('ultralytics/assets')
|
||||
|
||||
# Perfil do FastSAM-s
|
||||
modelo = FastSAM('FastSAM-s.pt')
|
||||
modelo.info()
|
||||
modelo('ultralytics/assets')
|
||||
|
||||
# Perfil do YOLOv8n-seg
|
||||
modelo = YOLO('yolov8n-seg.pt')
|
||||
modelo.info()
|
||||
modelo('ultralytics/assets')
|
||||
```
|
||||
|
||||
## Autoanotação: Um Caminho Rápido para Conjuntos de Dados de Segmentação
|
||||
|
||||
A autoanotação é um recurso-chave do SAM que permite aos usuários gerar um [conjunto de dados de segmentação](https://docs.ultralytics.com/datasets/segment) usando um modelo de detecção pré-treinado. Esse recurso permite a anotação rápida e precisa de um grande número de imagens, contornando a necessidade de anotação manual demorada.
|
||||
|
||||
### Gere seu Conjunto de Dados de Segmentação Usando um Modelo de Detecção
|
||||
|
||||
Para fazer a autoanotação do seu conjunto de dados com o framework Ultralytics, use a função `auto_annotate` conforme mostrado abaixo:
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics.data.annotator import auto_annotate
|
||||
|
||||
auto_annotate(data="caminho/para/imagens", det_model="yolov8x.pt", sam_model='sam_b.pt')
|
||||
```
|
||||
|
||||
| Argumento | Tipo | Descrição | Padrão |
|
||||
|------------|---------------------|-----------------------------------------------------------------------------------------------------------|--------------|
|
||||
| data | str | Caminho para uma pasta que contém as imagens a serem anotadas. | |
|
||||
| det_model | str, opcional | Modelo de detecção YOLO pré-treinado. O padrão é 'yolov8x.pt'. | 'yolov8x.pt' |
|
||||
| sam_model | str, opcional | Modelo de segmentação SAM pré-treinado. O padrão é 'sam_b.pt'. | 'sam_b.pt' |
|
||||
| device | str, opcional | Dispositivo no qual executar os modelos. O padrão é uma string vazia (CPU ou GPU, se disponível). | |
|
||||
| output_dir | str, None, opcional | Diretório para salvar os resultados anotados. O padrão é uma pasta 'labels' no mesmo diretório de 'data'. | None |
|
||||
|
||||
A função `auto_annotate` recebe o caminho para suas imagens, com argumentos opcionais para especificar os modelos de detecção pré-treinados e de segmentação SAM, o dispositivo onde executar os modelos e o diretório de saída para salvar os resultados anotados.
|
||||
|
||||
A autoanotação com modelos pré-treinados pode reduzir drasticamente o tempo e o esforço necessários para criar conjuntos de dados de segmentação de alta qualidade. Esse recurso é especialmente benéfico para pesquisadores e desenvolvedores que lidam com grandes coleções de imagens, pois permite que eles se concentrem no desenvolvimento e na avaliação do modelo, em vez de na anotação manual.
|
||||
|
||||
## Citações e Reconhecimentos
|
||||
|
||||
Se você encontrar o SAM útil em seu trabalho de pesquisa ou desenvolvimento, considere citar nosso artigo:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{kirillov2023segment,
|
||||
title={Segment Anything},
|
||||
author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollár and Ross Girshick},
|
||||
year={2023},
|
||||
eprint={2304.02643},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
Gostaríamos de expressar nossa gratidão à Meta AI por criar e manter esse recurso valioso para a comunidade de visão computacional.
|
||||
|
||||
*keywords: Segment Anything, Modelo de Segmentação de Qualquer Coisa, SAM, SAM da Meta, segmentação de imagem, segmentação baseada em prompts, desempenho de transferência zero, conjunto de dados SA-1B, arquitetura avançada, autoanotação, Ultralytics, modelos pré-treinados, SAM base, SAM large, segmentação de instâncias, visão computacional, IA, inteligência artificial, aprendizado de máquina, anotação de dados, máscaras de segmentação, modelo de detecção, modelo de detecção YOLO, bibtex, Meta AI.*
|
||||
121
docs/pt/models/yolo-nas.md
Normal file
121
docs/pt/models/yolo-nas.md
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore a documentação detalhada do YOLO-NAS, um modelo superior de detecção de objetos. Saiba mais sobre suas funcionalidades, modelos pré-treinados, uso com a API do Ultralytics Python e muito mais.
|
||||
keywords: YOLO-NAS, Deci AI, detecção de objetos, aprendizado profundo, busca de arquitetura neural, API do Ultralytics Python, modelo YOLO, modelos pré-treinados, quantização, otimização, COCO, Objects365, Roboflow 100
|
||||
---
|
||||
|
||||
# YOLO-NAS
|
||||
|
||||
## Visão Geral
|
||||
|
||||
Desenvolvido pela Deci AI, o YOLO-NAS é um modelo de detecção de objetos inovador. É o produto da tecnologia avançada de Busca de Arquitetura Neural, meticulosamente projetado para superar as limitações dos modelos YOLO anteriores. Com melhorias significativas no suporte à quantização e compromisso entre precisão e latência, o YOLO-NAS representa um grande avanço na detecção de objetos.
|
||||
|
||||
|
||||
**Visão geral do YOLO-NAS.** O YOLO-NAS utiliza blocos que suportam quantização e quantização seletiva para obter um desempenho ideal. O modelo, quando convertido para sua versão quantizada INT8, apresenta uma queda mínima na precisão, uma melhoria significativa em relação a outros modelos. Esses avanços culminam em uma arquitetura superior com capacidades de detecção de objetos sem precedentes e desempenho excepcional.
|
||||
|
||||
### Principais Características
|
||||
|
||||
- **Bloco Básico Amigável para Quantização:** O YOLO-NAS introduz um novo bloco básico que é amigo da quantização, abordando uma das limitações significativas dos modelos YOLO anteriores.
|
||||
- **Treinamento e Quantização Sofisticados:** O YOLO-NAS utiliza esquemas avançados de treinamento e quantização pós-treinamento para melhorar o desempenho.
|
||||
- **Otimização AutoNAC e Pré-Treinamento:** O YOLO-NAS utiliza a otimização AutoNAC e é pré-treinado em conjuntos de dados proeminentes, como COCO, Objects365 e Roboflow 100. Esse pré-treinamento torna o modelo extremamente adequado para tarefas de detecção de objetos em ambientes de produção.
|
||||
|
||||
## Modelos Pré-Treinados
|
||||
|
||||
Experimente o poder da detecção de objetos de última geração com os modelos pré-treinados do YOLO-NAS fornecidos pela Ultralytics. Esses modelos foram projetados para oferecer um desempenho excelente em termos de velocidade e precisão. Escolha entre várias opções adaptadas às suas necessidades específicas:
|
||||
|
||||
| Modelo | mAP | Latência (ms) |
|
||||
|------------------|-------|---------------|
|
||||
| YOLO-NAS S | 47.5 | 3.21 |
|
||||
| YOLO-NAS M | 51.55 | 5.85 |
|
||||
| YOLO-NAS L | 52.22 | 7.87 |
|
||||
| YOLO-NAS S INT-8 | 47.03 | 2.36 |
|
||||
| YOLO-NAS M INT-8 | 51.0 | 3.78 |
|
||||
| YOLO-NAS L INT-8 | 52.1 | 4.78 |
|
||||
|
||||
Cada variante do modelo foi projetada para oferecer um equilíbrio entre Precisão Média Média (mAP) e latência, ajudando você a otimizar suas tarefas de detecção de objetos em termos de desempenho e velocidade.
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
A Ultralytics tornou os modelos YOLO-NAS fáceis de serem integrados em suas aplicações Python por meio de nosso pacote `ultralytics`. O pacote fornece uma API Python de fácil utilização para simplificar o processo.
|
||||
|
||||
Os seguintes exemplos mostram como usar os modelos YOLO-NAS com o pacote `ultralytics` para inferência e validação:
|
||||
|
||||
### Exemplos de Inferência e Validação
|
||||
|
||||
Neste exemplo, validamos o YOLO-NAS-s no conjunto de dados COCO8.
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
Este exemplo fornece um código simples de inferência e validação para o YOLO-NAS. Para lidar com os resultados da inferência, consulte o modo [Predict](../modes/predict.md). Para usar o YOLO-NAS com modos adicionais, consulte [Val](../modes/val.md) e [Export](../modes/export.md). O YOLO-NAS no pacote `ultralytics` não suporta treinamento.
|
||||
|
||||
=== "Python"
|
||||
|
||||
Arquivos de modelos pré-treinados `*.pt` do PyTorch podem ser passados para a classe `NAS()` para criar uma instância do modelo em Python:
|
||||
|
||||
```python
|
||||
from ultralytics import NAS
|
||||
|
||||
# Carrega um modelo YOLO-NAS-s pré-treinado no COCO
|
||||
model = NAS('yolo_nas_s.pt')
|
||||
|
||||
# Exibe informações do modelo (opcional)
|
||||
model.info()
|
||||
|
||||
# Valida o modelo no conjunto de dados de exemplo COCO8
|
||||
results = model.val(data='coco8.yaml')
|
||||
|
||||
# Executa inferência com o modelo YOLO-NAS-s na imagem 'bus.jpg'
|
||||
results = model('caminho/para/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Comandos de CLI estão disponíveis para executar diretamente os modelos:
|
||||
|
||||
```bash
|
||||
# Carrega um modelo YOLO-NAS-s pré-treinado no COCO e valida seu desempenho no conjunto de dados de exemplo COCO8
|
||||
yolo val model=yolo_nas_s.pt data=coco8.yaml
|
||||
|
||||
# Carrega um modelo YOLO-NAS-s pré-treinado no COCO e executa inferência na imagem 'bus.jpg'
|
||||
yolo predict model=yolo_nas_s.pt source=caminho/para/bus.jpg
|
||||
```
|
||||
|
||||
## Tarefas e Modos Compatíveis
|
||||
|
||||
Oferecemos três variantes dos modelos YOLO-NAS: Pequeno (s), Médio (m) e Grande (l). Cada variante foi projetada para atender a diferentes necessidades computacionais e de desempenho:
|
||||
|
||||
- **YOLO-NAS-s**: Otimizado para ambientes com recursos computacionais limitados, mas eficiência é fundamental.
|
||||
- **YOLO-NAS-m**: Oferece uma abordagem equilibrada, adequada para detecção de objetos em geral com maior precisão.
|
||||
- **YOLO-NAS-l**: Adaptado para cenários que requerem a maior precisão, onde os recursos computacionais são menos restritos.
|
||||
|
||||
Abaixo está uma visão geral detalhada de cada modelo, incluindo links para seus pesos pré-treinados, as tarefas que eles suportam e sua compatibilidade com diferentes modos de operação.
|
||||
|
||||
| Tipo de Modelo | Pesos Pré-Treinados | Tarefas Suportadas | Inferência | Validação | Treinamento | Exportação |
|
||||
|----------------|-----------------------------------------------------------------------------------------------|-------------------------------------------|------------|-----------|-------------|------------|
|
||||
| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_s.pt) | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_m.pt) | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_l.pt) | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
|
||||
## Citações e Agradecimentos
|
||||
|
||||
Se você utilizar o YOLO-NAS em seus estudos ou trabalho de desenvolvimento, por favor, cite o SuperGradients:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{supergradients,
|
||||
doi = {10.5281/ZENODO.7789328},
|
||||
url = {https://zenodo.org/record/7789328},
|
||||
author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}},
|
||||
title = {Super-Gradients},
|
||||
publisher = {GitHub},
|
||||
journal = {GitHub repository},
|
||||
year = {2021},
|
||||
}
|
||||
```
|
||||
|
||||
Expressamos nossa gratidão à equipe [SuperGradients](https://github.com/Deci-AI/super-gradients/) da Deci AI por seus esforços na criação e manutenção deste recurso valioso para a comunidade de visão computacional. Acreditamos que o YOLO-NAS, com sua arquitetura inovadora e capacidades superiores de detecção de objetos, se tornará uma ferramenta fundamental para desenvolvedores e pesquisadores.
|
||||
|
||||
*keywords: YOLO-NAS, Deci AI, detecção de objetos, aprendizado profundo, busca de arquitetura neural, API do Ultralytics Python, modelo YOLO, SuperGradients, modelos pré-treinados, bloco básico amigável para quantização, esquemas avançados de treinamento, quantização pós-treinamento, otimização AutoNAC, COCO, Objects365, Roboflow 100*
|
||||
98
docs/pt/models/yolov3.md
Normal file
98
docs/pt/models/yolov3.md
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
---
|
||||
comments: true
|
||||
description: Obtenha uma visão geral do YOLOv3, YOLOv3-Ultralytics e YOLOv3u. Saiba mais sobre suas principais características, uso e tarefas suportadas para detecção de objetos.
|
||||
keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Detecção de Objetos, Inferência, Treinamento, Ultralytics
|
||||
---
|
||||
|
||||
# YOLOv3, YOLOv3-Ultralytics, e YOLOv3u
|
||||
|
||||
## Visão Geral
|
||||
|
||||
Este documento apresenta uma visão geral de três modelos de detecção de objetos intimamente relacionados, nomeadamente o [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) e [YOLOv3u](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
1. **YOLOv3:** Esta é a terceira versão do algoritmo de detecção de objetos You Only Look Once (YOLO). Originalmente desenvolvido por Joseph Redmon, o YOLOv3 melhorou seus predecessores ao introduzir recursos como previsões em várias escalas e três tamanhos diferentes de kernels de detecção.
|
||||
|
||||
2. **YOLOv3-Ultralytics:** Esta é a implementação do YOLOv3 pela Ultralytics. Ela reproduz a arquitetura original do YOLOv3 e oferece funcionalidades adicionais, como suporte para mais modelos pré-treinados e opções de personalização mais fáceis.
|
||||
|
||||
3. **YOLOv3u:** Esta é uma versão atualizada do YOLOv3-Ultralytics que incorpora o cabeçalho dividido livre de âncoras e sem "objectness" usado nos modelos YOLOv8. O YOLOv3u mantém a mesma arquitetura de "backbone" e "neck" do YOLOv3, mas com o cabeçalho de detecção atualizado do YOLOv8.
|
||||
|
||||
|
||||
|
||||
## Principais Características
|
||||
|
||||
- **YOLOv3:** Introduziu o uso de três escalas diferentes para detecção, aproveitando três tamanhos diferentes de kernels de detecção: 13x13, 26x26 e 52x52. Isso melhorou significativamente a precisão da detecção para objetos de diferentes tamanhos. Além disso, o YOLOv3 adicionou recursos como previsões multi-rótulos para cada caixa delimitadora e uma rede de extração de características melhor.
|
||||
|
||||
- **YOLOv3-Ultralytics:** A implementação do YOLOv3 pela Ultralytics oferece o mesmo desempenho do modelo original, porém possui suporte adicional para mais modelos pré-treinados, métodos de treinamento adicionais e opções de personalização mais fáceis. Isso torna o modelo mais versátil e fácil de usar para aplicações práticas.
|
||||
|
||||
- **YOLOv3u:** Este modelo atualizado incorpora o cabeçalho dividido livre de âncoras e "objectness" do YOLOv8. Ao eliminar a necessidade de caixas de âncoras pré-definidas e pontuações de "objectness", esse design de cabeçalho de detecção pode melhorar a capacidade do modelo de detectar objetos de tamanhos e formatos variados. Isso torna o YOLOv3u mais robusto e preciso para tarefas de detecção de objetos.
|
||||
|
||||
## Tarefas e Modos Suportados
|
||||
|
||||
A série YOLOv3, incluindo YOLOv3, YOLOv3-Ultralytics e YOLOv3u, foi projetada especificamente para tarefas de detecção de objetos. Esses modelos são conhecidos por sua eficácia em vários cenários do mundo real, equilibrando precisão e velocidade. Cada variante oferece recursos e otimizações únicos, tornando-os adequados para uma variedade de aplicações.
|
||||
|
||||
Os três modelos suportam um conjunto abrangente de modos, garantindo versatilidade em várias etapas do desenvolvimento e implantação de modelos. Esses modos incluem [Inferência](../modes/predict.md), [Validação](../modes/val.md), [Treinamento](../modes/train.md) e [Exportação](../modes/export.md), fornecendo aos usuários um conjunto completo de ferramentas para detecção eficaz de objetos.
|
||||
|
||||
| Tipo de Modelo | Tarefas Suportadas | Inferência | Validação | Treinamento | Exportação |
|
||||
|--------------------|-------------------------------------------|------------|-----------|-------------|------------|
|
||||
| YOLOv3 | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv3-Ultralytics | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv3u | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
Esta tabela fornece uma visão rápida das capacidades de cada variante do YOLOv3, destacando sua versatilidade e adequação para várias tarefas e modos operacionais em fluxos de trabalho de detecção de objetos.
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
Este exemplo apresenta exemplos simples de treinamento e inferência do YOLOv3. Para obter documentação completa sobre esses e outros [modos](../modes/index.md), consulte as páginas de documentação do [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) e [Export](../modes/export.md).
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Modelos pré-treinados do PyTorch `*.pt`, bem como arquivos de configuração `*.yaml`, podem ser passados para a classe `YOLO()` para criar uma instância do modelo em Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Carregue um modelo YOLOv3n pré-treinado na COCO
|
||||
model = YOLO('yolov3n.pt')
|
||||
|
||||
# Exiba informações sobre o modelo (opcional)
|
||||
model.info()
|
||||
|
||||
# Treine o modelo no conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Execute inferência com o modelo YOLOv3n na imagem 'bus.jpg'
|
||||
results = model('caminho/para/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Comandos CLI estão disponíveis para executar diretamente os modelos:
|
||||
|
||||
```bash
|
||||
# Carregue um modelo YOLOv3n pré-treinado na COCO e treine-o no conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Carregue um modelo YOLOv3n pré-treinado na COCO e execute inferência na imagem 'bus.jpg'
|
||||
yolo predict model=yolov3n.pt source=caminho/para/bus.jpg
|
||||
```
|
||||
|
||||
## Citações e Reconhecimentos
|
||||
|
||||
Se você utilizar o YOLOv3 em sua pesquisa, por favor, cite os artigos originais do YOLO e o repositório Ultralytics YOLOv3:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{redmon2018yolov3,
|
||||
title={YOLOv3: An Incremental Improvement},
|
||||
author={Redmon, Joseph and Farhadi, Ali},
|
||||
journal={arXiv preprint arXiv:1804.02767},
|
||||
year={2018}
|
||||
}
|
||||
```
|
||||
|
||||
Agradecemos a Joseph Redmon e Ali Farhadi por desenvolverem o YOLOv3 original.
|
||||
71
docs/pt/models/yolov4.md
Normal file
71
docs/pt/models/yolov4.md
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore nosso guia detalhado sobre o YOLOv4, um detector de objetos em tempo real de última geração. Entenda seus destaques arquiteturais, recursos inovadores e exemplos de aplicação.
|
||||
keywords: ultralytics, YOLOv4, detecção de objetos, rede neural, detecção em tempo real, detector de objetos, aprendizado de máquina
|
||||
---
|
||||
|
||||
# YOLOv4: Detecção de Objetos Rápida e Precisa
|
||||
|
||||
Bem-vindo à página de documentação do Ultralytics para o YOLOv4, um detector de objetos em tempo real de última geração lançado em 2020 por Alexey Bochkovskiy em [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). O YOLOv4 foi projetado para fornecer o equilíbrio ideal entre velocidade e precisão, tornando-o uma excelente escolha para muitas aplicações.
|
||||
|
||||
|
||||
**Diagrama da arquitetura do YOLOv4**. Mostra o design intricado da rede do YOLOv4, incluindo os componentes backbone, neck e head, bem como suas camadas interconectadas para uma detecção de objetos em tempo real otimizada.
|
||||
|
||||
## Introdução
|
||||
|
||||
YOLOv4 significa You Only Look Once versão 4. É um modelo de detecção de objetos em tempo real desenvolvido para superar as limitações de versões anteriores do YOLO, como [YOLOv3](yolov3.md) e outros modelos de detecção de objetos. Ao contrário de outros detectores de objetos baseados em redes neurais convolucionais (CNN), o YOLOv4 é aplicável não apenas a sistemas de recomendação, mas também ao gerenciamento de processos independentes e à redução da entrada humana. Sua operação em unidades de processamento gráfico (GPUs) convencionais permite o uso em massa a um preço acessível, e foi projetado para funcionar em tempo real em uma GPU convencional, exigindo apenas uma GPU para treinamento.
|
||||
|
||||
## Arquitetura
|
||||
|
||||
O YOLOv4 faz uso de várias características inovadoras que trabalham juntas para otimizar seu desempenho. Estas incluem Conexões Residuais Ponderadas (WRC), Conexões Parciais Cruzadas de Estágio (CSP), Normalização Cruzada em Mini Lote (CmBN), Treinamento Autoadversário (SAT), Ativação Mish, Aumento de Dados Mosaic, Regularização DropBlock e Perda CIoU. Essas características são combinadas para obter resultados de última geração.
|
||||
|
||||
Um detector de objetos típico é composto por várias partes, incluindo a entrada, o backbone, o neck e o head. O backbone do YOLOv4 é pré-treinado no ImageNet e é usado para prever as classes e caixas delimitadoras dos objetos. O backbone pode ser de vários modelos, incluindo VGG, ResNet, ResNeXt ou DenseNet. A parte neck do detector é usada para coletar mapas de características de diferentes estágios e geralmente inclui várias caminhadas bottom-up e várias caminhadas top-down. A parte head é responsável por fazer as detecções e classificações finais dos objetos.
|
||||
|
||||
## Bag of Freebies
|
||||
|
||||
O YOLOv4 também faz uso de métodos conhecidos como "bag of freebies" (saco de brindes), que são técnicas que melhoram a precisão do modelo durante o treinamento sem aumentar o custo da inferência. O aumento de dados é uma técnica comum de "bag of freebies" usada na detecção de objetos, que aumenta a variabilidade das imagens de entrada para melhorar a robustez do modelo. Alguns exemplos de aumento de dados incluem distorções fotométricas (ajustando o brilho, contraste, matiz, saturação e ruído de uma imagem) e distorções geométricas (adicionando dimensionamento aleatório, recorte, espelhamento e rotação). Essas técnicas ajudam o modelo a generalizar melhor para diferentes tipos de imagens.
|
||||
|
||||
## Recursos e Desempenho
|
||||
|
||||
O YOLOv4 foi projetado para oferecer velocidade e precisão ideais na detecção de objetos. A arquitetura do YOLOv4 inclui o CSPDarknet53 como o backbone, o PANet como o neck e o YOLOv3 como a cabeça de detecção. Esse design permite que o YOLOv4 realize detecção de objetos em uma velocidade impressionante, tornando-o adequado para aplicações em tempo real. O YOLOv4 também se destaca em termos de precisão, alcançando resultados de última geração em benchmarks de detecção de objetos.
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
No momento da escrita, o Ultralytics não oferece suporte a modelos YOLOv4. Portanto, os usuários interessados em usar o YOLOv4 deverão consultar diretamente o repositório YOLOv4 no GitHub para instruções de instalação e uso.
|
||||
|
||||
Aqui está uma breve visão geral das etapas típicas que você pode seguir para usar o YOLOv4:
|
||||
|
||||
1. Visite o repositório YOLOv4 no GitHub: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
|
||||
|
||||
2. Siga as instruções fornecidas no arquivo README para a instalação. Isso geralmente envolve clonar o repositório, instalar as dependências necessárias e configurar as variáveis de ambiente necessárias.
|
||||
|
||||
3. Uma vez que a instalação esteja completa, você pode treinar e usar o modelo de acordo com as instruções de uso fornecidas no repositório. Isso geralmente envolve a preparação do seu conjunto de dados, a configuração dos parâmetros do modelo, o treinamento do modelo e, em seguida, o uso do modelo treinado para realizar a detecção de objetos.
|
||||
|
||||
Observe que as etapas específicas podem variar dependendo do seu caso de uso específico e do estado atual do repositório YOLOv4. Portanto, é altamente recomendável consultar diretamente as instruções fornecidas no repositório YOLOv4 do GitHub.
|
||||
|
||||
Lamentamos qualquer inconveniente que isso possa causar e nos esforçaremos para atualizar este documento com exemplos de uso para o Ultralytics assim que o suporte para o YOLOv4 for implementado.
|
||||
|
||||
## Conclusão
|
||||
|
||||
O YOLOv4 é um modelo poderoso e eficiente de detecção de objetos que oferece um equilíbrio entre velocidade e precisão. O uso de recursos exclusivos e técnicas "Bag of Freebies" durante o treinamento permite que ele tenha um excelente desempenho em tarefas de detecção de objetos em tempo real. O YOLOv4 pode ser treinado e usado por qualquer pessoa com uma GPU convencional, tornando-o acessível e prático para uma ampla variedade de aplicações.
|
||||
|
||||
## Referências e Agradecimentos
|
||||
|
||||
Gostaríamos de agradecer aos autores do YOLOv4 por suas contribuições significativas no campo da detecção de objetos em tempo real:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{bochkovskiy2020yolov4,
|
||||
title={YOLOv4: Optimal Speed and Accuracy of Object Detection},
|
||||
author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao},
|
||||
year={2020},
|
||||
eprint={2004.10934},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
O artigo original do YOLOv4 pode ser encontrado no [arXiv](https://arxiv.org/pdf/2004.10934.pdf). Os autores disponibilizaram seu trabalho publicamente, e o código pode ser acessado no [GitHub](https://github.com/AlexeyAB/darknet). Agradecemos seus esforços em avançar o campo e tornar seu trabalho acessível à comunidade em geral.
|
||||
113
docs/pt/models/yolov5.md
Normal file
113
docs/pt/models/yolov5.md
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
---
|
||||
comments: true
|
||||
description: Descubra o YOLOv5u, uma versão aprimorada do modelo YOLOv5 com uma relação aprimorada entre precisão e velocidade e vários modelos pré-treinados para várias tarefas de detecção de objetos.
|
||||
keywords: YOLOv5u, detecção de objetos, modelos pré-treinados, Ultralytics, Inferência, Validação, YOLOv5, YOLOv8, sem âncora, sem certeza de objectness, aplicativos em tempo real, machine learning
|
||||
---
|
||||
|
||||
# YOLOv5
|
||||
|
||||
## Visão Geral
|
||||
|
||||
O YOLOv5u representa um avanço nas metodologias de detecção de objetos. Originário da arquitetura fundamental do modelo [YOLOv5](https://github.com/ultralytics/yolov5) desenvolvido pela Ultralytics, o YOLOv5u integra a divisão da cabeça do Ultralytics sem âncora e sem certeza de objectness, uma formação introduzida anteriormente nos modelos [YOLOv8](yolov8.md). Essa adaptação aprimora a arquitetura do modelo, resultando em uma relação aprimorada entre precisão e velocidade em tarefas de detecção de objetos. Com base nos resultados empíricos e em suas características derivadas, o YOLOv5u oferece uma alternativa eficiente para aqueles que procuram soluções robustas tanto na pesquisa quanto em aplicações práticas.
|
||||
|
||||
|
||||
|
||||
## Principais Recursos
|
||||
|
||||
- **Cabeça do Ultralytics sem Âncora:** Modelos tradicionais de detecção de objetos dependem de caixas âncora predefinidas para prever as localizações dos objetos. No entanto, o YOLOv5u moderniza essa abordagem. Ao adotar uma cabeça do Ultralytics sem âncora, ele garante um mecanismo de detecção mais flexível e adaptável, melhorando consequentemente o desempenho em cenários diversos.
|
||||
|
||||
- **Equilíbrio otimizado entre precisão e velocidade:** Velocidade e precisão muitas vezes puxam em direções opostas. Mas o YOLOv5u desafia esse equilíbrio. Ele oferece um equilíbrio calibrado, garantindo detecções em tempo real sem comprometer a precisão. Esse recurso é particularmente valioso para aplicativos que exigem respostas rápidas, como veículos autônomos, robótica e análise de vídeo em tempo real.
|
||||
|
||||
- **Variedade de Modelos Pré-Treinados:** Entendendo que diferentes tarefas exigem conjuntos de ferramentas diferentes, o YOLOv5u oferece uma variedade de modelos pré-treinados. Se você está focado em Inferência, Validação ou Treinamento, há um modelo personalizado esperando por você. Essa variedade garante que você não esteja apenas usando uma solução genérica, mas sim um modelo ajustado especificamente para o seu desafio único.
|
||||
|
||||
## Tarefas e Modos Suportados
|
||||
|
||||
Os modelos YOLOv5u, com vários pesos pré-treinados, se destacam nas tarefas de [Detecção de Objetos](../tasks/detect.md). Eles suportam uma ampla gama de modos, tornando-os adequados para aplicações diversas, desde o desenvolvimento até a implantação.
|
||||
|
||||
| Tipo de Modelo | Pesos Pré-Treinados | Tarefa | Inferência | Validação | Treinamento | Exportação |
|
||||
|----------------|-----------------------------------------------------------------------------------------------------------------------------|-------------------------------------------|------------|-----------|-------------|------------|
|
||||
| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
Essa tabela oferece uma visão detalhada das variantes do modelo YOLOv5u, destacando sua aplicabilidade em tarefas de detecção de objetos e suporte a diversos modos operacionais, como [Inferência](../modes/predict.md), [Validação](../modes/val.md), [Treinamento](../modes/train.md) e [Exportação](../modes/export.md). Esse suporte abrangente garante que os usuários possam aproveitar totalmente as capacidades dos modelos YOLOv5u em uma ampla gama de cenários de detecção de objetos.
|
||||
|
||||
## Métricas de Desempenho
|
||||
|
||||
!!! Desempenho
|
||||
|
||||
=== "Detecção"
|
||||
|
||||
Consulte a [Documentação de Detecção](https://docs.ultralytics.com/tasks/detect/) para exemplos de uso com esses modelos treinados no conjunto de dados [COCO](https://docs.ultralytics.com/datasets/detect/coco/), que incluem 80 classes pré-treinadas.
|
||||
|
||||
| Modelo | YAML | 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) |
|
||||
| --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------| -------------------------| ----------------------| -------------------------------------| -------------------------------------- | ---------------------- | ----------------- |
|
||||
| [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34.3 | 73.6 | 1.06 | 2.6 | 7.7 |
|
||||
| [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43.0 | 120.7 | 1.27 | 9.1 | 24.0 |
|
||||
| [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49.0 | 233.9 | 1.86 | 25.1 | 64.2 |
|
||||
| [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52.2 | 408.4 | 2.50 | 53.2 | 135.0 |
|
||||
| [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53.2 | 763.2 | 3.81 | 97.2 | 246.4 |
|
||||
| | | | | | | | |
|
||||
| [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 42.1 | 211.0 | 1.83 | 4.3 | 7.8 |
|
||||
| [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 48.6 | 422.6 | 2.34 | 15.3 | 24.6 |
|
||||
| [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 53.6 | 810.9 | 4.36 | 41.2 | 65.7 |
|
||||
| [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 55.7 | 1470.9 | 5.47 | 86.1 | 137.4 |
|
||||
| [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 56.8 | 2436.5 | 8.98 | 155.4 | 250.7 |
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
Este exemplo fornece exemplos simples de treinamento e inferência do YOLOv5. Para documentação completa sobre esses e outros [modos](../modes/index.md), consulte as páginas de documentação [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) e [Export](../modes/export.md).
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Modelos pré-treinados `*.pt` do PyTorch, assim como os arquivos de configuração `*.yaml`, podem ser passados para a classe `YOLO()` para criar uma instância do modelo em Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Carrega um modelo YOLOv5n pré-treinado no COCO
|
||||
modelo = YOLO('yolov5n.pt')
|
||||
|
||||
# Mostra informações do modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Treina o modelo no conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
resultados = modelo.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Executa a inferência com o modelo YOLOv5n na imagem 'bus.jpg'
|
||||
resultados = modelo('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Comandos CLI estão disponíveis para executar diretamente os modelos:
|
||||
|
||||
```bash
|
||||
# Carrega um modelo YOLOv5n pré-treinado no COCO e o treina no conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Carrega um modelo YOLOv5n pré-treinado no COCO e executa a inferência na imagem 'bus.jpg'
|
||||
yolo predict model=yolov5n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Citações e Agradecimentos
|
||||
|
||||
Se você usar o YOLOv5 ou YOLOv5u em sua pesquisa, por favor, cite o repositório YOLOv5 da Ultralytics da seguinte forma:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
```bibtex
|
||||
@software{yolov5,
|
||||
title = {Ultralytics YOLOv5},
|
||||
author = {Glenn Jocher},
|
||||
year = {2020},
|
||||
version = {7.0},
|
||||
license = {AGPL-3.0},
|
||||
url = {https://github.com/ultralytics/yolov5},
|
||||
doi = {10.5281/zenodo.3908559},
|
||||
orcid = {0000-0001-5950-6979}
|
||||
}
|
||||
```
|
||||
|
||||
Observe que os modelos YOLOv5 são fornecidos sob licenças [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) e [Enterprise](https://ultralytics.com/license).
|
||||
107
docs/pt/models/yolov6.md
Normal file
107
docs/pt/models/yolov6.md
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore Meituan YOLOv6, um modelo avançado de detecção de objetos que alcança um equilíbrio entre velocidade e precisão. Saiba mais sobre suas características, modelos pré-treinados e uso em Python.
|
||||
keywords: Meituan YOLOv6, detecção de objetos, Ultralytics, documentação YOLOv6, Concatenação Bidirecional, Treinamento Assistido por Âncora, modelos pré-treinados, aplicações em tempo real
|
||||
---
|
||||
|
||||
# Meituan YOLOv6
|
||||
|
||||
## Visão Geral
|
||||
|
||||
O Meituan YOLOv6 é um detector de objetos de ponta que oferece um equilíbrio notável entre velocidade e precisão, tornando-se uma escolha popular para aplicações em tempo real. Este modelo apresenta várias melhorias em sua arquitetura e esquema de treinamento, incluindo a implementação de um módulo de Concatenação Bidirecional (BiC), uma estratégia de treinamento assistido por âncora (AAT) e um design aprimorado de espinha dorsal e pescoço para obter precisão de última geração no conjunto de dados COCO.
|
||||
|
||||
|
||||
|
||||
**Visão geral do YOLOv6.** Diagrama da arquitetura do modelo mostrando os componentes de rede redesenhados e as estratégias de treinamento que levaram a melhorias significativas no desempenho. (a) O pescoço do YOLOv6 (N e S são mostrados). RepBlocks é substituída por CSPStackRep para M/L. (b) A estrutura de um módulo BiC. (c) Um bloco SimCSPSPPF. ([fonte](https://arxiv.org/pdf/2301.05586.pdf)).
|
||||
|
||||
### Principais Características
|
||||
|
||||
- **Módulo de Concatenação Bidirecional (BiC):** O YOLOv6 introduz um módulo BiC no pescoço do detector, aprimorando os sinais de localização e oferecendo ganhos de desempenho com uma degradação de velocidade insignificante.
|
||||
- **Estratégia de Treinamento Assistido por Âncora (AAT):** Este modelo propõe AAT para aproveitar os benefícios dos paradigmas baseados em âncoras e sem âncoras sem comprometer a eficiência da inferência.
|
||||
- **Design de Espinha Dorsal e Pescoço Aprimorado:** Ao aprofundar o YOLOv6 para incluir mais uma etapa na espinha dorsal e no pescoço, este modelo alcança desempenho de última geração no conjunto de dados COCO com entrada de alta resolução.
|
||||
- **Estratégia de Auto-Destilação:** Uma nova estratégia de auto-destilação é implementada para aumentar o desempenho de modelos menores do YOLOv6, aprimorando o ramo auxiliar de regressão durante o treinamento e removendo-o durante a inferência para evitar uma queda significativa na velocidade.
|
||||
|
||||
## Métricas de Desempenho
|
||||
|
||||
O YOLOv6 fornece vários modelos pré-treinados com diferentes escalas:
|
||||
|
||||
- YOLOv6-N: 37,5% AP na val2017 do COCO a 1187 FPS com GPU NVIDIA Tesla T4.
|
||||
- YOLOv6-S: 45,0% de AP a 484 FPS.
|
||||
- YOLOv6-M: 50,0% de AP a 226 FPS.
|
||||
- YOLOv6-L: 52,8% de AP a 116 FPS.
|
||||
- YOLOv6-L6: Precisão de última geração em tempo real.
|
||||
|
||||
O YOLOv6 também fornece modelos quantizados para diferentes precisões e modelos otimizados para plataformas móveis.
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
Este exemplo fornece exemplos simples de treinamento e inferência do YOLOv6. Para documentação completa sobre esses e outros [modos](../modes/index.md), consulte as páginas de documentação [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) e [Export](../modes/export.md).
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Modelos pré-treinados `*.pt` do PyTorch, assim como arquivos de configuração `*.yaml`, podem ser passados à classe `YOLO()` para criar uma instância do modelo em Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Constrói um modelo YOLOv6n do zero
|
||||
model = YOLO('yolov6n.yaml')
|
||||
|
||||
# Exibe informações do modelo (opcional)
|
||||
model.info()
|
||||
|
||||
# Treina o modelo no conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Executa inferência com o modelo YOLOv6n na imagem 'bus.jpg'
|
||||
results = model('caminho/para/onibus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Comandos da CLI estão disponíveis para executar diretamente os modelos:
|
||||
|
||||
```bash
|
||||
# Constrói um modelo YOLOv6n do zero e o treina no conjunto de dados de exemplo COCO8 por 100 épocas
|
||||
yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Constrói um modelo YOLOv6n do zero e executa inferência na imagem 'bus.jpg'
|
||||
yolo predict model=yolov6n.yaml source=caminho/para/onibus.jpg
|
||||
```
|
||||
|
||||
## Tarefas e Modos Suportados
|
||||
|
||||
A série YOLOv6 oferece uma variedade de modelos, cada um otimizado para [Detecção de Objetos](../tasks/detect.md) de alta performance. Esses modelos atendem a diferentes necessidades computacionais e requisitos de precisão, tornando-os versáteis para uma ampla variedade de aplicações.
|
||||
|
||||
| Tipo de Modelo | Pesos Pré-treinados | Tarefas Suportadas | Inferência | Validação | Treinamento | Exportação |
|
||||
|----------------|---------------------|-------------------------------------------|------------|-----------|-------------|------------|
|
||||
| YOLOv6-N | `yolov6-n.pt` | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-S | `yolov6-s.pt` | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-M | `yolov6-m.pt` | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-L | `yolov6-l.pt` | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-L6 | `yolov6-l6.pt` | [Detecção de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
Esta tabela fornece uma visão geral detalhada das variantes do modelo YOLOv6, destacando suas capacidades em tarefas de detecção de objetos e sua compatibilidade com vários modos operacionais, como [inferência](../modes/predict.md), [validação](../modes/val.md), [treinamento](../modes/train.md) e [exportação](../modes/export.md). Esse suporte abrangente garante que os usuários possam aproveitar totalmente as capacidades dos modelos YOLOv6 em uma ampla gama de cenários de detecção de objetos.
|
||||
|
||||
## Citações e Agradecimentos
|
||||
|
||||
Gostaríamos de agradecer aos autores por suas contribuições significativas no campo da detecção de objetos em tempo real:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{li2023yolov6,
|
||||
title={YOLOv6 v3.0: A Full-Scale Reloading},
|
||||
author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
|
||||
year={2023},
|
||||
eprint={2301.05586},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
O artigo original do YOLOv6 pode ser encontrado no [arXiv](https://arxiv.org/abs/2301.05586). Os autores disponibilizaram publicamente seu trabalho, e o código pode ser acessado no [GitHub](https://github.com/meituan/YOLOv6). Agradecemos seus esforços em avançar no campo e disponibilizar seu trabalho para a comunidade em geral.
|
||||
66
docs/pt/models/yolov7.md
Normal file
66
docs/pt/models/yolov7.md
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore o YOLOv7, um detector de objetos em tempo real. Entenda sua velocidade superior, impressionante precisão e foco exclusivo em otimização treinável de recursos gratuitos.
|
||||
keywords: YOLOv7, detector de objetos em tempo real, state-of-the-art, Ultralytics, conjunto de dados MS COCO, reparametrização de modelo, atribuição dinâmica de rótulo, escalonamento estendido, escalonamento composto
|
||||
---
|
||||
|
||||
# YOLOv7: Treinável Bag-of-Freebies
|
||||
|
||||
O YOLOv7 é um detector de objetos em tempo real state-of-the-art que supera todos os detectores de objetos conhecidos em termos de velocidade e precisão na faixa de 5 FPS a 160 FPS. Ele possui a maior precisão (56,8% de AP) entre todos os detectores de objetos em tempo real conhecidos com 30 FPS ou mais no GPU V100. Além disso, o YOLOv7 supera outros detectores de objetos, como YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 e muitos outros em velocidade e precisão. O modelo é treinado no conjunto de dados MS COCO do zero, sem usar outros conjuntos de dados ou pesos pré-treinados. O código-fonte para o YOLOv7 está disponível no GitHub.
|
||||
|
||||
|
||||
**Comparação de detectores de objetos state-of-the-art.
|
||||
** A partir dos resultados na Tabela 2, sabemos que o método proposto tem a melhor relação velocidade-precisão de forma abrangente. Se compararmos o YOLOv7-tiny-SiLU com o YOLOv5-N (r6.1), nosso método é 127 FPS mais rápido e 10,7% mais preciso em AP. Além disso, o YOLOv7 tem 51,4% de AP em uma taxa de quadros de 161 FPS, enquanto o PPYOLOE-L com o mesmo AP tem apenas uma taxa de quadros de 78 FPS. Em termos de uso de parâmetros, o YOLOv7 é 41% menor do que o PPYOLOE-L. Se compararmos o YOLOv7-X com uma velocidade de inferência de 114 FPS com o YOLOv5-L (r6.1) com uma velocidade de inferência de 99 FPS, o YOLOv7-X pode melhorar o AP em 3,9%. Se o YOLOv7-X for comparado com o YOLOv5-X (r6.1) de escala similar, a velocidade de inferência do YOLOv7-X é 31 FPS mais rápida. Além disso, em termos da quantidade de parâmetros e cálculos, o YOLOv7-X reduz 22% dos parâmetros e 8% dos cálculos em comparação com o YOLOv5-X (r6.1), mas melhora o AP em 2,2% ([Fonte](https://arxiv.org/pdf/2207.02696.pdf)).
|
||||
|
||||
## Visão Geral
|
||||
|
||||
A detecção de objetos em tempo real é um componente importante em muitos sistemas de visão computacional, incluindo rastreamento de múltiplos objetos, direção autônoma, robótica e análise de imagens médicas. Nos últimos anos, o desenvolvimento de detecção de objetos em tempo real tem se concentrado em projetar arquiteturas eficientes e melhorar a velocidade de inferência de várias CPUs, GPUs e unidades de processamento neural (NPUs). O YOLOv7 suporta tanto GPUs móveis quanto dispositivos GPU, desde a borda até a nuvem.
|
||||
|
||||
Ao contrário dos detectores de objetos em tempo real tradicionais que se concentram na otimização de arquitetura, o YOLOv7 introduz um foco na otimização do processo de treinamento. Isso inclui módulos e métodos de otimização projetados para melhorar a precisão da detecção de objetos sem aumentar o custo de inferência, um conceito conhecido como "treinável bag-of-freebies".
|
||||
|
||||
## Recursos Principais
|
||||
|
||||
O YOLOv7 apresenta vários recursos principais:
|
||||
|
||||
1. **Reparametrização do Modelo**: O YOLOv7 propõe um modelo reparametrizado planejado, que é uma estratégia aplicável a camadas em diferentes redes com o conceito de caminho de propagação de gradiente.
|
||||
|
||||
2. **Atribuição Dinâmica de Rótulo**: O treinamento do modelo com várias camadas de saída apresenta um novo problema: "Como atribuir alvos dinâmicos para as saídas de diferentes ramificações?" Para resolver esse problema, o YOLOv7 introduz um novo método de atribuição de rótulo chamado atribuição de rótulo orientada por liderança de granularidade fina (coarse-to-fine).
|
||||
|
||||
3. **Escalonamento Estendido e Composto**: O YOLOv7 propõe métodos de "escalonamento estendido" e "escalonamento composto" para o detector de objetos em tempo real que podem utilizar efetivamente parâmetros e cálculos.
|
||||
|
||||
4. **Eficiência**: O método proposto pelo YOLOv7 pode reduzir efetivamente cerca de 40% dos parâmetros e 50% dos cálculos do detector de objetos em tempo real state-of-the-art, além de apresentar uma velocidade de inferência mais rápida e maior precisão de detecção.
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
No momento em que este texto foi escrito, a Ultralytics ainda não oferece suporte aos modelos YOLOv7. Portanto, qualquer usuário interessado em usar o YOLOv7 precisará se referir diretamente ao repositório do YOLOv7 no GitHub para obter instruções de instalação e uso.
|
||||
|
||||
Aqui está uma breve visão geral das etapas típicas que você pode seguir para usar o YOLOv7:
|
||||
|
||||
1. Acesse o repositório do YOLOv7 no GitHub: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7).
|
||||
|
||||
2. Siga as instruções fornecidas no arquivo README para a instalação. Isso normalmente envolve clonar o repositório, instalar as dependências necessárias e configurar quaisquer variáveis de ambiente necessárias.
|
||||
|
||||
3. Após a conclusão da instalação, você pode treinar e usar o modelo conforme as instruções de uso fornecidas no repositório. Isso geralmente envolve a preparação do conjunto de dados, a configuração dos parâmetros do modelo, o treinamento do modelo e, em seguida, o uso do modelo treinado para realizar a detecção de objetos.
|
||||
|
||||
Observe que as etapas específicas podem variar dependendo do caso de uso específico e do estado atual do repositório do YOLOv7. Portanto, é altamente recomendável consultar diretamente as instruções fornecidas no repositório do YOLOv7 no GitHub.
|
||||
|
||||
Lamentamos qualquer inconveniente que isso possa causar e nos esforçaremos para atualizar este documento com exemplos de uso para a Ultralytics assim que o suporte para o YOLOv7 for implementado.
|
||||
|
||||
## Citações e Agradecimentos
|
||||
|
||||
Gostaríamos de agradecer aos autores do YOLOv7 por suas contribuições significativas no campo da detecção de objetos em tempo real:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{wang2022yolov7,
|
||||
title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
|
||||
author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
|
||||
journal={arXiv preprint arXiv:2207.02696},
|
||||
year={2022}
|
||||
}
|
||||
```
|
||||
|
||||
O artigo original do YOLOv7 pode ser encontrado no [arXiv](https://arxiv.org/pdf/2207.02696.pdf). Os autores disponibilizaram publicamente seu trabalho, e o código pode ser acessado no [GitHub](https://github.com/WongKinYiu/yolov7). Agradecemos seus esforços em avançar o campo e tornar seu trabalho acessível à comunidade em geral.
|
||||
162
docs/pt/models/yolov8.md
Normal file
162
docs/pt/models/yolov8.md
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore as emocionantes características do YOLOv8, a versão mais recente do nosso detector de objetos em tempo real! Saiba como as arquiteturas avançadas, modelos pré-treinados e o equilíbrio ideal entre precisão e velocidade tornam o YOLOv8 a escolha perfeita para as suas tarefas de detecção de objetos.
|
||||
keywords: YOLOv8, Ultralytics, detector de objetos em tempo real, modelos pré-treinados, documentação, detecção de objetos, série YOLO, arquiteturas avançadas, precisão, velocidade
|
||||
---
|
||||
|
||||
# YOLOv8
|
||||
|
||||
## Visão Geral
|
||||
|
||||
O YOLOv8 é a versão mais recente da série YOLO de detectores de objetos em tempo real, oferecendo um desempenho de ponta em termos de precisão e velocidade. Construindo sobre as inovações das versões anteriores do YOLO, o YOLOv8 introduz novas características e otimizações que o tornam uma escolha ideal para diversas tarefas de detecção de objetos em uma ampla variedade de aplicações.
|
||||
|
||||
|
||||
|
||||
## Principais Características
|
||||
|
||||
- **Arquiteturas Avançadas de Backbone e Neck:** O YOLOv8 utiliza arquiteturas avançadas de backbone e neck, resultando em uma melhor extração de características e desempenho na detecção de objetos.
|
||||
- **Anchor-free Split Ultralytics Head:** O YOLOv8 adota um head Ultralytics dividido sem ancoragem, o que contribui para uma melhor precisão e um processo de detecção mais eficiente em comparação com abordagens baseadas em âncoras.
|
||||
- **Equilíbrio Otimizado entre Precisão e Velocidade:** Com foco em manter um equilíbrio ideal entre precisão e velocidade, o YOLOv8 é adequado para tarefas de detecção de objetos em tempo real em diversas áreas de aplicação.
|
||||
- **Variedade de Modelos Pré-treinados:** O YOLOv8 oferece uma variedade de modelos pré-treinados para atender a diversas tarefas e requisitos de desempenho, tornando mais fácil encontrar o modelo adequado para o seu caso de uso específico.
|
||||
|
||||
## Tarefas e Modos Suportados
|
||||
|
||||
A série YOLOv8 oferece uma variedade de modelos, cada um especializado em tarefas específicas de visão computacional. Esses modelos são projetados para atender a diversos requisitos, desde a detecção de objetos até tarefas mais complexas, como segmentação de instâncias, detecção de poses/pontos-chave e classificação.
|
||||
|
||||
Cada variante da série YOLOv8 é otimizada para a respectiva tarefa, garantindo alto desempenho e precisão. Além disso, esses modelos são compatíveis com diversos modos operacionais, incluindo [Inferência](../modes/predict.md), [Validação](../modes/val.md), [Treinamento](../modes/train.md) e [Exportação](../modes/export.md), facilitando o uso em diferentes estágios de implantação e desenvolvimento.
|
||||
|
||||
| Modelo | Nomes de Arquivo | Tarefa | Inferência | Validação | Treinamento | Exportação |
|
||||
|-------------|----------------------------------------------------------------------------------------------------------------|--------------------------------------------------|------------|-----------|-------------|------------|
|
||||
| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Detecção](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Segmentação de Instâncias](../tasks/segment.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [Pose/Pontos-chave](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Classificação](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
Esta tabela fornece uma visão geral das variantes de modelos YOLOv8, destacando suas aplicações em tarefas específicas e sua compatibilidade com diversos modos operacionais, como inferência, validação, treinamento e exportação. Ela demonstra a versatilidade e robustez da série YOLOv8, tornando-os adequados para diversas aplicações em visão computacional.
|
||||
|
||||
## Métricas de Desempenho
|
||||
|
||||
!!! Desempenho
|
||||
|
||||
=== "Detecção (COCO)"
|
||||
|
||||
Consulte a [Documentação de Detecção](https://docs.ultralytics.com/tasks/detect/) para exemplos de uso com esses modelos treinados no conjunto de dados [COCO](https://docs.ultralytics.com/datasets/detect/coco/), que inclui 80 classes pré-treinadas.
|
||||
|
||||
| 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 |
|
||||
|
||||
=== "Detecção (Open Images V7)"
|
||||
|
||||
Consulte a [Documentação de Detecção](https://docs.ultralytics.com/tasks/detect/) para exemplos de uso com esses modelos treinados no conjunto de dados [Open Images V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), que inclui 600 classes pré-treinadas.
|
||||
|
||||
| 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-oiv7.pt) | 640 | 18,4 | 142,4 | 1,21 | 3,5 | 10,5 |
|
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-oiv7.pt) | 640 | 27,7 | 183,1 | 1,40 | 11,4 | 29,7 |
|
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-oiv7.pt) | 640 | 33,6 | 408,5 | 2,26 | 26,2 | 80,6 |
|
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-oiv7.pt) | 640 | 34,9 | 596,9 | 2,43 | 44,1 | 167,4 |
|
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-oiv7.pt) | 640 | 36,3 | 860,6 | 3,56 | 68,7 | 260,6 |
|
||||
|
||||
=== "Segmentação (COCO)"
|
||||
|
||||
Consulte a [Documentação de Segmentação](https://docs.ultralytics.com/tasks/segment/) para exemplos de uso com esses modelos treinados no conjunto de dados [COCO](https://docs.ultralytics.com/datasets/segment/coco/), que inclui 80 classes pré-treinadas.
|
||||
|
||||
| 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 |
|
||||
|
||||
=== "Classificação (ImageNet)"
|
||||
|
||||
Consulte a [Documentação de Classificação](https://docs.ultralytics.com/tasks/classify/) para exemplos de uso com esses modelos treinados no conjunto de dados [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), que inclui 1000 classes pré-treinadas.
|
||||
|
||||
| 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 |
|
||||
|
||||
=== "Pose (COCO)"
|
||||
|
||||
Consulte a [Documentação de Estimativa de Pose](https://docs.ultralytics.com/tasks/segment/) para exemplos de uso com esses modelos treinados no conjunto de dados [COCO](https://docs.ultralytics.com/datasets/pose/coco/), que inclui 1 classe pré-treinada, 'person'.
|
||||
|
||||
| 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 |
|
||||
|
||||
## Exemplos de Uso
|
||||
|
||||
Este exemplo fornece exemplos simples de treinamento e inferência do YOLOv8. Para a documentação completa desses e outros [modos](../modes/index.md), consulte as páginas de documentação [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) e [Export](../modes/export.md).
|
||||
|
||||
Observe que o exemplo abaixo é para modelos YOLOv8 de [Detecção](../tasks/detect.md) para detecção de objetos. Para outras tarefas suportadas, consulte a documentação de [Segmentação](../tasks/segment.md), [Classificação](../tasks/classify.md) e [Pose](../tasks/pose.md).
|
||||
|
||||
!!! Example "Exemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Modelos pré-treinados `*.pt` PyTorch, bem como arquivos de configuração `*.yaml`, podem ser passados para a classe `YOLO()` para criar uma instância do modelo em Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Carregar um modelo YOLOv8n pré-treinado para COCO
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Exibir informações do modelo (opcional)
|
||||
model.info()
|
||||
|
||||
# Treinar o modelo no exemplo de conjunto de dados 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('caminho/para/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Comandos da CLI estão disponíveis para executar os modelos diretamente:
|
||||
|
||||
```bash
|
||||
# Carregar um modelo YOLOv8n pré-treinado para COCO e treiná-lo no exemplo de conjunto de dados COCO8 por 100 épocas
|
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Carregar um modelo YOLOv8n pré-treinado para COCO e executar inferência na imagem 'bus.jpg'
|
||||
yolo predict model=yolov8n.pt source=caminho/para/bus.jpg
|
||||
```
|
||||
|
||||
## Citações e Reconhecimentos
|
||||
|
||||
Se você utilizar o modelo YOLOv8 ou qualquer outro software deste repositório em seu trabalho, por favor cite-o utilizando o formato abaixo:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@software{yolov8_ultralytics,
|
||||
author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu},
|
||||
title = {Ultralytics YOLOv8},
|
||||
version = {8.0.0},
|
||||
year = {2023},
|
||||
url = {https://github.com/ultralytics/ultralytics},
|
||||
orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069},
|
||||
license = {AGPL-3.0}
|
||||
}
|
||||
```
|
||||
|
||||
Observe que o DOI está pendente e será adicionado à citação assim que estiver disponível. Os modelos YOLOv8 são disponibilizados sob as licenças [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) e [Enterprise](https://ultralytics.com/license).
|
||||
Loading…
Add table
Add a link
Reference in a new issue