Add Docs languages zh, es, ru, pt, fr, de, ja, ko (#6316)
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
e3a538bbde
commit
48e70f0921
144 changed files with 17632 additions and 76 deletions
127
docs/ko/datasets/index.md
Normal file
127
docs/ko/datasets/index.md
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics가 지원하는 객체 탐지, 세분화, 자세 추정, 이미지 분류, 다중 객체 추적을 위한 다양한 컴퓨터 비전 데이터셋에 대한 탐색입니다.
|
||||
keywords: 컴퓨터 비전, 데이터셋, Ultralytics, YOLO, 객체 탐지, 인스턴스 세분화, 자세 추정, 이미지 분류, 다중 객체 추적
|
||||
---
|
||||
|
||||
# 데이터셋 개요
|
||||
|
||||
Ultralytics는 탐지, 인스턴스 세분화, 자세 추정, 분류 및 다중 객체 추적과 같은 컴퓨터 비전 작업을 촉진하기 위해 다양한 데이터셋을 지원합니다. 아래는 주요 Ultralytics 데이터셋 목록과 각 컴퓨터 비전 작업의 요약, 그리고 해당 데이터셋입니다.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 다국어 문서 작업은 현재 진행 중이며, 우리는 이를 개선하기 위해 노력하고 있습니다. 인내해 주셔서 감사합니다! 🙏
|
||||
|
||||
## [탐지 데이터셋](../../datasets/detect/index.md)
|
||||
|
||||
바운딩 박스 객체 탐지는 이미지 내 객체들을 탐지하고 각 객체 주위에 바운딩 박스를 그려 객체를 위치시키는 컴퓨터 비전 기법입니다.
|
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md): 도시 환경에서의 3D 추적 및 동작 예측 데이터와 풍부한 주석이 담긴 데이터셋입니다.
|
||||
- [COCO](../../datasets/detect/coco.md): 20만개가 넘는 레이블이 붙은 이미지로 설계된 객체 탐지, 세분화 및 설명을 위한 대규모 데이터셋입니다.
|
||||
- [COCO8](../../datasets/detect/coco8.md): COCO train 및 COCO val에서 처음 4개의 이미지를 포함하여 신속한 테스트에 적합합니다.
|
||||
- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): 전 세계에서 수집한 밀 머리 이미지로 구성된 객체 탐지 및 위치 지정 작업을 위한 데이터셋입니다.
|
||||
- [Objects365](../../datasets/detect/objects365.md): 365개 객체 카테고리와 60만개가 넘는 주석이 달린 이미지를 포함하는 고품질 대규모 객체 탐지용 데이터셋입니다.
|
||||
- [OpenImagesV7](../../datasets/detect/open-images-v7.md): 구글에서 제공하는 170만개의 훈련 이미지와 4만 2천개의 검증 이미지를 포함하는 포괄적인 데이터셋입니다.
|
||||
- [SKU-110K](../../datasets/detect/sku-110k.md): 1만 1천 개의 이미지와 170만 개의 바운딩 박스를 특징으로 하는 소매 환경에서 밀집된 객체 탐지를 위한 데이터셋입니다.
|
||||
- [VisDrone](../../datasets/detect/visdrone.md): 드론으로 촬영한 영상에서 객체 탐지 및 다중 객체 추적 데이터를 포함하는 데이터셋으로 1만 개가 넘는 이미지와 비디오 시퀀스를 포함합니다.
|
||||
- [VOC](../../datasets/detect/voc.md): 객체 탐지와 세분화를 위한 파스칼 시각 객체 클래스(VOC) 데이터셋으로 20개 객체 클래스와 1만 1천 개가 넘는 이미지를 포함합니다.
|
||||
- [xView](../../datasets/detect/xview.md): 상공 이미지에서 객체 탐지를 위한 데이터셋으로 60개 객체 카테고리와 100만 개가 넘는 주석이 달린 객체를 포함합니다.
|
||||
|
||||
## [인스턴스 세분화 데이터셋](../../datasets/segment/index.md)
|
||||
|
||||
인스턴스 세분화는 이미지 내 객체들을 픽셀 수준에서 식별하고 위치를 지정하는 컴퓨터 비전 기법입니다.
|
||||
|
||||
- [COCO](../../datasets/segment/coco.md): 객체 탐지, 세분화 및 설명 작업을 위해 설계된 20만개가 넘는 레이블이 붙은 이미지로 구성된 대규모 데이터셋입니다.
|
||||
- [COCO8-seg](../../datasets/segment/coco8-seg.md): 세분화 주석이 있는 8개의 COCO 이미지로 구성된 인스턴스 세분화 작업을 위한 더 작은 데이터셋입니다.
|
||||
|
||||
## [자세 추정](../../datasets/pose/index.md)
|
||||
|
||||
자세 추정은 카메라 또는 세계 좌표계에 대한 객체의 자세를 결정하는 기술입니다.
|
||||
|
||||
- [COCO](../../datasets/pose/coco.md): 자세 추정 작업을 위해 사람의 자세 주석이 달린 대규모 데이터셋입니다.
|
||||
- [COCO8-pose](../../datasets/pose/coco8-pose.md): 인간의 자세 주석이 포함된 8개의 COCO 이미지로 구성된 자세 추정 작업을 위한 더 작은 데이터셋입니다.
|
||||
- [Tiger-pose](../../datasets/pose/tiger-pose.md): 자세 추정 작업을 위한 호랑이를 포함한 263개 이미지로 구성된 컴팩트한 데이터셋으로, 호랑이당 12개의 키포인트가 주석으로 표시되어 있습니다.
|
||||
|
||||
## [분류](../../datasets/classify/index.md)
|
||||
|
||||
이미지 분류는 이미지의 시각적 내용을 기반으로 이미지를 하나 이상의 미리 정의된 클래스나 카테고리로 분류하는 컴퓨터 비전 작업입니다.
|
||||
|
||||
- [Caltech 101](../../datasets/classify/caltech101.md): 이미지 분류 작업을 위한 101개의 객체 카테고리를 포함하는 데이터셋입니다.
|
||||
- [Caltech 256](../../datasets/classify/caltech256.md): Caltech 101의 확장판으로 256개의 객체 카테고리와 더 어려운 이미지를 포함합니다.
|
||||
- [CIFAR-10](../../datasets/classify/cifar10.md): 각 클래스당 6천 개의 이미지를 포함하는 10개의 클래스로 구성된 60K 32x32 컬러 이미지 데이터셋입니다.
|
||||
- [CIFAR-100](../../datasets/classify/cifar100.md): CIFAR-10의 확장판으로 100개의 객체 카테고리 및 클래스 당 600개 이미지를 포함합니다.
|
||||
- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): 이미지 분류 작업을 위한 10개 패션 카테고리의 7만 개 그레이스케일 이미지를 포함하는 데이터셋입니다.
|
||||
- [ImageNet](../../datasets/classify/imagenet.md): 객체 탐지 및 이미지 분류를 위한 1400만 개의 이미지와 2만 개의 카테고리를 포함하는 대규모 데이터셋입니다.
|
||||
- [ImageNet-10](../../datasets/classify/imagenet10.md): 실험 및 테스트 속도를 높이기 위한 ImageNet의 10개 카테고리를 포함하는 더 작은 하위 집합입니다.
|
||||
- [Imagenette](../../datasets/classify/imagenette.md): 훈련과 테스트를 더 빠르게 진행할 수 있도록 쉽게 구별 가능한 클래스 10개를 포함하는 ImageNet의 더 작은 하위 집합입니다.
|
||||
- [Imagewoof](../../datasets/classify/imagewoof.md): 이미지 분류 작업을 위한 ImageNet의 더 어려운 하위 집합으로, 10개의 개 품종 카테고리를 포함합니다.
|
||||
- [MNIST](../../datasets/classify/mnist.md): 손으로 쓴 숫자의 7만 개 그레이스케일 이미지를 포함하는 이미지 분류 작업을 위한 데이터셋입니다.
|
||||
|
||||
## [지향 바운딩 박스 (OBB)](../../datasets/obb/index.md)
|
||||
|
||||
지향 바운딩 박스(OBB)는 이미지 내 비스듬한 객체를 회전된 바운딩 박스를 사용하여 탐지하는 컴퓨터 비전 방법으로, 종종 항공 및 위성 영상에 적용됩니다.
|
||||
|
||||
- [DOTAv2](../../datasets/obb/dota-v2.md): 170만 개 인스턴스와 1만 1천 268개 이미지를 포함하는 인기 있는 OBB 항공 이미지 데이터셋입니다.
|
||||
|
||||
## [다중 객체 추적](../../datasets/track/index.md)
|
||||
|
||||
다중 객체 추적은 비디오 시퀀스에서 시간에 걸쳐 여러 객체를 탐지하고 추적하는 컴퓨터 비전 기술입니다.
|
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md): 도시 환경에서의 3D 추적 및 동작 예측 데이터와 풍부한 주석으로 다중 객체 추적 작업을 위한 데이터셋입니다.
|
||||
- [VisDrone](../../datasets/detect/visdrone.md): 드론으로 촬영한 영상에서 객체 탐지 및 다중 객체 추적 데이터를 포함하는 데이터셋으로 1만 개가 넘는 이미지와 비디오 시퀀스를 포함합니다.
|
||||
|
||||
## 새 데이터셋 기여하기
|
||||
|
||||
새 데이터셋을 기여하는 것은 기존 인프라와 잘 조화되도록 보장하기 위해 여러 단계를 포함합니다. 아래는 필요한 단계입니다:
|
||||
|
||||
### 새 데이터셋 기여를 위한 단계
|
||||
|
||||
1. **이미지 수집**: 데이터셋에 속하는 이미지를 모읍니다. 이는 공공 데이터베이스 또는 자체 수집한 자료 등 다양한 출처에서 수집할 수 있습니다.
|
||||
|
||||
2. **이미지 주석 달기**: 이러한 이미지에 작업에 따라 바운딩 박스, 세그먼트 또는 키포인트로 주석을 답니다.
|
||||
|
||||
3. **주석 내보내기**: 이 주석들을 Ultralytics가 지원하는 YOLO *.txt 파일 형식으로 변환합니다.
|
||||
|
||||
4. **데이터셋 구성**: 데이터셋을 올바른 폴더 구조로 배열합니다. 'train/'과 'val/' 상위 디렉토리를 갖고 있어야 하며, 각각 'images/' 및 'labels/' 하위 디렉토리가 있어야 합니다.
|
||||
|
||||
```
|
||||
dataset/
|
||||
├── train/
|
||||
│ ├── images/
|
||||
│ └── labels/
|
||||
└── val/
|
||||
├── images/
|
||||
└── labels/
|
||||
```
|
||||
|
||||
5. **`data.yaml` 파일 생성**: 데이터셋의 루트 디렉토리에서 데이터셋, 클래스 및 기타 필요한 정보를 설명하는 `data.yaml` 파일을 만듭니다.
|
||||
|
||||
6. **이미지 최적화 (선택)**: 처리 과정을 더 효율적으로 하기 위해 데이터셋의 크기를 줄이고자 한다면 아래의 코드를 사용하여 이미지를 최적화할 수 있습니다. 필수는 아니지만, 데이터셋 크기를 작게하고 다운로드 속도를 빠르게 하는 것이 추천됩니다.
|
||||
|
||||
7. **데이터셋 압축**: 전체 데이터셋 폴더를 zip 파일로 압축합니다.
|
||||
|
||||
8. **문서화 및 PR**: 데이터셋에 대한 설명과 기존 프레임워크와의 적합성에 대해 설명하는 문서화 페이지를 만든 다음, 풀 리퀘스트(PR)를 제출합니다. PR을 제출하는 더 자세한 방법에 관해서는 [Ultralytics 기여 가이드라인](https://docs.ultralytics.com/help/contributing)을 참고하십시오.
|
||||
|
||||
### 데이터셋 최적화 및 압축 예제 코드
|
||||
|
||||
!!! example "데이터셋 최적화 및 압축"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from pathlib import Path
|
||||
from ultralytics.data.utils import compress_one_image
|
||||
from ultralytics.utils.downloads import zip_directory
|
||||
|
||||
# 데이터셋 디렉토리 정의
|
||||
path = Path('path/to/dataset')
|
||||
|
||||
# 데이터셋의 이미지 최적화 (선택사항)
|
||||
for f in path.rglob('*.jpg'):
|
||||
compress_one_image(f)
|
||||
|
||||
# 'path/to/dataset.zip'으로 데이터셋 압축
|
||||
zip_directory(path)
|
||||
```
|
||||
|
||||
이 단계들을 따르면 Ultralytics의 기존 구조와 잘 통합되는 새로운 데이터셋을 기여할 수 있습니다.
|
||||
82
docs/ko/index.md
Normal file
82
docs/ko/index.md
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics YOLOv8을 완벽하게 탐구하는 가이드로, 고속 및 정확성이 특징인 객체 탐지 및 이미지 분할 모델입니다. 설치, 예측, 훈련 튜토리얼 등이 포함되어 있습니다.
|
||||
keywords: Ultralytics, YOLOv8, 객체 탐지, 이미지 분할, 기계 학습, 딥러닝, 컴퓨터 비전, YOLOv8 설치, YOLOv8 예측, YOLOv8 훈련, YOLO 역사, YOLO 라이센스
|
||||
---
|
||||
|
||||
<div align="center">
|
||||
<p>
|
||||
<a href="https://yolovision.ultralytics.com" target="_blank">
|
||||
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Ultralytics YOLO 배너"></a>
|
||||
</p>
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://youtube.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Ultralytics Instagram"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
|
||||
<br>
|
||||
<br>
|
||||
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml/badge.svg" alt="Ultralytics CI"></a>
|
||||
<a href="https://codecov.io/github/ultralytics/ultralytics"><img src="https://codecov.io/github/ultralytics/ultralytics/branch/main/graph/badge.svg?token=HHW7IIVFVY" alt="Ultralytics 코드 커버리지"></a>
|
||||
<a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="YOLOv8 인용"></a>
|
||||
<a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Docker 당기기"></a>
|
||||
<br>
|
||||
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run on Gradient"/></a>
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
|
||||
<a href="https://www.kaggle.com/ultralytics/yolov8"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>
|
||||
</div>
|
||||
|
||||
Ultralytics의 최신 버전인 [YOLOv8](https://github.com/ultralytics/ultralytics)을 소개합니다. 이 모델은 딥러닝과 컴퓨터 비전의 최신 발전을 바탕으로 구축되었으며, 속도와 정확성 면에서 뛰어난 성능을 제공합니다. 간결한 설계로 인해 다양한 애플리케이션에 적합하며, 엣지 디바이스에서부터 클라우드 API에 이르기까지 다양한 하드웨어 플랫폼에 쉽게 적응 가능합니다.
|
||||
|
||||
YOLOv8 문서를 탐구하여, 그 기능과 능력을 이해하고 활용할 수 있도록 돕는 종합적인 자원입니다. 기계 학습 분야에서 경험이 많건, 새롭게 시작하는 이들이건, 이 허브는 YOLOv8의 잠재력을 극대화하기 위해 설계되었습니다.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 다국어 문서는 현재 제작 중이며, 이를 개선하기 위해 노력하고 있습니다. 인내해 주셔서 감사합니다! 🙏
|
||||
|
||||
## 시작하기
|
||||
|
||||
- **설치** `ultralytics`를 pip으로 설치하고 몇 분 만에 시작하세요 [:material-clock-fast: 시작하기](quickstart.md){ .md-button }
|
||||
- **예측** YOLOv8로 새로운 이미지와 비디오를 감지하세요 [:octicons-image-16: 이미지에서 예측하기](modes/predict.md){ .md-button }
|
||||
- **훈련** 새로운 YOLOv8 모델을 사용자의 맞춤 데이터셋으로 훈련하세요 [:fontawesome-solid-brain: 모델 훈련하기](modes/train.md){ .md-button }
|
||||
- **탐험** 세분화, 분류, 자세 인식, 추적과 같은 YOLOv8 작업 [:material-magnify-expand: 작업 탐험하기](tasks/index.md){ .md-button }
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
|
||||
title="YouTube 비디오 플레이어" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청하기:</strong> 사용자의 맞춤 데이터셋으로 YOLOv8 모델을 훈련하는 방법을 <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb" target="_blank">Google Colab</a>에서 알아보세요.
|
||||
</p>
|
||||
|
||||
## YOLO: 간단한 역사
|
||||
|
||||
[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once, 단 한 번의 검사)는 워싱턴 대학교의 Joseph Redmon과 Ali Farhadi가 개발한 인기 있는 객체 탐지 및 이미지 분할 모델입니다. 2015년에 출시된 YOLO는 그 빠른 속도와 정확성으로 인해 빠르게 인기를 얻었습니다.
|
||||
|
||||
- [YOLOv2](https://arxiv.org/abs/1612.08242)는 2016년에 공개되었으며 배치 정규화, 앵커 박스, 차원 클러스터를 통합하여 원본 모델을 개선했습니다.
|
||||
- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf)는 2018년에 출시되어 더 효율적인 백본 네트워크, 복수 앵커 및 공간 피라미드 풀링을 사용하여 모델의 성능을 더욱 향상시켰습니다.
|
||||
- [YOLOv4](https://arxiv.org/abs/2004.10934)는 2020년에 나와서 모자이크 데이터 증가, 새로운 앵커-프리 탐지 헤드, 새로운 손실 함수와 같은 혁신을 도입했습니다.
|
||||
- [YOLOv5](https://github.com/ultralytics/yolov5)는 모델의 성능을 더욱 향상시키고 하이퍼파라미터 최적화, 통합 실험 추적 및 인기 있는 수출 형식으로의 자동 수출과 같은 새로운 기능을 추가했습니다.
|
||||
- [YOLOv6](https://github.com/meituan/YOLOv6)는 2022년에 [Meituan](https://about.meituan.com/)에 의해 오픈 소스화되었으며, 이 회사의 자율 배달 로봇에서 사용되고 있습니다.
|
||||
- [YOLOv7](https://github.com/WongKinYiu/yolov7)는 COCO 키포인트 데이터셋에서의 자세 추정과 같은 추가 작업을 추가했습니다.
|
||||
- [YOLOv8](https://github.com/ultralytics/ultralytics)은 Ultralytics에서 출시한 YOLO의 최신 버전입니다. 첨단 상태 기술 모델로서, YOLOv8은 이전 버전들의 성공을 기반으로 새로운 기능과 개선 사항을 도입하여 성능, 유연성 및 효율성을 향상시켰습니다. YOLOv8은 [탐지](tasks/detect.md), [분할](tasks/segment.md), [자세 추정](tasks/pose.md), [추적](modes/track.md), [분류](tasks/classify.md)를 포함하여 다양한 비전 AI 작업을 지원합니다. 이러한 다재다능함은 사용자들이 다양한 애플리케이션과 도메인 전반에 걸쳐 YOLOv8의 능력을 활용할 수 있도록 합니다.
|
||||
|
||||
## YOLO 라이센스: Ultralytics YOLO는 어떻게 라이센스가 부여되나요?
|
||||
|
||||
Ultralytics는 다양한 사용 사례에 맞춰 두 가지 라이선스 옵션을 제공합니다:
|
||||
|
||||
- **AGPL-3.0 라이선스**: 이 [OSI 승인](https://opensource.org/licenses/) 오픈 소스 라이선스는 학생 및 애호가에게 이상적입니다. 오픈 협력과 지식 공유를 촉진합니다. 자세한 내용은 [라이선스](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) 파일을 참조하세요.
|
||||
- **기업 라이선스**: 상업적 사용을 위해 설계된 이 라이선스는 Ultralytics 소프트웨어 및 AI 모델을 상업적 제품 및 서비스에 원활하게 통합할 수 있게 하여 AGPL-3.0의 오픈 소스 요건을 우회할 수 있습니다. 상업적 제공물에 솔루션을 내장하는 시나리오에 관여하는 경우 [Ultralytics 라이선싱](https://ultralytics.com/license)을 통해 문의하시기 바랍니다.
|
||||
|
||||
우리의 라이선스 전략은 오픈 소스 프로젝트에 대한 개선 사항이 커뮤니티에 되돌아가도록 보장하려는 것입니다. 우리는 오픈 소스의 원칙을 가슴 깊이 새기고 있으며, 우리의 기여가 모두에게 유용한 방식으로 활용되고 확장될 수 있도록 보장하는 것이 우리의 사명입니다.❤️
|
||||
94
docs/ko/models/index.md
Normal file
94
docs/ko/models/index.md
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics에서 지원하는 YOLO 계열, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR 모델의 다양한 범위를 탐색하고 CLI 및 Python 사용 예시를 통해 시작해 보세요.
|
||||
keywords: Ultralytics, 문서화, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, 모델, 아키텍처, Python, CLI
|
||||
---
|
||||
|
||||
# Ultralytics에서 지원하는 모델
|
||||
|
||||
Ultralytics 모델 문서에 오신 것을 환영합니다! 저희는 [객체 검출](../tasks/detect.md), [인스턴스 분할](../tasks/segment.md), [이미지 분류](../tasks/classify.md), [자세 추정](../tasks/pose.md), [다중 객체 추적](../modes/track.md) 등 특정 작업에 맞춤화된 다양한 모델을 지원합니다. Ultralytics에 모델 아키텍처를 기여하고자 한다면, 저희의 [기여 가이드](../../help/contributing.md)를 확인해 주세요.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 현재 다국어 문서화 작업이 진행 중이며 문서를 개선하기 위해 열심히 작업하고 있습니다. 기다려 주셔서 감사합니다! 🙏
|
||||
|
||||
## 주요 모델
|
||||
|
||||
여기 몇 가지 주요 모델을 소개합니다:
|
||||
|
||||
1. **[YOLOv3](../../models/yolov3.md)**: Joseph Redmon에 의해 처음 제안된 YOLO 모델 계열의 세 번째 버전으로, 효율적인 실시간 객체 검출 능력으로 알려져 있습니다.
|
||||
2. **[YOLOv4](../../models/yolov4.md)**: 2020년 Alexey Bochkovskiy에 의해 발표된 YOLOv3의 다크넷 기반 업데이트 버전입니다.
|
||||
3. **[YOLOv5](../../models/yolov5.md)**: Ultralytics에 의해 개선된 YOLO 아키텍처 버전으로, 이전 버전들과 비교해 더 나은 성능 및 속도 저하를 제공합니다.
|
||||
4. **[YOLOv6](../../models/yolov6.md)**: 2022년 [Meituan](https://about.meituan.com/)에 의해 발표되었으며, 회사의 자율 배송 로봇에 많이 사용되고 있습니다.
|
||||
5. **[YOLOv7](../../models/yolov7.md)**: YOLOv4의 저자들에 의해 2022년에 발표된 업데이트된 YOLO 모델입니다.
|
||||
6. **[YOLOv8](../../models/yolov8.md)**: YOLO 계열의 최신 버전으로, 인스턴스 분할, 자세/키포인트 추정 및 분류 등 향상된 기능을 제공합니다.
|
||||
7. **[Segment Anything Model (SAM)](../../models/sam.md)**: Meta의 Segment Anything Model (SAM)입니다.
|
||||
8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)**: 경희대학교에 의한 모바일 애플리케이션용 MobileSAM입니다.
|
||||
9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)**: 중국 과학원 자동화 연구소의 영상 및 비디오 분석 그룹에 의한 FastSAM입니다.
|
||||
10. **[YOLO-NAS](../../models/yolo-nas.md)**: YOLO Neural Architecture Search (NAS) 모델입니다.
|
||||
11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)**: Baidu의 PaddlePaddle Realtime Detection Transformer (RT-DETR) 모델입니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/MWq1UxqTClU?si=nHAW-lYDzrz68jR0"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>보기:</strong> 몇 줄의 코드로 Ultralytics YOLO 모델을 실행하세요.
|
||||
</p>
|
||||
|
||||
## 시작하기: 사용 예시
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
PyTorch로 사전훈련된 `*.pt` 모델과 구성 `*.yaml` 파일은 Python에서 `YOLO()`, `SAM()`, `NAS()` 및 `RTDETR()` 클래스에 전달하여 모델 인스턴스를 생성할 수 있습니다:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# COCO 사전훈련된 YOLOv8n 모델을 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 모델 정보 표시 (선택 사항)
|
||||
model.info()
|
||||
|
||||
# COCO8 예시 데이터셋에서 YOLOv8n 모델로 100 에포크 동안 훈련
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# 'bus.jpg' 이미지에 YOLOv8n 모델로 추론 실행
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
모델을 직접 실행하기 위한 CLI 커맨드도 제공됩니다:
|
||||
|
||||
```bash
|
||||
# COCO 사전훈련된 YOLOv8n 모델을 로드하고 COCO8 예시 데이터셋에서 100 에포크 동안 훈련
|
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# COCO 사전훈련된 YOLOv8n 모델을 로드하고 'bus.jpg' 이미지에서 추론 실행
|
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## 새 모델 기여하기
|
||||
|
||||
Ultralytics에 모델을 기여하고 싶으신가요? 훌륭합니다! 저희는 항상 모델 포트폴리오를 확장하는 것에 개방적입니다.
|
||||
|
||||
1. **저장소를 포크하세요**: [Ultralytics GitHub 저장소](https://github.com/ultralytics/ultralytics)를 포크하며 시작하세요.
|
||||
|
||||
2. **포크를 클론하세요**: 로컬 기기에 포크한 저장소를 클론하고 작업할 새 브랜치를 만드세요.
|
||||
|
||||
3. **모델 구현하기**: 저희의 [기여 가이드](../../help/contributing.md)에 제시된 코딩 표준과 가이드라인을 따라 모델을 추가하세요.
|
||||
|
||||
4. **철저히 테스트하기**: 파이프라인의 일부로서 뿐만 아니라 독립적으로도 모델을 철저히 테스트하세요.
|
||||
|
||||
5. **풀 리퀘스트 생성하기**: 모델에 만족하게 되면, 리뷰를 위해 메인 저장소로 풀 리퀘스트를 생성하세요.
|
||||
|
||||
6. **코드 리뷰 및 병합**: 리뷰 이후, 모델이 저희의 기준을 만족한다면 메인 저장소로 병합될 것입니다.
|
||||
|
||||
자세한 단계는 저희의 [기여 가이드](../../help/contributing.md)를 참조하세요.
|
||||
94
docs/ko/modes/benchmark.md
Normal file
94
docs/ko/modes/benchmark.md
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8의 다양한 내보내기 형식에 걸쳐 속도 및 정확성을 프로파일링하는 방법을 알아보고, mAP50-95, accuracy_top5 메트릭 및 기타에 대한 통찰을 얻으십시오.
|
||||
keywords: Ultralytics, YOLOv8, 벤치마킹, 속도 프로파일링, 정확도 프로파일링, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, YOLO 내보내기 형식
|
||||
---
|
||||
|
||||
# Ultralytics YOLO를 사용한 모델 벤치마킹
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO 생태계 및 통합">
|
||||
|
||||
## 소개
|
||||
|
||||
모델을 학습하고 검증한 후, 다음으로 논리적인 단계는 다양한 실제 상황에서의 성능을 평가하는 것입니다. Ultralytics YOLOv8의 벤치마크 모드는 다양한 내보내기 형식에서 모델의 속도와 정확도를 평가하는 강력한 프레임워크를 제공하여 이와 같은 목적을 수행하는 역할을 합니다.
|
||||
|
||||
## 벤치마킹이 왜 중요한가요?
|
||||
|
||||
- **정보에 기반한 결정:** 속도와 정확도 사이의 타협점에 대한 통찰력을 얻을 수 있습니다.
|
||||
- **자원 배분:** 다양한 하드웨어에서 각기 다른 내보내기 형식의 성능을 이해합니다.
|
||||
- **최적화:** 특정 사용 사례에 가장 적합한 내보내기 형식을 알아냅니다.
|
||||
- **비용 효율성:** 벤치마크 결과에 기반하여 하드웨어 자원을 보다 효율적으로 사용합니다.
|
||||
|
||||
### 벤치마크 모드의 주요 메트릭
|
||||
|
||||
- **mAP50-95:** 객체 인식, 세분화, 자세 추정에 사용됩니다.
|
||||
- **accuracy_top5:** 이미지 분류에 사용됩니다.
|
||||
- **추론 시간:** 각 이미지 당 밀리초로 측정된 시간입니다.
|
||||
|
||||
### 지원되는 내보내기 형식
|
||||
|
||||
- **ONNX:** CPU 성능 최적화를 위함
|
||||
- **TensorRT:** GPU 효율성을 극대화하기 위함
|
||||
- **OpenVINO:** 인텔 하드웨어 최적화를 위함
|
||||
- **CoreML, TensorFlow SavedModel, 그 외:** 다양한 배포 요구 사항을 위함.
|
||||
|
||||
!!! 팁 "팁"
|
||||
|
||||
* CPU 속도 향상을 위해 ONNX 또는 OpenVINO로 내보내기.
|
||||
* GPU 속도 향상을 위해 TensorRT로 내보내기.
|
||||
|
||||
## 사용 예제
|
||||
|
||||
YOLOv8n 벤치마킹을 ONNX, TensorRT 등 모든 지원되는 내보내기 형식에 대해 실행합니다. 완벽한 내보내기 인수 목록을 보려면 아래의 인수 섹션을 참조하세요.
|
||||
|
||||
!!! 예제 ""
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics.utils.benchmarks import benchmark
|
||||
|
||||
# GPU에서 벤치마킹
|
||||
benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
|
||||
```
|
||||
|
||||
## 인수
|
||||
|
||||
`model`, `data`, `imgsz`, `half`, `device`, `verbose`와 같은 인수들은 사용자들이 벤치마킹을 특정 필요에 맞게 조정하고 쉽게 다른 내보내기 형식의 성능을 비교할 수 있도록 유연성을 제공합니다.
|
||||
|
||||
| 키 | 값 | 설명 |
|
||||
|-----------|---------|----------------------------------------------------------|
|
||||
| `model` | `None` | 모델 파일 경로, 예: yolov8n.pt, yolov8n.yaml |
|
||||
| `data` | `None` | 벤치마킹 데이터 세트를 참조하는 YAML 경로 ('val' 레이블 아래) |
|
||||
| `imgsz` | `640` | 스칼라 또는 (h, w) 리스트 형태의 이미지 크기, 예: (640, 480) |
|
||||
| `half` | `False` | FP16 양자화 |
|
||||
| `int8` | `False` | INT8 양자화 |
|
||||
| `device` | `None` | 실행할 기기, 예: CUDA device=0 혹은 device=0,1,2,3 또는 device=cpu |
|
||||
| `verbose` | `False` | 오류 시 계속하지 않음 (bool), 또는 val 하한 임계값 (float) |
|
||||
|
||||
## 내보내기 형식
|
||||
|
||||
벤치마크는 아래에 나와있는 가능한 모든 내보내기 형식에서 자동으로 실행을 시도합니다.
|
||||
|
||||
| 형식 | `format` 인자 | 모델 | 메타데이터 | 인수 |
|
||||
|--------------------------------------------------------------------|---------------|---------------------------|-------|-----------------------------------------------------|
|
||||
| [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` |
|
||||
|
||||
전체 `export` 세부 정보는 [Export](https://docs.ultralytics.com/modes/export/) 페이지에서 확인할 수 있습니다.
|
||||
108
docs/ko/modes/export.md
Normal file
108
docs/ko/modes/export.md
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8 모델을 ONNX, TensorRT, CoreML 등의 다양한 형식으로 내보내는 단계별 가이드를 확인해보세요. 이제 배포를 진행해보세요!.
|
||||
keywords: YOLO, YOLOv8, Ultralytics, 모델 내보내기, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, 모델 내보내기
|
||||
---
|
||||
|
||||
# Ultralytics YOLO를 사용한 모델 내보내기
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO 생태계 및 통합">
|
||||
|
||||
## 소개
|
||||
|
||||
모델을 훈련하는 최종 목적은 실제 환경에서 배포하기 위함입니다. Ultralytics YOLOv8의 내보내기 모드는 훈련된 모델을 다양한 형식으로 내보내어 여러 플랫폼과 디바이스에서 배포할 수 있는 범용적인 옵션을 제공합니다. 이 포괄적인 가이드는 모델 내보내기의 미묘한 점들을 설명하고 최대의 호환성과 성능을 달성하는 방법을 안내하는 것을 목표로 합니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/WbomGeoOT_k?si=aGmuyooWftA0ue9X"
|
||||
title="YouTube 비디오 플레이어" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청하기:</strong> 사용자 지정 훈련된 Ultralytics YOLOv8 모델을 내보내고 웹캠에서 실시간 추론을 실행하는 방법.
|
||||
</p>
|
||||
|
||||
## YOLOv8의 내보내기 모드를 선택해야 하는 이유는 무엇인가요?
|
||||
|
||||
- **범용성:** ONNX, TensorRT, CoreML 등 다양한 형식으로 내보낼 수 있습니다.
|
||||
- **성능:** TensorRT를 사용할 경우 최대 5배 빠른 GPU 속도 향상 및 ONNX 또는 OpenVINO를 사용하여 최대 3배 빠른 CPU 속도 향상을 얻을 수 있습니다.
|
||||
- **호환성:** 모델을 다양한 하드웨어 및 소프트웨어 환경에서 배포할 수 있도록 만들어줍니다.
|
||||
- **사용의 용이성:** 모델 내보내기를 위한 간단한 CLI 및 Python API 제공.
|
||||
|
||||
### 내보내기 모드의 주요 기능
|
||||
|
||||
다음은 몇 가지 주요 기능들입니다:
|
||||
|
||||
- **원클릭 내보내기:** 다양한 형식으로 내보내기 위한 간단한 명령어.
|
||||
- **배치 내보내기:** 배치 추론이 가능한 모델들을 내보낼 수 있습니다.
|
||||
- **최적화된 추론:** 내보낸 모델들은 더 빠른 추론 시간을 위해 최적화되어 있습니다.
|
||||
- **튜토리얼 비디오:** 원활한 내보내기 경험을 위한 심도 있는 가이드 및 튜토리얼.
|
||||
|
||||
!!! 팁 "팁"
|
||||
|
||||
* CPU 속도 향상을 위해 ONNX 또는 OpenVINO로 내보내세요.
|
||||
* GPU 속도 향상을 위해 TensorRT로 내보내세요.
|
||||
|
||||
## 사용 예시
|
||||
|
||||
YOLOv8n 모델을 ONNX나 TensorRT와 같은 다른 형식으로 내보냅니다. 내보내기 인수에 대한 전체 목록은 아래 '인수' 섹션을 참조하세요.
|
||||
|
||||
!!! 예시 ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 불러오기
|
||||
model = YOLO('yolov8n.pt') # 공식 모델을 불러오기
|
||||
model = YOLO('path/to/best.pt') # 사용자 지정 훈련 모델을 불러오기
|
||||
|
||||
# 모델을 내보내기
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n.pt format=onnx # 공식 모델을 내보내기
|
||||
yolo export model=path/to/best.pt format=onnx # 사용자 지정 훈련 모델을 내보내기
|
||||
```
|
||||
|
||||
## 인수
|
||||
|
||||
YOLO 모델의 내보내기 설정은 다른 환경이나 플랫폼에서 모델을 사용하기 위해 저장 또는 내보내기할 때 사용하는 다양한 구성 및 옵션을 의미합니다. 이러한 설정은 모델의 성능, 크기 및 다양한 시스템과의 호환성에 영향을 미칠 수 있습니다. 일반적인 YOLO 내보내기 설정에는 내보낸 모델 파일의 형식(예: ONNX, TensorFlow SavedModel), 모델이 실행될 장치(예: CPU, GPU) 및 마스크 또는 상자당 여러 라벨과 같은 추가 기능의 포함 여부 등이 있습니다. 모델이 사용되는 특정 작업과 대상 환경 또는 플랫폼의 요구 사항이나 제약 사항에 따라 내보내기 과정에 영향을 미치는 다른 요소들도 있을 수 있습니다. 내보낸 모델이 의도한 용도로 최적화되어 있고 대상 환경에서 효과적으로 사용할 수 있도록 이러한 설정을 세심하게 고려하고 구성하는 것이 중요합니다.
|
||||
|
||||
| 키 | 값 | 설명 |
|
||||
|-------------|-----------------|---------------------------------------------|
|
||||
| `format` | `'torchscript'` | 내보낼 형식 |
|
||||
| `imgsz` | `640` | 스칼라 또는 (h, w) 리스트 형식의 이미지 크기, 예: (640, 480) |
|
||||
| `keras` | `False` | TF SavedModel 내보내기에 Keras 사용 |
|
||||
| `optimize` | `False` | TorchScript: 모바일 최적화 |
|
||||
| `half` | `False` | FP16 양자화 |
|
||||
| `int8` | `False` | INT8 양자화 |
|
||||
| `dynamic` | `False` | ONNX/TensorRT: 동적 축 |
|
||||
| `simplify` | `False` | ONNX/TensorRT: 모델 단순화 |
|
||||
| `opset` | `None` | ONNX: opset 버전 (선택적, 기본값은 최신) |
|
||||
| `workspace` | `4` | TensorRT: 작업공간 크기 (GB) |
|
||||
| `nms` | `False` | CoreML: NMS 추가 |
|
||||
|
||||
## 내보내기 형식
|
||||
|
||||
아래 표에는 사용 가능한 YOLOv8 내보내기 형식이 나와 있습니다. `format` 인수를 사용하여 어떤 형식으로든 내보낼 수 있습니다. 예: `format='onnx'` 또는 `format='engine'`.
|
||||
|
||||
| 형식 | `format` 인수 | 모델 | 메타데이터 | 인수 |
|
||||
|--------------------------------------------------------------------|---------------|---------------------------|-------|-----------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
|
||||
73
docs/ko/modes/index.md
Normal file
73
docs/ko/modes/index.md
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8를 통해 트레이닝부터 추적까지, Ultralytics에 최적화된 모든 기능을 활용하세요. 지원되는 각 모드에 대한 통찰력과 예시를 포함하여 검증, 내보내기, 벤치마킹까지 이해하실 수 있습니다.
|
||||
keywords: Ultralytics, YOLOv8, 머신러닝, 객체탐지, 트레이닝, 검증, 예측, 내보내기, 추적, 벤치마킹
|
||||
---
|
||||
|
||||
# Ultralytics YOLOv8 모드
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO 생태계 및 통합">
|
||||
|
||||
## 서론
|
||||
|
||||
Ultralytics YOLOv8는 단순한 객체 탐지 모델이 아닙니다; 데이터 수집에서 모델 트레이닝, 검증, 배포, 실세계 추적에 이르기까지 머신러닝 모델의 전체 생애주기를 커버하기 위해 설계된 다재다능한 프레임워크입니다. 각각의 모드는 특정 목적을 위해 섬세하게 구성되며, 다양한 작업 및 사용 사례에 필요한 유연성과 효율성을 제공합니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/j8uQc0qB91s?si=dhnGKgqvs7nPgeaM"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청하기:</strong> Ultralytics 모드 튜토리얼: 트레이닝, 검증, 예측, 내보내기 및 벤치마킹.
|
||||
</p>
|
||||
|
||||
### 모드 요약
|
||||
|
||||
YOLOv8이 지원하는 **모드**를 이해하는 것은 모델을 최대한 활용하기 위해 필수적입니다:
|
||||
|
||||
- **Train** 모드: 사용자 맞춤 또는 사전 로드된 데이터셋 위에서 모델을 튜닝합니다.
|
||||
- **Val** 모드: 트레이닝 후 모델 성능을 검증하기 위한 체크포인트.
|
||||
- **Predict** 모드: 실세계 데이터에서 모델의 예측력을 발휘합니다.
|
||||
- **Export** 모드: 다양한 포맷으로 모델을 배포 준비 상태로 만듭니다.
|
||||
- **Track** 모드: 객체 탐지 모델을 실시간 추적 애플리케이션으로 확장합니다.
|
||||
- **Benchmark** 모드: 다양한 배포 환경에서 모델의 속도와 정확도를 분석합니다.
|
||||
|
||||
이 포괄적인 가이드는 각 모드에 대한 개요와 실제 인사이트를 제공하여 YOLOv8의 전체 잠재력을 활용할 수 있도록 도와줍니다.
|
||||
|
||||
## [Train](train.md)
|
||||
|
||||
Train 모드는 사용자 맞춤 데이터셋 위에서 YOLOv8 모델을 트레이닝하기 위해 사용됩니다. 이 모드에서는 지정된 데이터셋과 하이퍼파라미터를 사용하여 모델을 트레이닝합니다. 트레이닝 과정에서 모델의 파라미터를 최적화하여 이미지 내 객체의 클래스와 위치를 정확히 예측할 수 있도록 합니다.
|
||||
|
||||
[Train 예시](train.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Val](val.md)
|
||||
|
||||
Val 모드는 트레이닝된 YOLOv8 모델을 검증하기 위해 사용됩니다. 이 모드에서는 모델을 검증 세트에서 평가하여 정확도 및 일반화 성능을 측정합니다. 이 모드는 모델의 하이퍼파라미터를 조정하고 성능을 개선하는데 사용할 수 있습니다.
|
||||
|
||||
[Val 예시](val.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Predict](predict.md)
|
||||
|
||||
Predict 모드는 트레이닝된 YOLOv8 모델을 사용하여 새 이미지 또는 비디오에서 예측을 수행하기 위해 사용됩니다. 이 모드에서는 체크포인트 파일에서 모델을 로드하고, 사용자가 이미지나 비디오를 제공하여 추론을 수행합니다. 모델은 입력 이미지 또는 비디오에서 객체의 클래스와 위치를 예측합니다.
|
||||
|
||||
[Predict 예시](predict.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Export](export.md)
|
||||
|
||||
Export 모드는 배포를 위해 YOLOv8 모델을 내보낼 수 있는 포맷으로 변환하기 위해 사용됩니다. 이 모드에서는 모델을 다른 소프트웨어 어플리케이션 또는 하드웨어 기기에서 사용할 수 있는 포맷으로 변환합니다. 이 모드는 모델을 생산 환경으로 배포하는데 유용합니다.
|
||||
|
||||
[Export 예시](export.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Track](track.md)
|
||||
|
||||
Track 모드는 실시간으로 YOLOv8 모델을 사용하여 객체를 추적하기 위해 사용됩니다. 이 모드에서는 체크포인트 파일에서 모델을 로드하고, 사용자가 실시간 비디오 스트림을 제공하여 실시간 객체 추적을 수행합니다. 이 모드는 감시 시스템이나 자율 주행 차량 같은 애플리케이션에 유용합니다.
|
||||
|
||||
[Track 예시](track.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Benchmark](benchmark.md)
|
||||
|
||||
Benchmark 모드는 YOLOv8의 다양한 내보내기 포맷에 대한 속도와 정확도를 프로파일링하기 위해 사용됩니다. 벤치마크는 내보낸 포맷의 크기, 그리고 객체 탐지, 세분화 및 포즈에 대한 `mAP50-95` 메트릭 또는 분류에 대한 `accuracy_top5` 메트릭, 그리고 ONNX, OpenVINO, TensorRT 등 다양한 내보내기 포맷에서의 이미지당 추론 시간을 밀리초로 제공합니다. 이 정보는 속도와 정확도에 대한 특정 사용 사례 요구 사항에 기반하여 최적의 내보내기 포맷을 선택하는 데 도움이 될 수 있습니다.
|
||||
|
||||
[Benchmark 예시](benchmark.md){ .md-button .md-button--primary}
|
||||
227
docs/ko/modes/predict.md
Normal file
227
docs/ko/modes/predict.md
Normal file
|
|
@ -0,0 +1,227 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8 예측 모드를 사용하여 다양한 작업을 수행하는 방법을 알아보십시오. 이미지, 비디오 및 데이터 형식과 같은 다양한 추론 소스에 대해 자세히 알아봅니다.
|
||||
keywords: Ultralytics, YOLOv8, 예측 모드, 추론 소스, 예측 작업, 스트리밍 모드, 이미지 처리, 비디오 처리, 머신 러닝, AI
|
||||
---
|
||||
|
||||
# Ultralytics YOLO로 모델 예측
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO 생태계와 통합">
|
||||
|
||||
## 소개
|
||||
|
||||
머신 러닝 및 컴퓨터 비전의 세계에서 시각적 데이터를 해석하는 과정을 '추론' 또는 '예측'이라고 합니다. Ultralytics YOLOv8는 다양한 데이터 소스에서의 고성능, 실시간 추론을 위해 맞춤화된 강력한 기능인 **예측 모드**를 제공합니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/QtsI0TnwDZs?si=ljesw75cMO2Eas14"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청:</strong> Ultralytics YOLOv8 모델에서 출력을 추출하여 맞춤 프로젝트에 사용하는 방법.
|
||||
</p>
|
||||
|
||||
## 실제 응용 분야
|
||||
|
||||
| 제조업 | 스포츠 | 안전 |
|
||||
|:-----------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------:|
|
||||
|  |  |  |
|
||||
| 차량 예비 부품 탐지 | 축구 선수 탐지 | 사람 넘어짐 탐지 |
|
||||
|
||||
## 예측 인퍼런스를 위해 Ultralytics YOLO 사용하기
|
||||
|
||||
다음은 YOLOv8의 예측 모드를 다양한 추론 요구 사항에 사용해야 하는 이유입니다:
|
||||
|
||||
- **다양성:** 이미지, 비디오, 심지어 실시간 스트림에 대한 추론을 수행할 수 있습니다.
|
||||
- **성능:** 정확성을 희생하지 않고 실시간, 고속 처리를 위해 설계되었습니다.
|
||||
- **사용 편의성:** 빠른 배포 및 테스트를 위한 직관적인 Python 및 CLI 인터페이스를 제공합니다.
|
||||
- **고도의 사용자 정의:** 특정 요구 사항에 맞게 모델의 추론 행동을 조율하기 위한 다양한 설정 및 매개변수를 제공합니다.
|
||||
|
||||
### 예측 모드의 주요 기능
|
||||
|
||||
YOLOv8의 예측 모드는 강력하고 다재다능하게 설계되었으며, 다음과 같은 특징을 갖고 있습니다:
|
||||
|
||||
- **다중 데이터 소스 호환성:** 데이터가 개별 이미지, 이미지 컬렉션, 비디오 파일 또는 실시간 비디오 스트림의 형태로 존재하는지 여부에 관계없이 예측 모드가 지원합니다.
|
||||
- **스트리밍 모드:** `Results` 객체의 메모리 효율적인 생성자로 스트리밍 기능을 사용합니다. 예측기의 호출 메서드에서 `stream=True`로 설정하여 활성화합니다.
|
||||
- **배치 처리:** 단일 배치에서 여러 이미지 또는 비디오 프레임을 처리하는 기능을 통해 추론 시간을 더욱 단축합니다.
|
||||
- **통합 친화적:** 유연한 API 덕분에 기존 데이터 파이프라인 및 기타 소프트웨어 구성 요소와 쉽게 통합할 수 있습니다.
|
||||
|
||||
Ultralytics YOLO 모델은 Python `Results` 객체의 리스트를 반환하거나, 추론 중 `stream=True`가 모델에 전달될 때 `Results` 객체의 메모리 효율적인 Python 생성자를 반환합니다:
|
||||
|
||||
!!! 예시 "예측"
|
||||
|
||||
=== "`stream=False`로 리스트 반환"
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 로드
|
||||
model = YOLO('yolov8n.pt') # 사전 훈련된 YOLOv8n 모델
|
||||
|
||||
# 이미지 리스트에 대한 배치 추론 실행
|
||||
results = model(['im1.jpg', 'im2.jpg']) # Results 객체의 리스트 반환
|
||||
|
||||
# 결과 리스트 처리
|
||||
for result in results:
|
||||
boxes = result.boxes # bbox 출력을 위한 Boxes 객체
|
||||
masks = result.masks # 세그멘테이션 마스크 출력을 위한 Masks 객체
|
||||
keypoints = result.keypoints # 자세 출력을 위한 Keypoints 객체
|
||||
probs = result.probs # 분류 출력을 위한 Probs 객체
|
||||
```
|
||||
|
||||
=== "`stream=True`로 생성자 반환"
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 로드
|
||||
model = YOLO('yolov8n.pt') # 사전 훈련된 YOLOv8n 모델
|
||||
|
||||
# 이미지 리스트에 대한 배치 추론 실행
|
||||
results = model(['im1.jpg', 'im2.jpg'], stream=True) # Results 객체의 생성자 반환
|
||||
|
||||
# 결과 생성자 처리
|
||||
for result in results:
|
||||
boxes = result.boxes # bbox 출력을 위한 Boxes 객체
|
||||
masks = result.masks # 세그멘테이션 마스크 출력을 위한 Masks 객체
|
||||
keypoints = result.keypoints # 자세 출력을 위한 Keypoints 객체
|
||||
probs = result.probs # 분류 출력을 위한 Probs 객체
|
||||
```
|
||||
|
||||
## 추론 소스
|
||||
|
||||
YOLOv8은 아래 표에 표시된 바와 같이 추론을 위한 다양한 유형의 입력 소스를 처리할 수 있습니다. 소스에는 정적 이미지, 비디오 스트림, 다양한 데이터 형식이 포함됩니다. 표는 또한 각 소스를 'stream=True' ✅와 함께 스트리밍 모드에서 사용할 수 있는지 여부를 나타냅니다. 스트리밍 모드는 비디오나 라이브 스트림을 처리할 때 결과를 메모리에 모두 로드하는 대신 결과의 생성자를 만들어 유용하게 사용됩니다.
|
||||
|
||||
!!! 팁 "팁"
|
||||
|
||||
긴 비디오나 큰 데이터 세트를 처리할 때 'stream=True'를 사용하여 효율적으로 메모리를 관리합니다. 'stream=False'일 때는 모든 프레임 또는 데이터 포인트에 대한 결과가 메모리에 저장되어, 입력이 크면 메모리 부족 오류를 빠르게 유발할 수 있습니다. 반면에, 'stream=True'는 생성자를 사용하여 현재 프레임 또는 데이터 포인트의 결과만 메모리에 유지하여 메모리 소비를 크게 줄이고 메모리 부족 문제를 방지합니다.
|
||||
|
||||
| 소스 | 인수 | 유형 | 비고 |
|
||||
|-----------|--------------------------------------------|-----------------|--------------------------------------------------------------------------|
|
||||
| 이미지 | `'image.jpg'` | `str` 또는 `Path` | 단일 이미지 파일. |
|
||||
| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | 이미지 URL. |
|
||||
| 스크린샷 | `'screen'` | `str` | 스크린샷을 캡처합니다. |
|
||||
| PIL | `Image.open('im.jpg')` | `PIL.Image` | HWC 형식으로 RGB 채널이 있습니다. |
|
||||
| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | HWC 형식으로 BGR 채널이 있고 `uint8 (0-255)` 입니다. |
|
||||
| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | HWC 형식으로 BGR 채널이 있고 `uint8 (0-255)` 입니다. |
|
||||
| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | BCHW 형식으로 RGB 채널이 있고 `float32 (0.0-1.0)` 입니다. |
|
||||
| CSV | `'sources.csv'` | `str` 또는 `Path` | 이미지, 비디오 또는 디렉토리 경로가 있는 CSV 파일. |
|
||||
| 비디오 ✅ | `'video.mp4'` | `str` 또는 `Path` | MP4, AVI 등과 같은 형식의 비디오 파일입니다. |
|
||||
| 디렉토리 ✅ | `'path/'` | `str` 또는 `Path` | 이미지나 비디오가 있는 디렉토리 경로입니다. |
|
||||
| 글로브 ✅ | `'path/*.jpg'` | `str` | 여러 파일에 일치하는 글로브 패턴입니다. '*' 문자를 와일드카드로 사용하세요. |
|
||||
| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | YouTube 비디오의 URL입니다. |
|
||||
| 스트림 ✅ | `'rtsp://example.com/media.mp4'` | `str` | RTSP, RTMP, TCP 또는 IP 주소와 같은 스트리밍 프로토콜의 URL입니다. |
|
||||
| 멀티-스트림 ✅ | `'list.streams'` | `str` 또는 `Path` | 스트림 URL이 행당 하나씩 있는 `*.streams` 텍스트 파일이며, 예를 들어 8개의 스트림은 배치 크기 8에서 실행됩니다. |
|
||||
|
||||
아래는 각 유형의 소스를 사용하는 코드 예제입니다:
|
||||
|
||||
!!! 예시 "예측 소스"
|
||||
|
||||
=== "이미지"
|
||||
이미지 파일에서 추론을 실행합니다.
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 사전 훈련된 YOLOv8n 모델 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 이미지 파일 경로 정의
|
||||
source = 'path/to/image.jpg'
|
||||
|
||||
# 소스에서 추론 실행
|
||||
results = model(source) # Results 객체의 리스트
|
||||
```
|
||||
|
||||
=== "스크린샷"
|
||||
현재 스크린 콘텐츠를 스크린샷으로 추론을 실행합니다.
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 사전 훈련된 YOLOv8n 모델 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 현재 스크린샷을 소스로 정의
|
||||
source = 'screen'
|
||||
|
||||
# 소스에서 추론 실행
|
||||
results = model(source) # Results 객체의 리스트
|
||||
```
|
||||
|
||||
=== "URL"
|
||||
URL을 통해 원격으로 호스팅되는 이미지나 비디오에서 추론을 실행합니다.
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 사전 훈련된 YOLOv8n 모델 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 원격 이미지나 동영상 URL 정의
|
||||
source = 'https://ultralytics.com/images/bus.jpg'
|
||||
|
||||
# 소스에서 추론 실행
|
||||
results = model(source) # Results 객체의 리스트
|
||||
```
|
||||
|
||||
=== "PIL"
|
||||
Python Imaging Library (PIL)로 열린 이미지에서 추론을 실행합니다.
|
||||
```python
|
||||
from PIL import Image
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 사전 훈련된 YOLOv8n 모델 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# PIL을 사용하여 이미지 열기
|
||||
source = Image.open('path/to/image.jpg')
|
||||
|
||||
# 소스에서 추론 실행
|
||||
results = model(source) # Results 객체의 리스트
|
||||
```
|
||||
|
||||
=== "OpenCV"
|
||||
OpenCV로 읽은 이미지에서 추론을 실행합니다.
|
||||
```python
|
||||
import cv2
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 사전 훈련된 YOLOv8n 모델 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# OpenCV를 사용하여 이미지 읽기
|
||||
source = cv2.imread('path/to/image.jpg')
|
||||
|
||||
# 소스에서 추론 실행
|
||||
results = model(source) # Results 객체의 리스트
|
||||
```
|
||||
|
||||
=== "numpy"
|
||||
numpy 배열로 표현된 이미지에서 추론을 실행합니다.
|
||||
```python
|
||||
import numpy as np
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 사전 훈련된 YOLOv8n 모델 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 무작위 numpy 배열 생성, HWC 형태 (640, 640, 3), 값 범위 [0, 255], 타입 uint8
|
||||
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8')
|
||||
|
||||
# 소스에서 추론 실행
|
||||
results = model(source) # Results 객체의 리스트
|
||||
```
|
||||
|
||||
=== "torch"
|
||||
PyTorch 텐서로 표현된 이미지에서 추론을 실행합니다.
|
||||
```python
|
||||
import torch
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 사전 훈련된 YOLOv8n 모델 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 무작위 torch 텐서 생성, BCHW 형태 (1, 3, 640, 640), 값 범위 [0, 1], 타입 float32
|
||||
source = torch.rand(1, 3, 640, 640, dtype=torch.float32)
|
||||
|
||||
# 소스에서 추론 실행
|
||||
results = model(source) # Results 객체의 리스트
|
||||
```
|
||||
256
docs/ko/modes/track.md
Normal file
256
docs/ko/modes/track.md
Normal file
|
|
@ -0,0 +1,256 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics YOLO를 사용하여 비디오 스트림에서 객체 추적을 사용하는 방법을 알아보세요. 다양한 추적기를 사용하는 안내와 추적기 구성을 맞춤 설정하는 방법에 대한 가이드가 있습니다.
|
||||
keywords: Ultralytics, YOLO, 객체 추적, 비디오 스트림, BoT-SORT, ByteTrack, 파이썬 가이드, CLI 가이드
|
||||
---
|
||||
|
||||
# Ultralytics YOLO를 이용한 다중 객체 추적
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418637-1d6250fd-1515-4c10-a844-a32818ae6d46.png" alt="다중 객체 추적 예시">
|
||||
|
||||
비디오 분석의 영역에서 객체 추적은 프레임 내에서 객체의 위치와 클래스를 식별할 뿐만 아니라 비디오가 진행됨에 따라 각각의 검출된 객체에 대해 고유 ID를 유지하는 중요한 작업입니다. 응용 프로그램은 감시 및 보안에서 실시간 스포츠 분석에 이르기까지 무한합니다.
|
||||
|
||||
## 객체 추적을 위해 Ultralytics YOLO를 선택해야 하는 이유는?
|
||||
|
||||
Ultralytics 추적기의 출력은 표준 객체 검출과 일관되지만 객체 ID가 추가된 가치가 있습니다. 이를 통해 비디오 스트림에서 객체를 추적하고 이후 분석을 수행하기가 쉽습니다. 여기에 어떤 이유로 Ultralytics YOLO를 사용해야 하는지에 대해 설명합니다:
|
||||
|
||||
- **효율성:** 정확성을 저하시키지 않으면서 실시간으로 비디오 스트림을 처리합니다.
|
||||
- **유연성:** 다양한 추적 알고리즘과 구성을 지원합니다.
|
||||
- **사용하기 쉬움:** 간단한 파이썬 API 및 CLI 옵션으로 빠른 통합 및 배치가 가능합니다.
|
||||
- **맞춤 설정:** 맞춤 학습된 YOLO 모델과 함께 사용하기 쉬워 특정 도메인 응용 프로그램에 통합할 수 있습니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/hHyHmOtmEgs?si=VNZtXmm45Nb9s-N-"
|
||||
title="YouTube 비디오 플레이어" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청하기:</strong> Ultralytics YOLOv8로 객체 감지 및 추적하기.
|
||||
</p>
|
||||
|
||||
## 실제 세계 응용 프로그램
|
||||
|
||||
| 교통수단 | 소매업 | 수산업 |
|
||||
|:-----------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------:|
|
||||
|  |  |  |
|
||||
| 차량 추적 | 사람 추적 | 물고기 추적 |
|
||||
|
||||
## 한눈에 보기
|
||||
|
||||
Ultralytics YOLO는 객체 감지 기능을 확장하여 견고하고 다재다능한 객체 추적을 제공합니다:
|
||||
|
||||
- **실시간 추적:** 고화면률의 비디오에서 매끄럽게 객체 추적합니다.
|
||||
- **다중 추적기 지원:** 다양한 검증된 추적 알고리즘 중에서 선택 가능합니다.
|
||||
- **맞춤형 추적기 구성:** 다양한 매개변수를 조정하여 특정 요구사항에 맞게 추적 알고리즘을 맞춤화할 수 있습니다.
|
||||
|
||||
## 사용 가능한 추적기
|
||||
|
||||
Ultralytics YOLO는 다음과 같은 추적 알고리즘을 지원합니다. 관련 YAML 구성 파일(예: `tracker=tracker_type.yaml`)을 전달하여 사용할 수 있습니다:
|
||||
|
||||
* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - 이 추적기를 활성화하려면 `botsort.yaml`을 사용합니다.
|
||||
* [ByteTrack](https://github.com/ifzhang/ByteTrack) - 이 추적기를 활성화하려면 `bytetrack.yaml`을 사용합니다.
|
||||
|
||||
기본 추적기는 BoT-SORT입니다.
|
||||
|
||||
## 추적
|
||||
|
||||
비디오 스트림에서 추적기를 실행하려면 YOLOv8n, YOLOv8n-seg 및 YOLOv8n-pose와 같은 훈련된 Detect, Segment 또는 Pose 모델을 사용하십시오.
|
||||
|
||||
!!! 예시 ""
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 공식 모델 또는 맞춤 모델을 불러오기
|
||||
model = YOLO('yolov8n.pt') # 공식 Detect 모델 불러오기
|
||||
model = YOLO('yolov8n-seg.pt') # 공식 Segment 모델 불러오기
|
||||
model = YOLO('yolov8n-pose.pt') # 공식 Pose 모델 불러오기
|
||||
model = YOLO('path/to/best.pt') # 맞춤 학습된 모델 불러오기
|
||||
|
||||
# 모델을 사용하여 추적 수행
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # 기본 추적기로 추적하기
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # ByteTrack 추적기로 추적하기
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# 명령 행 인터페이스를 사용하여 다양한 모델로 추적 수행
|
||||
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # 공식 Detect 모델
|
||||
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # 공식 Segment 모델
|
||||
yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # 공식 Pose 모델
|
||||
yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # 맞춤 학습된 모델
|
||||
|
||||
# ByteTrack 추적기를 사용하여 추적하기
|
||||
yolo track model=path/to/best.pt tracker="bytetrack.yaml"
|
||||
```
|
||||
|
||||
위의 사용법에서 볼 수 있듯이 모든 Detect, Segment 및 Pose 모델은 비디오나 스트리밍 출처에서 추적이 가능합니다.
|
||||
|
||||
## 구성
|
||||
|
||||
### 추적 인수
|
||||
|
||||
추적 구성은 `conf`, `iou` 및 `show`와 같은 예측 모드와 동일한 속성을 공유합니다. 추가 구성에 대해서는 [Predict](https://docs.ultralytics.com/modes/predict/) 모델 페이지를 참조하십시오.
|
||||
|
||||
!!! 예시 ""
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 추적 매개변수를 구성하고 추적기를 실행합니다
|
||||
model = YOLO('yolov8n.pt')
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# 추적 매개변수를 구성하고 명령 행 인터페이스를 사용하여 추적기를 실행합니다
|
||||
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
|
||||
```
|
||||
|
||||
### 추적기 선택
|
||||
|
||||
Ultralytics에서는 수정된 추적기 구성 파일도 사용할 수 있습니다. 이를 위해 [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)에서 추적기 구성 파일의 복사본(예: `custom_tracker.yaml`)을 만들고 필요한대로 구성을 수정하면 됩니다(단, `tracker_type` 제외).
|
||||
|
||||
!!! 예시 ""
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 불러오고 맞춤 구성 파일로 추적기를 실행합니다
|
||||
model = YOLO('yolov8n.pt')
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# 명령 행 인터페이스를 사용하여 맞춤 구성 파일로 모델을 불러오고 추적기를 실행합니다
|
||||
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
|
||||
```
|
||||
|
||||
추적 인수에 대한 종합적인 목록은 [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) 페이지를 참조하세요.
|
||||
|
||||
## 파이썬 예시
|
||||
|
||||
### 보존하는 추적 루프
|
||||
|
||||
다음은 OpenCV(`cv2`)와 YOLOv8를 사용하여 비디오 프레임에서 객체 추적을 실행하는 파이썬 스크립트입니다. 이 스크립트에서는 필요한 패키지(`opencv-python` 및 `ultralytics`)를 이미 설치했다고 가정합니다. `persist=True` 인수는 추적기에 현재 이미지 또는 프레임이 시퀀스에서 다음 것이며 현재 이미지에서 이전 이미지의 추적을 예상한다고 알립니다.
|
||||
|
||||
!!! 예시 "추적이 포함된 스트리밍 for-loop"
|
||||
|
||||
```python
|
||||
import cv2
|
||||
from ultralytics import YOLO
|
||||
|
||||
# YOLOv8 모델을 불러옵니다
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 비디오 파일을 엽니다
|
||||
video_path = "path/to/video.mp4"
|
||||
cap = cv2.VideoCapture(video_path)
|
||||
|
||||
# 비디오 프레임을 반복합니다
|
||||
while cap.isOpened():
|
||||
# 비디오에서 프레임을 읽습니다
|
||||
success, frame = cap.read()
|
||||
|
||||
if success:
|
||||
# 프레임에 YOLOv8 추적을 실행하여 추적을 유지합니다
|
||||
results = model.track(frame, persist=True)
|
||||
|
||||
# 결과를 프레임에 시각화합니다
|
||||
annotated_frame = results[0].plot()
|
||||
|
||||
# 어노테이션된 프레임을 표시합니다
|
||||
cv2.imshow("YOLOv8 추적", annotated_frame)
|
||||
|
||||
# 'q'가 눌리면 루프를 중단합니다
|
||||
if cv2.waitKey(1) & 0xFF == ord("q"):
|
||||
break
|
||||
else:
|
||||
# 비디오의 끝에 도달하면 루프를 중단합니다
|
||||
break
|
||||
|
||||
# 비디오 캡처 객체를 해제하고 표시 창을 닫습니다
|
||||
cap.release()
|
||||
cv2.destroyAllWindows()
|
||||
```
|
||||
|
||||
여기서 `model(frame)`을 `model.track(frame)`으로 변경하면 단순 감지가 아닌 객체 추적이 가능해집니다. 이 수정된 스크립트는 비디오의 각 프레임에 추적기를 실행하고 결과를 시각화한 후 창에 표시합니다. 'q'를 누르면 루프가 종료됩니다.
|
||||
|
||||
### 시간에 따른 추적 그리기
|
||||
|
||||
연속 프레임에서 객체 추적을 시각화하면 비디오 내에서 검출된 객체의 이동 패턴과 행동에 대한 소중한 통찰력을 제공할 수 있습니다. Ultralytics YOLOv8을 사용하면 이러한 추적을 원활하고 효율적으로 플로팅할 수 있습니다.
|
||||
|
||||
다음 예시에서, 여러 비디오 프레임에 걸친 검출된 객체의 움직임을 플로팅하기 위해 YOLOv8의 추적 기능을 활용하는 방법을 보여줍니다. 이 스크립트는 비디오 파일을 여는 것을 포함하여 프레임별로 읽고 YOLO 모델을 사용하여 다양한 객체를 식별하고 추적합니다. 검출된 경계 상자의 중심점을 보존하고 연결하여 추적된 객체의 경로를 나타내는 선을 그립니다.
|
||||
|
||||
!!! 예시 "비디오 프레임에 걸쳐 추적 그리기"
|
||||
|
||||
```python
|
||||
from collections import defaultdict
|
||||
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
from ultralytics import YOLO
|
||||
|
||||
# YOLOv8 모델을 불러옵니다
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 비디오 파일을 엽니다
|
||||
video_path = "path/to/video.mp4"
|
||||
cap = cv2.VideoCapture(video_path)
|
||||
|
||||
# 추적 내역을 저장합니다
|
||||
track_history = defaultdict(lambda: [])
|
||||
|
||||
# 비디오 프레임을 반복합니다
|
||||
while cap.isOpened():
|
||||
# 비디오에서 프레임을 읽습니다
|
||||
success, frame = cap.read()
|
||||
|
||||
if success:
|
||||
# 프레임에 YOLOv8 추적을 실행하여 추적을 유지합니다
|
||||
results = model.track(frame, persist=True)
|
||||
|
||||
# 상자 및 추적 ID를 가져옵니다
|
||||
boxes = results[0].boxes.xywh.cpu()
|
||||
track_ids = results[0].boxes.id.int().cpu().tolist()
|
||||
|
||||
# 결과를 프레임에 시각화합니다
|
||||
annotated_frame = results[0].plot()
|
||||
|
||||
# 추적을 플롯합니다
|
||||
for box, track_id in zip(boxes, track_ids):
|
||||
x, y, w, h = box
|
||||
track = track_history[track_id]
|
||||
track.append((float(x), float(y))) # x, y의 중심점
|
||||
if len(track) > 30: # 90프레임에 대해 90개의 추적을 유지
|
||||
track.pop(0)
|
||||
|
||||
# 추적 라인을 그립니다
|
||||
points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
|
||||
cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
|
||||
|
||||
# 어노테이션된 프레임을 표시합니다
|
||||
cv2.imshow("YOLOv8 추적", annotated_frame)
|
||||
|
||||
# 'q'가 눌리면 루프를 중단합니다
|
||||
if cv2.waitKey(1) & 0xFF == ord("q"):
|
||||
break
|
||||
else:
|
||||
# 비디오의 끝에 도달하면 루프를 중단합니다
|
||||
break
|
||||
|
||||
```
|
||||
145
docs/ko/modes/train.md
Normal file
145
docs/ko/modes/train.md
Normal file
|
|
@ -0,0 +1,145 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8 모델을 Ultralytics YOLO를 사용하여 훈련하는 단계별 가이드로, 단일 GPU 및 다중 GPU 훈련의 예제 포함
|
||||
keywords: Ultralytics, YOLOv8, YOLO, 객체 감지, 훈련 모드, 사용자 정의 데이터셋, GPU 훈련, 다중 GPU, 하이퍼파라미터, CLI 예제, Python 예제
|
||||
---
|
||||
|
||||
# Ultralytics YOLO와 함께 하는 모델 훈련
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO 생태계 및 통합">
|
||||
|
||||
## 소개
|
||||
|
||||
딥러닝 모델을 훈련한다는 것은 모델에 데이터를 공급하고 그것이 정확한 예측을 할 수 있도록 매개변수를 조정하는 과정을 말합니다. Ultralytics YOLOv8의 훈련 모드는 현대 하드웨어 기능을 완전히 활용하여 객체 감지 모델의 효과적이고 효율적인 훈련을 위해 설계되었습니다. 이 가이드는 YOLOv8의 강력한 기능 세트를 사용하여 자체 모델을 훈련하는 데 필요한 모든 세부 정보를 다루는 것을 목표로 합니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청하기:</strong> Google Colab에서 여러분의 사용자 정의 데이터셋으로 YOLOv8 모델을 훈련하는 방법.
|
||||
</p>
|
||||
|
||||
## Ultralytics YOLO로 훈련하는 이유?
|
||||
|
||||
YOLOv8의 훈련 모드를 선택하는 데는 몇 가지 설득력 있는 이유가 있습니다:
|
||||
|
||||
- **효율성:** 단일 GPU 설정이든 여러 GPU로 확장하든, 하드웨어를 최대한 활용하세요.
|
||||
- **다양성:** COCO, VOC, ImageNet과 같은 기존의 데이터셋뿐만 아니라 사용자 정의 데이터셋으로도 훈련 가능.
|
||||
- **사용자 친화적:** 간단하면서도 강력한 CLI 및 Python 인터페이스를 통한 직관적인 훈련 경험 제공.
|
||||
- **하이퍼파라미터 유연성:** 모델의 성능을 미세 조정할 수 있는 다양하게 구성 가능한 하이퍼파라미터.
|
||||
|
||||
### 훈련 모드의 주요 기능
|
||||
|
||||
다음은 YOLOv8의 훈련 모드의 주요 기능 중 일부입니다:
|
||||
|
||||
- **자동 데이터셋 다운로드:** COCO, VOC, ImageNet과 같은 표준 데이터셋들은 첫 사용시 자동으로 다운로드됩니다.
|
||||
- **다중 GPU 지원:** 여러 GPU에 걸쳐 훈련 노력을 빠르게 확대하기 위한 규모있는 훈련 지원.
|
||||
- **하이퍼파라미터 구성:** YAML 구성 파일이나 CLI 인수를 통해 하이퍼파라미터 수정 가능.
|
||||
- **시각화 및 모니터링:** 훈련 지표의 실시간 추적 및 학습 과정의 시각화로 더 나은 인사이트 제공.
|
||||
|
||||
!!! 팁 "팁"
|
||||
|
||||
* YOLOv8 데이터셋들은 첫 사용시 자동으로 다운로드됩니다, 예: `yolo train data=coco.yaml`
|
||||
|
||||
## 사용 예제
|
||||
|
||||
COCO128 데이터셋에서 YOLOv8n을 이미지 크기 640으로 100 에포크 동안 훈련합니다. 훈련 장치는 `device` 인수를 사용하여 지정할 수 있습니다. 인수를 전달하지 않으면 사용 가능한 경우 GPU `device=0`이, 아니면 `device=cpu`가 사용됩니다. 전체 훈련 인수 목록은 아래 Arguments 섹션을 참조하세요.
|
||||
|
||||
!!! 예제 "단일 GPU 및 CPU 훈련 예제"
|
||||
|
||||
장치는 자동으로 결정됩니다. GPU가 사용 가능하면 사용되며, 그렇지 않으면 CPU에서 훈련이 시작됩니다.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 로드하세요.
|
||||
model = YOLO('yolov8n.yaml') # YAML에서 새 모델 구축
|
||||
model = YOLO('yolov8n.pt') # 사전 훈련된 모델 로드 (훈련을 위해 권장됨)
|
||||
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # YAML에서 구축 및 가중치 전달
|
||||
|
||||
# 모델을 훈련합니다.
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# YAML에서 새 모델을 구축하고 처음부터 훈련을 시작하세요.
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
|
||||
|
||||
# 사전 훈련된 *.pt 모델에서 훈련을 시작하세요.
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
|
||||
# YAML에서 새 모델을 구축하고, 사전 훈련된 가중치를 전달하고 훈련을 시작하세요.
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### 다중 GPU 훈련
|
||||
|
||||
다중 GPU 훈련을 통해 사용 가능한 하드웨어 리소스를 더 효율적으로 활용할 수 있습니다. 이 기능은 Python API와 명령행 인터페이스 모두를 통해 사용할 수 있습니다. 다중 GPU 훈련을 활성화하려면 사용하려는 GPU 장치 ID를 지정하세요.
|
||||
|
||||
!!! 예제 "다중 GPU 훈련 예제"
|
||||
|
||||
2개의 GPU, CUDA 장치 0과 1로 훈련하려면 다음 명령을 사용하세요. 필요에 따라 추가 GPU로 확장하세요.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 로드하세요.
|
||||
model = YOLO('yolov8n.pt') # 사전 훈련된 모델 로드 (훈련 추천됨)
|
||||
|
||||
# 2개의 GPU로 모델을 훈련합니다.
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# 사전 훈련된 *.pt 모델로부터 시작하여 GPU 0과 1을 사용하여 훈련합니다.
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
|
||||
```
|
||||
|
||||
### Apple M1 및 M2 MPS 훈련
|
||||
|
||||
Ultralytics YOLO 모델에 통합된 Apple M1 및 M2 칩들에 대한 지원을 통해 Apple의 강력한 Metal Performance Shaders (MPS) 프레임워크를 활용하여 장치에서 모델을 훈련할 수 있습니다. MPS는 Apple 사용자 지정 실리콘에서 컴퓨터 및 이미지 처리 작업을 실행하는 고성능 방법을 제공합니다.
|
||||
|
||||
Apple M1 및 M2 칩에서 훈련을 활성화하려면, 훈련 과정을 시작할 때 장치로 'mps'를 지정해야 합니다. 아래는 Python 및 명령행 인터페이스를 통해 이를 수행할 수 있는 예제입니다:
|
||||
|
||||
!!! 예제 "MPS 훈련 예제"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 로드하세요.
|
||||
model = YOLO('yolov8n.pt') # 사전 훈련된 모델 로드 (훈련 추천됨)
|
||||
|
||||
# 2개의 GPU로 모델을 훈련합니다.
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# 사전 훈련된 *.pt 모델을 사용하여 mps 장치에서 훈련을 시작합니다.
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
|
||||
```
|
||||
|
||||
M1/M2 칩의 연산력을 활용하면서 훈련 작업을 더 효율적으로 처리할 수 있습니다. 자세한 지침과 고급 설정 옵션을 원하신다면 [PyTorch MPS 문서](https://pytorch.org/docs/stable/notes/mps.html)를 참조하세요.
|
||||
|
||||
### 중단된 훈련 이어나가기
|
||||
|
||||
이전에 저장된 상태에서 훈련을 이어나가는 기능은 딥러닝 모델을 다룰 때 중요한 기능입니다. 이 기능은 훈련 과정이 예기치 않게 중단되었거나 새로운 데이터로 모델을 계속 훈련하거나 더 많은 에포크 동안 훈련을 진행하고 싶을 때 유용합니다.
|
||||
|
||||
훈련을 재개할 때, Ultralytics YOLO는 마지막으로 저장된 모델에서 가중치를 로드하고 옵티마이저 상태, 학습률 스케줄러, 에포크 번호도 복원합니다. 이를 통해 훈련 과정을 중단된 지점부터 이어갈 수 있습니다.
|
||||
|
||||
Ultralytics YOLO에서 `train` 메서드 호출 시 `resume` 인수를 `True`로 설정하고 부분적으로 훈련된 모델 가중치가 포함된 `.pt` 파일의 경로를 지정하면 훈련을 이어나갈 수 있습니다.
|
||||
86
docs/ko/modes/val.md
Normal file
86
docs/ko/modes/val.md
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8 모델 검증 가이드. 검증 설정 및 측정 항목을 사용하여 YOLO 모델의 성능을 평가하는 방법에 대해 알아보세요. Python 및 CLI 예제가 포함되어 있습니다.
|
||||
keywords: Ultralytics, YOLO 문서, YOLOv8, 검증, 모델 평가, 하이퍼파라미터, 정확도, 측정 항목, Python, CLI
|
||||
---
|
||||
|
||||
# Ultralytics YOLO로 모델 검증하기
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO 생태계 및 통합">
|
||||
|
||||
## 도입
|
||||
|
||||
검증은 훈련된 모델의 품질을 평가할 수 있게 해주는 기계학습 파이프라인에서 중요한 단계입니다. Ultralytics YOLOv8의 Val 모드는 모델의 객체 탐지 성능을 평가하기 위한 강력한 도구 및 측정 항목 모음을 제공합니다. 이 가이드는 Val 모드를 효과적으로 사용하여 모델의 정확성과 신뢰성을 보장하는 방법에 대한 완벽한 리소스 역할을 합니다.
|
||||
|
||||
## 왜 Ultralytics YOLO로 검증을 해야 할까요?
|
||||
|
||||
YOLOv8의 Val 모드를 사용하는 이점은 다음과 같습니다:
|
||||
|
||||
- **정밀도:** mAP50, mAP75, mAP50-95와 같은 정확한 측정 항목으로 모델을 종합적으로 평가합니다.
|
||||
- **편의성:** 훈련 설정을 기억하는 내장 기능을 활용하여 검증 절차를 단순화합니다.
|
||||
- **유연성:** 같거나 다른 데이터셋과 이미지 크기로 모델을 검증할 수 있습니다.
|
||||
- **하이퍼파라미터 튜닝:** 검증 측정 항목을 사용하여 모델의 성능을 더 잘 조율합니다.
|
||||
|
||||
### Val 모드의 주요 기능
|
||||
|
||||
YOLOv8의 Val 모드가 제공하는 주목할 만한 기능들은 다음과 같습니다:
|
||||
|
||||
- **자동화된 설정:** 모델은 훈련 구성을 기억하여 간단하게 검증이 가능합니다.
|
||||
- **멀티-메트릭 지원:** 다양한 정확도 측정 항목을 기반으로 모델을 평가합니다.
|
||||
- **CLI 및 Python API:** 검증을 위해 명령 줄 인터페이스 또는 Python API 중에서 선택할 수 있습니다.
|
||||
- **데이터 호환성:** 훈련 단계에서 사용된 데이터셋과 사용자 정의 데이터셋 모두와 원활하게 작동합니다.
|
||||
|
||||
!!! tip "팁"
|
||||
|
||||
* YOLOv8 모델은 훈련 설정을 자동으로 기억하므로 `yolo val model=yolov8n.pt`나 `model('yolov8n.pt').val()`만으로 같은 이미지 크기와 원본 데이터셋에서 쉽게 검증할 수 있습니다.
|
||||
|
||||
## 사용 예제
|
||||
|
||||
COCO128 데이터셋에서 훈련된 YOLOv8n 모델의 정확도를 검증합니다. `모델`은 훈련 `데이터`와 인자를 모델 속성으로 유지하므로 인자가 필요 없습니다. 전체 내보내기 인자 목록은 아래의 인자 섹션을 참고하세요.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 로드
|
||||
model = YOLO('yolov8n.pt') # 공식 모델을 로드합니다
|
||||
model = YOLO('path/to/best.pt') # 사용자 정의 모델을 로드합니다
|
||||
|
||||
# 모델 검증
|
||||
metrics = model.val() # 인자가 필요 없음, 데이터셋과 설정이 기억됩니다
|
||||
metrics.box.map # map50-95
|
||||
metrics.box.map50 # map50
|
||||
metrics.box.map75 # map75
|
||||
metrics.box.maps # 각 카테고리의 map50-95가 포함된 목록
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect val model=yolov8n.pt # 공식 모델 검증
|
||||
yolo detect val model=path/to/best.pt # 사용자 정의 모델 검증
|
||||
```
|
||||
|
||||
## 인자
|
||||
|
||||
YOLO 모델의 검증 설정은 모델의 성능을 검증 데이터셋에서 평가하기 위한 다양한 하이퍼파라미터 및 구성을 의미합니다. 이러한 설정은 모델의 성능, 속도, 정확성에 영향을 미칠 수 있습니다. 일반적인 YOLO 검증 설정에는 배치 크기, 훈련 중 검증이 수행되는 빈도 및 모델 성능을 평가하기 위해 사용되는 측정 항목이 포함됩니다. 검증 과정에 영향을 줄 수 있는 다른 요소로는 검증 데이터셋의 크기와 구성 및 모델이 사용되는 구체적인 작업이 있습니다. 모델이 검증 데이터셋에서 잘 수행되고 있고 과적합을 감지하고 방지하기 위해서는 이러한 설정을 신중하게 조정하고 실험하는 것이 중요합니다.
|
||||
|
||||
| Key | Value | Description |
|
||||
|---------------|---------|---------------------------------------------------|
|
||||
| `data` | `None` | 데이터 파일 경로 예: coco128.yaml |
|
||||
| `imgsz` | `640` | 입력 이미지의 크기를 정수로 지정 |
|
||||
| `batch` | `16` | 배치 당 이미지 수 (-1은 AutoBatch에 해당) |
|
||||
| `save_json` | `False` | 결과를 JSON 파일로 저장 |
|
||||
| `save_hybrid` | `False` | 라벨의 하이브리드 버전(라벨 + 추가 예측)을 저장 |
|
||||
| `conf` | `0.001` | 탐지를 위한 객체 신뢰도 임계값 |
|
||||
| `iou` | `0.6` | NMS 용 교차 영역과 합친 영역(IoU)의 임계값 |
|
||||
| `max_det` | `300` | 이미지 당 최대 탐지 개수 |
|
||||
| `half` | `True` | 반정밀도(FP16) 사용 |
|
||||
| `device` | `None` | 사용할 장치 예: cuda의 device=0/1/2/3이나 device=cpu |
|
||||
| `dnn` | `False` | ONNX 추론에 OpenCV DNN 사용 |
|
||||
| `plots` | `False` | 훈련 중 플롯 표시 |
|
||||
| `rect` | `False` | 최소한의 패딩을 위해 각 배치가 직사각형 val로 조정됨 |
|
||||
| `split` | `val` | 검증을 위해 사용되는 데이터셋 분할, 예: 'val', 'test', 혹은 'train' |
|
||||
|
|
||||
196
docs/ko/quickstart.md
Normal file
196
docs/ko/quickstart.md
Normal file
|
|
@ -0,0 +1,196 @@
|
|||
---
|
||||
comments: true
|
||||
description: pip, conda, git 및 Docker를 사용하여 Ultralytics을 설치하는 다양한 방법을 탐색해 보세요. Ultralytics을 명령줄 인터페이스 또는 Python 프로젝트 내에서 사용하는 방법을 알아보세요.
|
||||
keywords: Ultralytics 설치, pip를 이용한 Ultralytics 설치, Docker를 이용한 Ultralytics 설치, Ultralytics 명령줄 인터페이스, Ultralytics Python 인터페이스
|
||||
---
|
||||
|
||||
## Ultralytics 설치하기
|
||||
|
||||
Ultralytics는 pip, conda, Docker를 포함한 다양한 설치 방법을 제공합니다. `ultralytics` pip 패키지를 이용해 가장 안정적인 최신 버전의 YOLOv8을 설치하거나 [Ultralytics GitHub 저장소](https://github.com/ultralytics/ultralytics)를 복제하여 가장 최신 버전을 받아볼 수 있습니다. Docker를 이용하면 패키지를 로컬에 설치하지 않고 격리된 컨테이너에서 실행할 수 있습니다.
|
||||
|
||||
!!! example "설치하기"
|
||||
|
||||
=== "Pip 설치하기 (권장)"
|
||||
pip을 사용하여 `ultralytics` 패키지를 설치하거나, `pip install -U ultralytics`를 실행하여 기존 설치를 업데이트하세요. Python Package Index(PyPI)에서 `ultralytics` 패키지에 대한 자세한 내용을 확인하세요: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
|
||||
|
||||
[](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/project/ultralytics)
|
||||
|
||||
```bash
|
||||
# PyPI에서 ultralytics 패키지 설치하기
|
||||
pip install ultralytics
|
||||
```
|
||||
|
||||
GitHub [저장소](https://github.com/ultralytics/ultralytics)에서 직접 `ultralytics` 패키지를 설치할 수도 있습니다. 최신 개발 버전이 필요한 경우 유용할 수 있습니다. 시스템에 Git 명령줄 도구가 설치되어 있는지 확인하세요. `@main` 명령어는 `main` 브랜치를 설치하며, `@my-branch`로 변경하거나 `main` 브랜치를 기본으로 사용하려면 아예 제거하면 됩니다.
|
||||
|
||||
```bash
|
||||
# GitHub에서 ultralytics 패키지 설치하기
|
||||
pip install git+https://github.com/ultralytics/ultralytics.git@main
|
||||
```
|
||||
|
||||
|
||||
=== "Conda 설치하기"
|
||||
pip의 대안으로 사용할 수 있는 또 다른 패키지 관리자인 Conda를 통해서도 설치할 수 있습니다. [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics)에서 Anaconda에 대한 자세한 정보를 확인하세요. Conda 패키지를 업데이트하는 Ultralytics feedstock 저장소는 [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/)에 있습니다.
|
||||
|
||||
|
||||
[](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics)
|
||||
|
||||
```bash
|
||||
# conda를 사용하여 ultralytics 패키지 설치하기
|
||||
conda install -c conda-forge ultralytics
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
CUDA 환경에서 설치하는 경우 일반적으로 `ultralytics`, `pytorch` 및 `pytorch-cuda`를 동일한 명령어로 설치하여 Conda 패키지 관리자가 충돌을 해결하도록 하거나, 필요한 경우 CPU 전용 `pytorch` 패키지를 덮어쓸 수 있도록 `pytorch-cuda`를 마지막에 설치하는 것이 좋습니다.
|
||||
```bash
|
||||
# Conda를 사용하여 모든 패키지 함께 설치하기
|
||||
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
|
||||
```
|
||||
|
||||
### Conda Docker 이미지
|
||||
|
||||
Ultralytics Conda Docker 이미지들도 [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics)에서 사용할 수 있습니다. 이 이미지들은 [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/)를 기반으로 하며, Conda 환경에서 `ultralytics`를 사용하기 위한 간단한 방법입니다.
|
||||
|
||||
```bash
|
||||
# 이미지 이름을 변수로 설정하기
|
||||
t=ultralytics/ultralytics:latest-conda
|
||||
|
||||
# Docker Hub에서 최신 ultralytics 이미지 가져오기
|
||||
sudo docker pull $t
|
||||
|
||||
# GPU 지원으로 ultralytics 이미지를 컨테이너에서 실행하기
|
||||
sudo docker run -it --ipc=host --gpus all $t # 모든 GPU 사용
|
||||
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # 특정 GPU 지정
|
||||
```
|
||||
|
||||
|
||||
=== "Git 복제하기"
|
||||
개발에 기여하거나 최신 소스 코드를 실험해 보고 싶다면 `ultralytics` 저장소를 복제하세요. 복제한 후 해당 디렉토리로 이동하여 pip을 이용해 편집 가능 모드 `-e`로 패키지를 설치합니다.
|
||||
```bash
|
||||
# ultralytics 저장소 복제하기
|
||||
git clone https://github.com/ultralytics/ultralytics
|
||||
|
||||
# 복제한 디렉토리로 이동하기
|
||||
cd ultralytics
|
||||
|
||||
# 개발을 위한 편집 가능 모드로 패키지 설치하기
|
||||
pip install -e .
|
||||
```
|
||||
|
||||
=== "Docker 사용하기"
|
||||
|
||||
Docker를 사용하면 `ultralytics` 패키지를 격리된 컨테이너에서 원활하게 실행할 수 있으며, 다양한 환경에서 일관된 성능을 보장합니다. [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics)의 공식 `ultralytics` 이미지 중 하나를 선택함으로써 로컬 설치의 복잡함을 피하고 검증된 작업 환경에 접근할 수 있습니다. Ultralytics은 서로 다른 플랫폼과 사용 사례에 대해 높은 호환성과 효율성을 제공하기 위해 5가지 주요 Docker 이미지를 제공합니다:
|
||||
|
||||
<a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Docker Pulls"></a>
|
||||
|
||||
- **Dockerfile:** 트레이닝에 추천되는 GPU 이미지입니다.
|
||||
- **Dockerfile-arm64:** Raspberry Pi와 같은 ARM64 기반 플랫폼에 배포하기에 최적화된 ARM64 아키텍처용입니다.
|
||||
- **Dockerfile-cpu:** GPU가 없는 환경에서 인퍼런스에 적합한 Ubuntu 기반 CPU 전용 버전입니다.
|
||||
- **Dockerfile-jetson:** NVIDIA Jetson 장치에 최적화된 GPU 지원을 통합한 버전입니다.
|
||||
- **Dockerfile-python:** 가볍게 애플리케이션을 위해 필요한 종속성과 Python만 있는 최소한의 이미지입니다.
|
||||
- **Dockerfile-conda:** Miniconda3를 기반으로 하며 ultralytics 패키지의 conda 설치를 포함하고 있습니다.
|
||||
|
||||
아래의 명령어로 최신 이미지를 받고 실행할 수 있습니다:
|
||||
|
||||
```bash
|
||||
# 이미지 이름을 변수로 설정하기
|
||||
t=ultralytics/ultralytics:latest
|
||||
|
||||
# Docker Hub에서 최신 ultralytics 이미지 가져오기
|
||||
sudo docker pull $t
|
||||
|
||||
# GPU 지원으로 ultralytics 이미지를 컨테이너에서 실행하기
|
||||
sudo docker run -it --ipc=host --gpus all $t # 모든 GPU 사용
|
||||
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # 특정 GPU 지정
|
||||
```
|
||||
|
||||
위 명령어는 최신 `ultralytics` 이미지로 Docker 컨테이너를 초기화합니다. `-it` 플래그는 pseudo-TTY를 할당하고 표준 입력을 유지하여 컨테이너와 상호 작용할 수 있게 해줍니다. `--ipc=host` 플래그는 프로세스 간 메모리 공유에 필요한 IPC(Inter-Process Communication) 네임스페이스를 호스트로 설정합니다. `--gpus all` 플래그는 컨테이너 내에서 사용 가능한 모든 GPU에 대한 접근을 활성화하는데, GPU 계산이 필요한 작업에 중요합니다.
|
||||
|
||||
참고: 로컬 기계의 파일을 컨테이너 내에서 작업하기 위해서는 로컬 디렉토리를 컨테이너에 마운트하는 데 Docker 볼륨을 사용하세요:
|
||||
|
||||
```bash
|
||||
# 로컬 디렉토리를 컨테이너 내부 디렉토리에 마운트하기
|
||||
sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
|
||||
```
|
||||
|
||||
`/path/on/host`를 로컬 기계의 디렉토리 경로로, `/path/in/container`를 컨테이너 내부에서 원하는 경로로 변경하여 접근할 수 있게 하세요.
|
||||
|
||||
Docker 사용에 대한 고급 기능은 [Ultralytics Docker 가이드](https://docs.ultralytics.com/guides/docker-quickstart/)에서 더 탐구해보세요.
|
||||
|
||||
`ultralytics`의 종속성 목록은 [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) 파일에서 확인할 수 있습니다. 위 예제에서는 모든 필요한 종속성을 설치합니다.
|
||||
|
||||
!!! tip "팁"
|
||||
|
||||
PyTorch 설치 요구사항은 운영 체제와 CUDA 요구사항에 따라 다르므로 [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally)의 지침에 따라 PyTorch를 먼저 설치하는 것이 권장됩니다.
|
||||
|
||||
<a href="https://pytorch.org/get-started/locally/">
|
||||
<img width="800" alt="PyTorch 설치 지침" src="https://user-images.githubusercontent.com/26833433/228650108-ab0ec98a-b328-4f40-a40d-95355e8a84e3.png">
|
||||
</a>
|
||||
|
||||
## 명령줄 인터페이스(CLI)로 Ultralytics 사용하기
|
||||
|
||||
Ultralytics 명령줄 인터페이스(CLI)는 Python 환경이 필요 없이 단일 라인 명령어를 통해 작업을 쉽게 실행할 수 있도록 합니다. CLI는 커스터마이징이나 Python 코드가 필요 없습니다. `yolo` 명령어를 이용해 터미널에서 모든 작업을 실행할 수 있습니다. 명령줄에서 YOLOv8을 사용하는 방법에 대해 더 알아보려면 [CLI 가이드](../usage/cli.md)를 참고하세요.
|
||||
|
||||
!!! example
|
||||
|
||||
=== "문법"
|
||||
|
||||
Ultralytics `yolo` 명령어는 다음과 같은 문법을 사용합니다:
|
||||
```bash
|
||||
yolo TASK MODE ARGS
|
||||
|
||||
여기서 TASK (선택적)은 [detect, segment, classify] 중 하나
|
||||
MODE (필수)는 [train, val, predict, export, track] 중 하나
|
||||
ARGS (선택적)은 'imgsz=320'과 같이 기본값을 재정의하는 'arg=value' 쌍을 아무 개수나 지정할 수 있습니다.
|
||||
```
|
||||
모든 ARGS는 전체 [구성 가이드](../usage/cfg.md)에서 또는 `yolo cfg`로 확인할 수 있습니다
|
||||
|
||||
=== "Train"
|
||||
|
||||
10 에포크 동안 초기 학습률 0.01로 감지 모델을 훈련합니다.
|
||||
```bash
|
||||
yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
|
||||
```
|
||||
|
||||
=== "Predict"
|
||||
|
||||
이전 훈련된 세분화 모델을 사용하여 이미지 크기 320으로 YouTube 동영상을 예측합니다:
|
||||
```bash
|
||||
yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
|
||||
```
|
||||
|
||||
=== "Val"
|
||||
|
||||
배치 크기 1와 이미지 크기 640으로 이전 훈련된 감지 모델을 검증합니다:
|
||||
```bash
|
||||
yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
|
||||
```
|
||||
|
||||
=== "Export"
|
||||
|
||||
YOLOv8n 분류 모델을 ONNX 형식으로 내보냅니다. 이미지 크기는 224x128입니다 (TASK 필요 없음).
|
||||
```bash
|
||||
yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
|
||||
```
|
||||
|
||||
=== "특별"
|
||||
|
||||
버전 확인, 설정 보기, 검사 실행 등을 위한 특별 명령어를 실행하세요:
|
||||
```bash
|
||||
yolo help
|
||||
yolo checks
|
||||
yolo version
|
||||
yolo settings
|
||||
yolo copy-cfg
|
||||
yolo cfg
|
||||
```
|
||||
|
||||
!!! warning "주의"
|
||||
|
||||
모든 인수는 `arg=val`쌍으로 전달되어야 하며, 각 쌍 사이에는 공백으로 구분해야 합니다. 인수 접두사로 `--`를 사용하거나 인수 사이에 쉼표 `,`를 사용해서는 안 됩니다.
|
||||
|
||||
- `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` ✅
|
||||
- `yolo predict model yolov8n.pt imgsz 640 conf 0.25` ❌
|
||||
- `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` ❌
|
||||
|
||||
[CLI 가이드](../usage/cli.md){ .md-button .md-button--primary}
|
||||
172
docs/ko/tasks/classify.md
Normal file
172
docs/ko/tasks/classify.md
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8 분류 모델에 대한 이미지 분류 정보를 알아보세요. 사전 훈련된 모델 목록과 모델 학습, 검증, 예측, 내보내기 방법에 대한 자세한 정보를 확인하실 수 있습니다.
|
||||
keywords: Ultralytics, YOLOv8, 이미지 분류, 사전 훈련된 모델, YOLOv8n-cls, 학습, 검증, 예측, 모델 내보내기
|
||||
---
|
||||
|
||||
# 이미지 분류
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418606-adf35c62-2e11-405d-84c6-b84e7d013804.png" alt="Image classification examples">
|
||||
|
||||
이미지 분류는 가장 단순한 세 가지 작업 중 하나로, 전체 이미지를 미리 정의된 클래스 집합 중 하나로 분류하는 작업입니다.
|
||||
|
||||
이미지 분류기의 출력은 단일 클래스 라벨과 신뢰도 점수입니다. 이미지 분류는 클래스의 이미지만 알고 싶고 해당 클래스의 객체가 어디에 위치하고 있는지 또는 그 정확한 형태가 무엇인지 알 필요가 없을 때 유용합니다.
|
||||
|
||||
!!! 팁 "팁"
|
||||
|
||||
YOLOv8 분류 모델은 `-cls` 접미사를 사용합니다. 예: `yolov8n-cls.pt`이며, [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)에서 사전 훈련되었습니다.
|
||||
|
||||
## [모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
여기에는 사전 훈련된 YOLOv8 분류 모델이 표시됩니다. Detect, Segment 및 Pose 모델은 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에서 사전 훈련되고, 분류 모델은 [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) 데이터셋에서 사전 훈련됩니다.
|
||||
|
||||
[모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)은 첫 사용 시 최신 Ultralytics [릴리스](https://github.com/ultralytics/assets/releases)에서 자동으로 다운로드됩니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | 정확도<br><sup>top1 | 정확도<br><sup>top5 | 속도<br><sup>CPU ONNX<br>(ms) | 속도<br><sup>A100 TensorRT<br>(ms) | 매개변수<br><sup>(M) | FLOPs<br><sup>(B) at 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 |
|
||||
|
||||
- **정확도** 값은 [ImageNet](https://www.image-net.org/) 데이터셋 검증 세트에서의 모델 정확도입니다.
|
||||
<br>[ImageNet](https://www.image-net.org/)에서 재현 가능합니다: `yolo val classify data=path/to/ImageNet device=0`
|
||||
- **속도**는 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 인스턴스를 사용해 ImageNet 검증 이미지들의 평균 속도입니다.
|
||||
<br>[ImageNet](https://www.image-net.org/)에서 재현 가능합니다: `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
|
||||
|
||||
## 학습
|
||||
|
||||
YOLOv8n-cls 모델을 MNIST160 데이터셋에서 100 에포크 동안 학습시키고 이미지 크기는 64로 설정합니다. 가능한 모든 인자는 [설정](../../usage/cfg.md) 페이지에서 확인할 수 있습니다.
|
||||
|
||||
!!! 예제 ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 불러오기
|
||||
model = YOLO('yolov8n-cls.yaml') # YAML에서 새 모델 구축
|
||||
model = YOLO('yolov8n-cls.pt') # 사전 훈련된 모델 불러오기 (학습용 추천)
|
||||
model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # YAML로 구축하고 가중치 전송
|
||||
|
||||
# 모델 학습
|
||||
result = model.train(data='mnist160', epochs=100, imgsz=64)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# YAML에서 새 모델을 구축하고 처음부터 학습 시작
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
|
||||
|
||||
# 사전 훈련된 *.pt 모델에서 학습 시작
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
|
||||
|
||||
# YAML에서 새 모델을 구축하고 사전 훈련된 가중치를 전송한 뒤 학습 시작
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
|
||||
```
|
||||
|
||||
### 데이터셋 형식
|
||||
|
||||
YOLO 분류 데이터셋 형식은 [데이터셋 가이드](../../datasets/classify/index.md)에서 자세히 확인할 수 있습니다.
|
||||
|
||||
## 검증
|
||||
|
||||
학습된 YOLOv8n-cls 모델의 정확도를 MNIST160 데이터셋에서 검증합니다. `model`은 모델 속성으로 훈련 시 `data` 및 인자를 유지하므로 추가 인자를 전달할 필요가 없습니다.
|
||||
|
||||
!!! 예제 ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 불러오기
|
||||
model = YOLO('yolov8n-cls.pt') # 공식 모델 불러오기
|
||||
model = YOLO('path/to/best.pt') # 사용자 모델 불러오기
|
||||
|
||||
# 모델 검증
|
||||
metrics = model.val() # 추가 인자 불필요, 데이터셋 및 설정 기억함
|
||||
metrics.top1 # top1 정확도
|
||||
metrics.top5 # top5 정확도
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify val model=yolov8n-cls.pt # 공식 모델 검증
|
||||
yolo classify val model=path/to/best.pt # 사용자 모델 검증
|
||||
```
|
||||
|
||||
## 예측
|
||||
|
||||
학습된 YOLOv8n-cls 모델을 사용하여 이미지에 대한 예측을 실행합니다.
|
||||
|
||||
!!! 예제 ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 불러오기
|
||||
model = YOLO('yolov8n-cls.pt') # 공식 모델 불러오기
|
||||
model = YOLO('path/to/best.pt') # 사용자 모델 불러오기
|
||||
|
||||
# 예측 실행
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # 이미지에 대한 예측 실행
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # 공식 모델로 예측 실행
|
||||
yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # 사용자 모델로 예측 실행
|
||||
```
|
||||
|
||||
자세한 `predict` 모드 정보는 [예측](https://docs.ultralytics.com/modes/predict/) 페이지에서 확인하세요.
|
||||
|
||||
## 내보내기
|
||||
|
||||
YOLOv8n-cls 모델을 ONNX, CoreML 등과 같은 다른 형식으로 내보냅니다.
|
||||
|
||||
!!! 예제 ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 불러오기
|
||||
model = YOLO('yolov8n-cls.pt') # 공식 모델 불러오기
|
||||
model = YOLO('path/to/best.pt') # 사용자 훈련 모델 불러오기
|
||||
|
||||
# 모델 내보내기
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-cls.pt format=onnx # 공식 모델 내보내기
|
||||
yolo export model=path/to/best.pt format=onnx # 사용자 훈련 모델 내보내기
|
||||
```
|
||||
|
||||
아래 표에 사용 가능한 YOLOv8-cls 내보내기 형식이 나와 있습니다. 내보낸 모델에서 바로 예측하거나 검증할 수 있습니다. 즉, `yolo predict model=yolov8n-cls.onnx`를 사용할 수 있습니다. 내보내기가 완료된 후 모델에 대한 사용 예제들이 표시됩니다.
|
||||
|
||||
| 형식 | `format` 인자 | 모델 | 메타데이터 | 인자 |
|
||||
|--------------------------------------------------------------------|---------------|-------------------------------|-------|-----------------------------------------------------|
|
||||
| [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` |
|
||||
|
||||
자세한 `export` 정보는 [내보내기](https://docs.ultralytics.com/modes/export/) 페이지에서 확인하세요.
|
||||
184
docs/ko/tasks/detect.md
Normal file
184
docs/ko/tasks/detect.md
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics 공식 YOLOv8 문서입니다. 모델 훈련, 검증, 예측 및 다양한 형식으로 모델 내보내기 방법을 배우십시오. 세부적인 성능 통계를 포함합니다.
|
||||
keywords: YOLOv8, Ultralytics, 객체 감지, 사전 훈련된 모델, 훈련, 검증, 예측, 모델 내보내기, COCO, ImageNet, PyTorch, ONNX, CoreML
|
||||
---
|
||||
|
||||
# 객체 감지
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418624-5785cb93-74c9-4541-9179-d5c6782d491a.png" alt="객체 감지 예제">
|
||||
|
||||
객체 감지는 이미지 또는 비디오 스트림 내의 객체의 위치와 클래스를 식별하는 작업입니다.
|
||||
|
||||
객체 감지기의 출력은 이미지 속 객체를 내포하는 경계 상자(bounding box) 세트와 각 상자에 대한 클래스 레이블과 신뢰도 점수를 포함합니다. 장면 내 관심 객체를 식별해야 하지만 객체의 정확한 위치나 정확한 모양을 알 필요가 없을 때 객체 감지가 좋은 선택입니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/5ku7npMrW40?si=6HQO1dDXunV8gekh"
|
||||
title="YouTube 비디오 플레이어" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청하기:</strong> 사전 훈련된 Ultralytics YOLOv8 모델로 객체 감지하기.
|
||||
</p>
|
||||
|
||||
!!! tip "팁"
|
||||
|
||||
YOLOv8 Detect 모델들은 기본 YOLOv8 모델이며 예를 들어 `yolov8n.pt` 이 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에서 사전 훈련되었습니다.
|
||||
|
||||
## [모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
여기서는 YOLOv8 사전 훈련된 Detect 모델을 나타냅니다. Detect, Segment, 및 Pose 모델은 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에서, Classify 모델은 [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) 데이터셋에서 사전 훈련되었습니다.
|
||||
|
||||
[모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)은 첫 사용 시 Ultralytics의 최신 [릴리즈](https://github.com/ultralytics/assets/releases)에서 자동으로 다운로드됩니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | mAP<sup>val<br>50-95 | 속도<br><sup>CPU ONNX<br>(ms) | 속도<br><sup>A100 TensorRT<br>(ms) | 파라미터<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 |
|
||||
|
||||
- **mAP<sup>val</sup>** 값은 [COCO val2017](http://cocodataset.org) 데이터셋에서 단일 모델 단일 스케일을 사용한 값입니다.
|
||||
<br>[COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터와 `yolo val detect data=coco.yaml device=0` 명령으로 재현할 수 있습니다.
|
||||
- **속도**는 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 인스턴스를 사용해 COCO val 이미지들을 평균한 것입니다.
|
||||
<br>[COCO128](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco128.yaml) 데이터와 `yolo val detect data=coco128.yaml batch=1 device=0|cpu` 명령으로 재현할 수 있습니다.
|
||||
|
||||
## 훈련
|
||||
|
||||
COCO128 데이터셋에서 이미지 크기 640으로 YOLOv8n 모델을 100 에포크 동안 훈련합니다. 가능한 모든 인수에 대한 목록은 [설정](../../usage/cfg.md) 페이지에서 확인할 수 있습니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 로드하기
|
||||
model = YOLO('yolov8n.yaml') # YAML에서 새 모델을 빌드합니다.
|
||||
model = YOLO('yolov8n.pt') # 사전 훈련된 모델을 로드합니다(훈련을 위해 권장됩니다).
|
||||
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # YAML에서 빌드하고 가중치를 전달합니다.
|
||||
|
||||
# 모델 훈련하기
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# YAML에서 새 모델을 빌드하고 처음부터 훈련을 시작합니다.
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
|
||||
|
||||
# 사전 훈련된 *.pt 모델로부터 훈련을 시작합니다.
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
|
||||
# YAML에서 새 모델을 빌드하고, 사전 훈련된 가중치를 전달한 후 훈련을 시작합니다.
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### 데이터셋 형식
|
||||
|
||||
YOLO 감지 데이터셋 형식은 [데이터셋 가이드](../../datasets/detect/index.md)에서 자세히 볼 수 있습니다. 다른 형식(예: COCO 등)의 기존 데이터셋을 YOLO 형식으로 변환하려면 Ultralytics의 [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) 도구를 사용하십시오.
|
||||
|
||||
## 검증
|
||||
|
||||
COCO128 데이터셋에서 훈련된 YOLOv8n 모델의 정확도를 검증합니다. `model`은 훈련 시의 `data`와 인수를 모델 속성으로 보존하기 때문에 인수를 전달할 필요가 없습니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 로드하기
|
||||
model = YOLO('yolov8n.pt') # 공식 모델을 로드합니다.
|
||||
model = YOLO('path/to/best.pt') # 사용자 정의 모델을 로드합니다.
|
||||
|
||||
# 모델 검증하기
|
||||
metrics = model.val() # 데이터셋과 설정을 기억하니 인수는 필요 없습니다.
|
||||
metrics.box.map # map50-95
|
||||
metrics.box.map50 # map50
|
||||
metrics.box.map75 # map75
|
||||
metrics.box.maps # 각 카테고리의 map50-95가 포함된 리스트입니다.
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect val model=yolov8n.pt # 공식 모델 검증하기
|
||||
yolo detect val model=path/to/best.pt # 사용자 정의 모델 검증하기
|
||||
```
|
||||
|
||||
## 예측
|
||||
|
||||
훈련된 YOLOv8n 모델을 사용하여 이미지에 대한 예측을 수행합니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 로드하기
|
||||
model = YOLO('yolov8n.pt') # 공식 모델을 로드합니다.
|
||||
model = YOLO('path/to/best.pt') # 사용자 정의 모델을 로드합니다.
|
||||
|
||||
# 모델로 예측하기
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # 이미지에 대해 예측합니다.
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # 공식 모델로 예측하기
|
||||
yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # 사용자 정의 모델로 예측하기
|
||||
```
|
||||
|
||||
전체 'predict' 모드 세부 사항은 [Predict](https://docs.ultralytics.com/modes/predict/) 페이지에서 확인하세요.
|
||||
|
||||
## 내보내기
|
||||
|
||||
YOLOv8n 모델을 ONNX, CoreML 등과 같은 다른 형식으로 내보냅니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 로드하기
|
||||
model = YOLO('yolov8n.pt') # 공식 모델을 로드합니다.
|
||||
model = YOLO('path/to/best.pt') # 사용자 정의 모델을 로드합니다.
|
||||
|
||||
# 모델 내보내기
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n.pt format=onnx # 공식 모델 내보내기
|
||||
yolo export model=path/to/best.pt format=onnx # 사용자 정의 모델 내보내기
|
||||
```
|
||||
|
||||
사용 가능한 YOLOv8 내보내기 형식은 아래 표에 나와 있습니다. 내보내기 완료 후 사용 예시는 모델에 대해 보여줍니다.
|
||||
|
||||
| 형식 | `format` 인수 | 모델 | 메타데이터 | 인수 |
|
||||
|--------------------------------------------------------------------|---------------|---------------------------|-------|-----------------------------------------------------|
|
||||
| [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` |
|
||||
|
||||
전체 'export' 세부 사항은 [Export](https://docs.ultralytics.com/modes/export/) 페이지에서 확인하세요.
|
||||
55
docs/ko/tasks/index.md
Normal file
55
docs/ko/tasks/index.md
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8을 사용하여 수행할 수 있는 컴퓨터 비전 작업의 기초인 탐지, 세분화, 분류 및 자세 추정에 대해 알아보세요. AI 프로젝트에서의 그 용도를 이해하세요.
|
||||
keywords: Ultralytics, YOLOv8, 탐지, 세분화, 분류, 자세 추정, AI 프레임워크, 컴퓨터 비전 작업
|
||||
---
|
||||
|
||||
# Ultralytics YOLOv8 작업
|
||||
|
||||
<br>
|
||||
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png" alt="Ultralytics YOLO 지원 작업">
|
||||
|
||||
YOLOv8는 여러 컴퓨터 비전 **작업**을 지원하는 AI 프레임워크입니다. 이 프레임워크는 [탐지](detect.md), [세분화](segment.md), [분류](classify.md), 그리고 [자세](pose.md) 추정을 수행하는 데 사용될 수 있습니다. 각각의 작업은 서로 다른 목적과 사용 사례를 가지고 있습니다.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 다국어 문서화 작업이 진행 중에 있으며, 더 나은 문서를 제공하기 위해 노력하고 있습니다. 인내해 주셔서 감사합니다! 🙏
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/NAs-cfq9BDw"
|
||||
title="YouTube 비디오 플레이어" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>보기:</strong> Ultralytics YOLO 작업 탐색: 객체 탐지, 세분화, 추적, 자세 추정.
|
||||
</p>
|
||||
|
||||
## [탐지](detect.md)
|
||||
|
||||
탐지는 YOLOv8이 지원하는 기본 작업입니다. 이미지 또는 비디오 프레임에서 객체를 탐지하고 주변에 경계 상자를 그리는 것을 포함합니다. 탐지된 객체들은 그 특징에 따라 다른 카테고리로 분류됩니다. YOLOv8은 단일 이미지나 비디오 프레임에서 여러 객체를 정확하고 빠르게 탐지할 수 있습니다.
|
||||
|
||||
[탐지 예시](detect.md){ .md-button .md-button--primary}
|
||||
|
||||
## [세분화](segment.md)
|
||||
|
||||
세분화는 이미지를 내용에 기반하여 다른 영역으로 나누는 작업입니다. 각 영역은 내용에 따라 레이블이 지정됩니다. 이 작업은 이미지 세분화와 의료 영상과 같은 응용 분야에 유용합니다. YOLOv8는 U-Net 아키텍처의 변형을 사용하여 세분화를 수행합니다.
|
||||
|
||||
[세분화 예시](segment.md){ .md-button .md-button--primary}
|
||||
|
||||
## [분류](classify.md)
|
||||
|
||||
분류는 이미지를 다른 카테고리로 분류하는 작업입니다. YOLOv8는 이미지의 내용을 바탕으로 이미지 분류에 사용될 수 있습니다. 이는 EfficientNet 아키텍처의 변형을 사용하여 분류 작업을 수행합니다.
|
||||
|
||||
[분류 예시](classify.md){ .md-button .md-button--primary}
|
||||
|
||||
## [자세](pose.md)
|
||||
|
||||
자세/키포인트 탐지는 이미지나 비디오 프레임에서 특정 점들을 탐지하는 작업입니다. 이들 점은 키포인트로 불리며, 움직임 추적이나 자세 추정에 사용됩니다. YOLOv8은 이미지나 비디오 프레임의 키포인트를 정확하고 빠르게 탐지할 수 있습니다.
|
||||
|
||||
[자세 예시](pose.md){ .md-button .md-button--primary}
|
||||
|
||||
## 결론
|
||||
|
||||
YOLOv8은 탐지, 세분화, 분류, 키포인트 탐지 등 다양한 작업을 지원합니다. 각각의 작업은 다른 목적과 사용 사례를 가지고 있습니다. 이러한 작업의 차이점을 이해함으로써, 컴퓨터 비전 응용 프로그램에 적합한 작업을 선택할 수 있습니다.
|
||||
185
docs/ko/tasks/pose.md
Normal file
185
docs/ko/tasks/pose.md
Normal file
|
|
@ -0,0 +1,185 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics YOLOv8을 사용하여 포즈 추정 작업을 수행하는 방법을 알아보세요. 미리 학습된 모델을 찾고, 학습, 검증, 예측, 내보내기 등을 진행하는 방법을 배울 수 있습니다.
|
||||
keywords: Ultralytics, YOLO, YOLOv8, 포즈 추정, 키포인트 검출, 객체 검출, 미리 학습된 모델, 기계 학습, 인공 지능
|
||||
---
|
||||
|
||||
# 포즈 추정
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png" alt="포즈 추정 예시">
|
||||
|
||||
포즈 추정은 이미지 내 특정 점들의 위치를 식별하는 작업입니다. 이러한 점들은 보통 관절, 표식, 또는 기타 구별 가능한 특징으로 나타나는 키포인트입니다. 키포인트의 위치는 대개 2D `[x, y]` 또는 3D `[x, y, visible]` 좌표의 집합으로 표현됩니다.
|
||||
|
||||
포즈 추정 모델의 출력은 이미지 속 객체 상의 키포인트를 나타내는 점들의 집합과 각 점의 신뢰도 점수를 포함합니다. 포즈 추정은 장면 속 객체의 구체적인 부분을 식별하고, 서로 관련된 위치를 파악해야 할 때 좋은 선택입니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청하기:</strong> Ultralytics YOLOv8을 이용한 포즈 추정.
|
||||
</p>
|
||||
|
||||
!!! tip "팁"
|
||||
|
||||
YOLOv8 _pose_ 모델은 `-pose` 접미사가 붙습니다. 예: `yolov8n-pose.pt`. 이 모델들은 [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) 데이터셋으로 학습되었으며 포즈 추정 작업에 적합합니다.
|
||||
|
||||
## [모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
여기에 표시된 YOLOv8 미리 학습된 포즈 모델을 확인하세요. Detect, Segment 및 Pose 모델은 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋으로 미리 학습되며, Classify 모델은 [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) 데이터셋으로 미리 학습됩니다.
|
||||
|
||||
[모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)은 첫 사용 시 Ultralytics [릴리스](https://github.com/ultralytics/assets/releases)에서 자동으로 다운로드됩니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | mAP<sup>포즈<br>50-95 | mAP<sup>포즈<br>50 | 속도<br><sup>CPU ONNX<br>(ms) | 속도<br><sup>A100 TensorRT<br>(ms) | 파라미터<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>** 값은 [COCO Keypoints val2017](http://cocodataset.org) 데이터셋에서 단일 모델 단일 규모를 기준으로 합니다.
|
||||
<br>재현하려면 `yolo val pose data=coco-pose.yaml device=0`을 사용하세요.
|
||||
- **속도**는 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 인스턴스를 사용하여 COCO val 이미지 평균입니다.
|
||||
<br>재현하려면 `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`를 사용하세요.
|
||||
|
||||
## 학습
|
||||
|
||||
COCO128-pose 데이터셋에서 YOLOv8-pose 모델 학습하기.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 불러오기
|
||||
model = YOLO('yolov8n-pose.yaml') # YAML에서 새로운 모델 구축
|
||||
model = YOLO('yolov8n-pose.pt') # 사전 학습된 모델 불러오기 (학습에 추천)
|
||||
model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # YAML에서 구축하고 가중치 전달
|
||||
|
||||
# 모델 학습
|
||||
results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# YAML에서 새로운 모델 구축하고 처음부터 학습 시작
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
|
||||
|
||||
# 사전 학습된 *.pt 모델로부터 학습 시작
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
|
||||
# YAML에서 새로운 모델 구축하고 사전 학습된 가중치를 전달하여 학습 시작
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### 데이터셋 형식
|
||||
|
||||
YOLO 포즈 데이터셋 형식에 대한 자세한 내용은 [데이터셋 가이드](../../datasets/pose/index.md)에서 찾아볼 수 있습니다. 기존 데이터셋을 다른 형식(예: COCO 등)에서 YOLO 형식으로 변환하려면 Ultralytics의 [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) 도구를 사용하세요.
|
||||
|
||||
## 검증
|
||||
|
||||
학습된 YOLOv8n-pose 모델의 정확도를 COCO128-pose 데이터셋에서 검증하기. 모델은 학습 `data` 및 인수를 모델 속성으로 유지하기 때문에 인수를 전달할 필요가 없습니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 불러오기
|
||||
model = YOLO('yolov8n-pose.pt') # 공식 모델 불러오기
|
||||
model = YOLO('path/to/best.pt') # 사용자 모델 불러오기
|
||||
|
||||
# 모델 검증
|
||||
metrics = model.val() # 데이터셋 및 설정을 기억하므로 인수 필요 없음
|
||||
metrics.box.map # map50-95
|
||||
metrics.box.map50 # map50
|
||||
metrics.box.map75 # map75
|
||||
metrics.box.maps # 각 범주의 map50-95를 포함하는 리스트
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose val model=yolov8n-pose.pt # 공식 모델 검증
|
||||
yolo pose val model=path/to/best.pt # 사용자 모델 검증
|
||||
```
|
||||
|
||||
## 예측
|
||||
|
||||
학습된 YOLOv8n-pose 모델을 사용하여 이미지에 대한 예측 수행하기.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 불러오기
|
||||
model = YOLO('yolov8n-pose.pt') # 공식 모델 불러오기
|
||||
model = YOLO('path/to/best.pt') # 사용자 모델 불러오기
|
||||
|
||||
# 모델로 예측하기
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # 이미지에서 예측
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # 공식 모델로 예측
|
||||
yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # 사용자 모델로 예측
|
||||
```
|
||||
|
||||
`predict` 모드의 전체 세부 정보는 [예측](https://docs.ultralytics.com/modes/predict/) 페이지에서 확인하세요.
|
||||
|
||||
## 내보내기
|
||||
|
||||
YOLOv8n 포즈 모델을 ONNX, CoreML 등 다른 형식으로 내보내기.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델 불러오기
|
||||
model = YOLO('yolov8n-pose.pt') # 공식 모델 불러오기
|
||||
model = YOLO('path/to/best.pt') # 사용자 학습 모델 불러오기
|
||||
|
||||
# 모델 내보내기
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-pose.pt format=onnx # 공식 모델 내보내기
|
||||
yolo export model=path/to/best.pt format=onnx # 사용자 학습 모델 내보내기
|
||||
```
|
||||
|
||||
YOLOv8-pose 내보내기 가능한 형식은 아래 표에 나열되어 있습니다. 내보낸 모델에서 직접 예측 또는 검증이 가능합니다, 예: `yolo predict model=yolov8n-pose.onnx`. 내보내기가 완료된 후 모델 사용 예제가 표시됩니다.
|
||||
|
||||
| 형식 | `format` 인수 | 모델 | 메타데이터 | 인수 |
|
||||
|--------------------------------------------------------------------|---------------|--------------------------------|-------|-----------------------------------------------------|
|
||||
| [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` |
|
||||
|
||||
`export`의 전체 세부 정보는 [내보내기](https://docs.ultralytics.com/modes/export/) 페이지에서 확인하세요.
|
||||
188
docs/ko/tasks/segment.md
Normal file
188
docs/ko/tasks/segment.md
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics YOLO를 이용한 인스턴스 세그멘테이션 모델 사용법 배우기. 훈련, 검증, 이미지 예측 및 모델 수출에 대한 지침.
|
||||
keywords: yolov8, 인스턴스 세그멘테이션, Ultralytics, COCO 데이터셋, 이미지 세그멘테이션, 객체 탐지, 모델 훈련, 모델 검증, 이미지 예측, 모델 수출
|
||||
---
|
||||
|
||||
# 인스턴스 세그멘테이션
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418644-7df320b8-098d-47f1-85c5-26604d761286.png" alt="인스턴스 세그멘테이션 예시">
|
||||
|
||||
인스턴스 세그멘테이션은 객체 탐지를 한 단계 더 발전시켜 이미지에서 각각의 개별 객체를 식별하고 이미지의 나머지 부분에서 분리하는 기술입니다.
|
||||
|
||||
인스턴스 세그멘테이션 모델의 출력은 이미지의 각 객체를 윤곽하는 마스크나 윤곽 선뿐만 아니라 각 객체에 대한 클래스 레이블과 신뢰도 점수로 구성됩니다. 객체들이 이미지 안에서 어디에 있는지 뿐만 아니라 그들의 정확한 형태가 무엇인지 알아야 할 때 인스턴스 세그멘테이션이 유용합니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/o4Zd-IeMlSY?si=37nusCzDTd74Obsp"
|
||||
title="YouTube 비디오 플레이어" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>시청하기:</strong> Python에서 사전 훈련된 Ultralytics YOLOv8 모델로 세그멘테이션 실행.
|
||||
</p>
|
||||
|
||||
!!! tip "팁"
|
||||
|
||||
YOLOv8 Segment 모델은 '-seg' 접미사를 사용하며 즉, `yolov8n-seg.pt`와 같이 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에 사전 훈련되어 있습니다.
|
||||
|
||||
## [모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
여기에는 YOLOv8 사전 훈련 세그먼트 모델들이 나열되어 있습니다. Detect, Segment, Pose 모델들은 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에 사전 훈련되어 있으며, Classify 모델들은 [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) 데이터셋에 사전 훈련되어 있습니다.
|
||||
|
||||
[모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)은 첫 사용 시 Ultralytics의 최신 [릴리스](https://github.com/ultralytics/assets/releases)에서 자동으로 다운로드 됩니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | mAP<sup>박스<br>50-95 | mAP<sup>마스크<br>50-95 | 속도<br><sup>CPU ONNX<br>(밀리초) | 속도<br><sup>A100 TensorRT<br>(밀리초) | 매개변수<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 |
|
||||
|
||||
- **mAP<sup>val</sup>** 값들은 [COCO val2017](http://cocodataset.org) 데이터셋에서 단일 모델 단일 스케일로 얻은 값입니다.
|
||||
<br>복제는 `yolo val segment data=coco.yaml device=0` 명령어로 실행할 수 있습니다.
|
||||
- **속도**는 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 인스턴스를 이용하여 COCO 검증 이미지로 평균 내었습니다.
|
||||
<br>복제는 `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` 명령어로 실행할 수 있습니다.
|
||||
|
||||
## 훈련
|
||||
|
||||
COCO128-seg 데이터셋에서 이미지 크기 640으로 YOLOv8n-seg을 100 에포크 동안 훈련합니다. 가능한 모든 인자 목록은 [설정](../../usage/cfg.md) 페이지에서 확인할 수 있습니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 불러옵니다
|
||||
model = YOLO('yolov8n-seg.yaml') # YAML에서 새로운 모델을 구성
|
||||
model = YOLO('yolov8n-seg.pt') # 사전 훈련된 모델을 불러옴 (훈련에 추천)
|
||||
model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # YAML에서 구성하고 가중치를 전달
|
||||
|
||||
# 모델을 훈련시킵니다
|
||||
results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# YAML에서 새로운 모델을 구성하고 처음부터 훈련을 시작합니다
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
|
||||
|
||||
# 사전 훈련된 *.pt 모델로 부터 훈련을 시작합니다
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
|
||||
# YAML에서 새로운 모델을 구성하고 사전 훈련된 가중치를 전달한 뒤 훈련을 시작합니다
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### 데이터셋 형식
|
||||
|
||||
YOLO 세그멘테이션 데이터셋 형식은 [데이터셋 가이드](../../datasets/segment/index.md)에서 자세히 확인할 수 있습니다. 기존 데이터셋 (COCO 등)을 YOLO 형식으로 변환하려면 Ultralytics의 [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) 도구를 이용하세요.
|
||||
|
||||
## 검증
|
||||
|
||||
COCO128-seg 데이터셋에서 훈련된 YOLOv8n-seg 모델의 정확도를 검증합니다. 모델은 훈련할 때의 `data`와 인자를 모델 속성으로 기억하기 때문에 별도의 인자를 전달할 필요가 없습니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 불러옵니다
|
||||
model = YOLO('yolov8n-seg.pt') # 공식 모델을 불러옴
|
||||
model = YOLO('path/to/best.pt') # 커스텀 모델을 불러옴
|
||||
|
||||
# 모델을 검증합니다
|
||||
metrics = model.val() # 데이터셋과 설정이 기억되어 있어 인자가 필요 없습니다
|
||||
metrics.box.map # map50-95(B)
|
||||
metrics.box.map50 # map50(B)
|
||||
metrics.box.map75 # map75(B)
|
||||
metrics.box.maps # 각 카테고리별 map50-95(B) 리스트
|
||||
metrics.seg.map # map50-95(M)
|
||||
metrics.seg.map50 # map50(M)
|
||||
metrics.seg.map75 # map75(M)
|
||||
metrics.seg.maps # 각 카테고리별 map50-95(M) 리스트
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo segment val model=yolov8n-seg.pt # 공식 모델로 검증
|
||||
yolo segment val model=path/to/best.pt # 커스텀 모델로 검증
|
||||
```
|
||||
|
||||
## 예측
|
||||
|
||||
훈련된 YOLOv8n-seg 모델을 사용하여 이미지에 대한 예측을 실행합니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 불러옵니다
|
||||
model = YOLO('yolov8n-seg.pt') # 공식 모델을 불러옴
|
||||
model = YOLO('path/to/best.pt') # 커스텀 모델을 불러옴
|
||||
|
||||
# 모델로 예측을 진행합니다
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # 이미지에 대한 예측
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # 공식 모델로 예측 실행
|
||||
yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # 커스텀 모델로 예측 실행
|
||||
```
|
||||
|
||||
`predict` 모드의 전체 세부 사항은 [예측](https://docs.ultralytics.com/modes/predict/) 페이지에서 확인할 수 있습니다.
|
||||
|
||||
## 수출
|
||||
|
||||
ONNX, CoreML 등과 같은 다른 형식으로 YOLOv8n-seg 모델을 수출합니다.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 모델을 불러옵니다
|
||||
model = YOLO('yolov8n-seg.pt') # 공식 모델을 불러옴
|
||||
model = YOLO('path/to/best.pt') # 커스텀 훈련 모델을 불러옴
|
||||
|
||||
# 모델을 수출합니다
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-seg.pt format=onnx # 공식 모델을 수출합니다
|
||||
yolo export model=path/to/best.pt format=onnx # 커스텀 훈련 모델을 수출합니다
|
||||
```
|
||||
|
||||
아래 표에 나열된 것은 가능한 YOLOv8-seg 수출 형식입니다. 수출 완료 후 모델 사용 예는 모델을 직접 예측하거나 검증할 때 사용할 수 있습니다.
|
||||
|
||||
| 형식 | `format` 인자 | 모델 | 메타데이터 | 인자 |
|
||||
|--------------------------------------------------------------------|---------------|-------------------------------|-------|-----------------------------------------------------|
|
||||
| [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` |
|
||||
|
||||
`export`의 전체 세부 사항은 [수출](https://docs.ultralytics.com/modes/export/) 페이지에서 확인할 수 있습니다.
|
||||
Loading…
Add table
Add a link
Reference in a new issue