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
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' |
|
||||
|
|
||||
Loading…
Add table
Add a link
Reference in a new issue