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

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

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

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

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

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

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

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

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

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

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

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

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