Update https://docs.ultralytics.com/models (#6513)
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com> Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
Glenn Jocher
GitHub
parent
0c4e97443b
commit
16a13a1ce0
178 changed files with 14224 additions and 561 deletions
193
docs/ko/models/fast-sam.md
Normal file
193
docs/ko/models/fast-sam.md
Normal file
|
|
@ -0,0 +1,193 @@
|
|||
---
|
||||
comments: true
|
||||
description: FastSAM은 이미지에서 실시간 객체 분할을 위한 CNN 기반 솔루션으로, 향상된 사용자 상호작용, 계산 효율성, 다양한 비전 작업에 대응할 수 있는 특징을 갖고 있습니다.
|
||||
keywords: FastSAM, 머신러닝, CNN 기반 솔루션, 객체 분할, 실시간 솔루션, Ultralytics, 비전 작업, 이미지 처리, 산업 응용, 사용자 상호작용
|
||||
---
|
||||
|
||||
# Fast Segment Anything Model (FastSAM)
|
||||
|
||||
Fast Segment Anything Model (FastSAM)은 Segment Anything 작업을 위한 새로운 실시간 CNN 기반 솔루션입니다. 이 작업은 다양한 사용자 상호작용 프롬프트에 따라 이미지 내의 모든 객체를 분할하는 것을 목표로 합니다. FastSAM은 계산 요구 사항을 크게 줄이면서 경쟁력 있는 성능을 유지하기 때문에 다양한 비전 작업에 실용적인 선택지가 될 수 있습니다.
|
||||
|
||||
|
||||
|
||||
## 개요
|
||||
|
||||
FastSAM은 계산 리소스 요구 사항이 큰 Transformer 모델인 Segment Anything Model (SAM)의 한계를 해결하기 위해 설계되었습니다. FastSAM은 Segment Anything 작업을 두 단계로 분리한 방식을 채택합니다: 모든 인스턴스 분할과 프롬프트로 인한 영역 선택. 첫 번째 단계에서는 [YOLOv8-seg](../tasks/segment.md)를 사용하여 이미지의 모든 인스턴스의 분할 마스크를 생성합니다. 두 번째 단계에서는 프롬프트에 해당하는 관심 영역을 출력합니다.
|
||||
|
||||
## 주요 특징
|
||||
|
||||
1. **실시간 솔루션**: CNN의 계산 효율성을 활용하여 FastSAM은 Segment Anything 작업에 대한 실시간 솔루션을 제공하며, 빠른 결과가 필요한 산업 응용에 가치가 있습니다.
|
||||
|
||||
2. **효율성과 성능**: FastSAM은 성능 품질을 희생하지 않고 계산과 리소스 요구 사항을 크게 줄입니다. SAM과 비교해 유사한 성능을 달성하면서 계산 리소스를 크게 줄여 실시간 응용이 가능해집니다.
|
||||
|
||||
3. **프롬프트 안내 분할**: FastSAM은 다양한 사용자 상호작용 프롬프트에 따라 이미지 내의 모든 객체를 분할할 수 있으므로 다양한 시나리오에서 유연성과 적응성을 제공합니다.
|
||||
|
||||
4. **YOLOv8-seg 기반**: FastSAM은 [YOLOv8-seg](../tasks/segment.md)를 기반으로 한 것으로, 인스턴스 분할 브랜치가 장착된 객체 감지기입니다. 이를 통해 이미지의 모든 인스턴스의 분할 마스크를 효과적으로 생성할 수 있습니다.
|
||||
|
||||
5. **벤치마크에서 경쟁 결과**: MS COCO에서의 객체 제안 작업에서 FastSAM은 [SAM](sam.md)에 비해 단일 NVIDIA RTX 3090에서 훨씬 더 빠른 속도로 높은 점수를 달성하여 효율성과 능력을 입증했습니다.
|
||||
|
||||
6. **실용적인 응용**: FastSAM은 현재 방법보다 수십 배 또는 수백 배 더 빠른 속도로 여러 비전 작업의 신속한 솔루션을 제공하여 실질적인 적용 가능성을 제시합니다.
|
||||
|
||||
7. **모델 압축 가능성**: FastSAM은 구조에 인공 사전을 도입하여 계산 비용을 크게 줄일 수 있는 경로를 보여주어 일반 비전 작업에 대한 대형 모델 아키텍처에 대한 새로운 가능성을 열어줍니다.
|
||||
|
||||
## 사용 가능한 모델, 지원되는 작업 및 운영 모드
|
||||
|
||||
이 표는 사용 가능한 모델과 해당하는 사전 훈련 가중치, 지원하는 작업 및 [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), [Export](../modes/export.md)와 같은 다른 운영 모드에 대한 호환성을 나타내며, 지원되는 모드는 ✅ 이모지로, 지원되지 않는 모드는 ❌ 이모지로 표시됩니다.
|
||||
|
||||
| 모델 유형 | 사전 훈련 가중치 | 지원되는 작업 | Inference | Validation | Training | Export |
|
||||
|-----------|----------------|--------------------------------|-----------|------------|----------|--------|
|
||||
| FastSAM-s | `FastSAM-s.pt` | [인스턴스 분할](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
| FastSAM-x | `FastSAM-x.pt` | [인스턴스 분할](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## 사용 예시
|
||||
|
||||
FastSAM 모델을 Python 애플리케이션에 쉽게 통합할 수 있습니다. Ultralytics는 개발을 간소화하기 위해 사용자 친화적인 Python API 및 CLI 명령을 제공합니다.
|
||||
|
||||
### 예측 사용법
|
||||
|
||||
이미지에서 객체 검출을 수행하려면 다음과 같이 `predict` 메서드를 사용합니다:
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import FastSAM
|
||||
from ultralytics.models.fastsam import FastSAMPrompt
|
||||
|
||||
# 추론 소스 정의
|
||||
source = 'path/to/bus.jpg'
|
||||
|
||||
# FastSAM 모델 생성
|
||||
model = FastSAM('FastSAM-s.pt') # 또는 FastSAM-x.pt
|
||||
|
||||
# 이미지에 대한 추론 실행
|
||||
everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
|
||||
|
||||
# Prompt Process 객체 준비
|
||||
prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
|
||||
|
||||
# 모든 프롬프트
|
||||
ann = prompt_process.everything_prompt()
|
||||
|
||||
# 바운딩 박스의 기본 모양은 [0,0,0,0]에서 [x1,y1,x2,y2]로 변경
|
||||
ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
|
||||
|
||||
# 텍스트 프롬프트
|
||||
ann = prompt_process.text_prompt(text='a photo of a dog')
|
||||
|
||||
# 포인트 프롬프트
|
||||
# 기본 포인트 [[0,0]] [[x1,y1],[x2,y2]]
|
||||
# 기본 포인트 레이블 [0] [1,0] 0:배경, 1:전경
|
||||
ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
|
||||
prompt_process.plot(annotations=ann, output='./')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
```bash
|
||||
# FastSAM 모델 로드 및 모든 것을 세분화하여 추출
|
||||
yolo segment predict model=FastSAM-s.pt source=path/to/bus.jpg imgsz=640
|
||||
```
|
||||
|
||||
이 코드 조각은 사전 훈련된 모델을 로드하고 이미지에 대한 예측을 실행하는 간편함을 보여줍니다.
|
||||
|
||||
### 검증 사용법
|
||||
|
||||
데이터셋에서 모델을 검증하는 방법은 다음과 같습니다:
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import FastSAM
|
||||
|
||||
# FastSAM 모델 생성
|
||||
model = FastSAM('FastSAM-s.pt') # 또는 FastSAM-x.pt
|
||||
|
||||
# 모델 검증
|
||||
results = model.val(data='coco8-seg.yaml')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
```bash
|
||||
# FastSAM 모델 로드 및 이미지 크기 640에서 COCO8 예제 데이터셋에 대해 유효성 검사
|
||||
yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
|
||||
```
|
||||
|
||||
FastSAM은 단일 클래스 객체의 감지와 분할만 지원합니다. 이는 모든 객체를 동일한 클래스로 인식하고 분할한다는 의미입니다. 따라서 데이터셋을 준비할 때 모든 객체 카테고리 ID를 0으로 변환해야 합니다.
|
||||
|
||||
## FastSAM 공식 사용법
|
||||
|
||||
FastSAM은 [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM) 저장소에서 직접 사용할 수도 있습니다. FastSAM을 사용하기 위해 수행할 일반적인 단계를 간단히 소개합니다:
|
||||
|
||||
### 설치
|
||||
|
||||
1. FastSAM 저장소를 복제합니다:
|
||||
```shell
|
||||
git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
|
||||
```
|
||||
|
||||
2. Python 3.9로 Conda 환경을 생성하고 활성화합니다:
|
||||
```shell
|
||||
conda create -n FastSAM python=3.9
|
||||
conda activate FastSAM
|
||||
```
|
||||
|
||||
3. 복제한 저장소로 이동하여 필요한 패키지를 설치합니다:
|
||||
```shell
|
||||
cd FastSAM
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
4. CLIP 모델을 설치합니다:
|
||||
```shell
|
||||
pip install git+https://github.com/openai/CLIP.git
|
||||
```
|
||||
|
||||
### 예시 사용법
|
||||
|
||||
1. [모델 체크포인트](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing)를 다운로드합니다.
|
||||
|
||||
2. FastSAM을 추론하기 위해 다음과 같이 사용합니다. 예시 명령어:
|
||||
|
||||
- 이미지에서 모든 것을 세분화:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
|
||||
```
|
||||
|
||||
- 텍스트 프롬프트를 사용하여 특정 객체를 세분화:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "the yellow dog"
|
||||
```
|
||||
|
||||
- 바운딩 박스 내의 객체를 세분화 (xywh 형식으로 상자 좌표 제공):
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
|
||||
```
|
||||
|
||||
- 특정 지점 근처의 객체를 세분화:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
|
||||
```
|
||||
|
||||
또한, FastSAM을 [Colab 데모](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) 또는 [HuggingFace 웹 데모](https://huggingface.co/spaces/An-619/FastSAM)에서 시각적인 경험으로 시도해 볼 수 있습니다.
|
||||
|
||||
## 인용 및 감사의 말씀
|
||||
|
||||
FastSAM의 실시간 인스턴스 분할 분야에 대한 혁신적인 기여를 위해 FastSAM 저자들에게 감사의 말씀을 전합니다:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{zhao2023fast,
|
||||
title={Fast Segment Anything},
|
||||
author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
|
||||
year={2023},
|
||||
eprint={2306.12156},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
FastSAM 원본 논문은 [arXiv](https://arxiv.org/abs/2306.12156)에서 찾을 수 있습니다. 저자들은 자신들의 작업을 공개적으로 제공하였으며, 코드베이스는 [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM)에서 이용할 수 있습니다. 저자들의 노력에 감사드리며 저작물을 더 폭넓은 커뮤니티에 알리기 위한 기여를 기대합니다.
|
||||
|
|
@ -1,32 +1,32 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics에서 지원하는 YOLO 계열, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR 모델의 다양한 범위를 탐색하고 CLI 및 Python 사용 예시를 통해 시작해 보세요.
|
||||
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가 지원하는 모델들
|
||||
|
||||
Ultralytics 모델 문서에 오신 것을 환영합니다! 저희는 [객체 검출](../tasks/detect.md), [인스턴스 분할](../tasks/segment.md), [이미지 분류](../tasks/classify.md), [자세 추정](../tasks/pose.md), [다중 객체 추적](../modes/track.md) 등 특정 작업에 맞춤화된 다양한 모델을 지원합니다. Ultralytics에 모델 아키텍처를 기여하고자 한다면, 저희의 [기여 가이드](../../help/contributing.md)를 확인해 주세요.
|
||||
Ultralytics 모델 문서에 오신 것을 환영합니다! 우리는 [객체 감지](../tasks/detect.md), [인스턴스 분할](../tasks/segment.md), [이미지 분류](../tasks/classify.md), [자세 추정](../tasks/pose.md), [다중 객체 추적](../modes/track.md)과 같은 특정 작업에 맞춰진 다양한 범위의 모델을 지원합니다. Ultralytics에 모델 아키텍처를 기여하고 싶다면, [기여 가이드](../../help/contributing.md)를 확인해 보세요.
|
||||
|
||||
!!! Note "노트"
|
||||
!!! 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) 모델입니다.
|
||||
1. **[YOLOv3](yolov3.md)**: Joseph Redmon에 의해 최초로 만들어진 YOLO 모델 패밀리의 세 번째 버전으로, 효율적인 실시간 객체 감지 능력으로 알려져 있습니다.
|
||||
2. **[YOLOv4](yolov4.md)**: 2020년 Alexey Bochkovskiy가 발표한 YOLOv3의 다크넷 기반 업데이트 버전입니다.
|
||||
3. **[YOLOv5](yolov5.md)**: Ultralytics에 의해 향상된 YOLO 아키텍처로, 이전 버전들에 비해 더 나은 성능과 속도 트레이드오프를 제공합니다.
|
||||
4. **[YOLOv6](yolov6.md)**: [미투안](https://about.meituan.com/)에서 2022년에 발표하여, 회사의 자율 주행 배달 로봇에서 많이 사용되고 있습니다.
|
||||
5. **[YOLOv7](yolov7.md)**: YOLOv4의 저자들에 의해 2022년에 업데이트된 YOLO 모델들입니다.
|
||||
6. **[YOLOv8](yolov8.md) 새로운 🚀**: YOLO 패밀리의 최신 버전으로, 인스턴스 분할, 자세/키포인트 추정, 분류 등 향상된 기능을 제공합니다.
|
||||
7. **[Segment Anything Model (SAM)](sam.md)**: 메타의 Segment Anything Model (SAM)입니다.
|
||||
8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: 경희대학교에서 모바일 어플리케이션을 위해 개발한 MobileSAM입니다.
|
||||
9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: 중국 과학원 자동화 연구소의 이미지 및 비디오 분석 그룹에 의해 개발된 FastSAM입니다.
|
||||
10. **[YOLO-NAS](yolo-nas.md)**: YOLO Neural Architecture Search (NAS) 모델들입니다.
|
||||
11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)**: 바이두의 PaddlePaddle Realtime Detection Transformer (RT-DETR) 모델들입니다.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
|
|
@ -36,59 +36,63 @@ Ultralytics 모델 문서에 오신 것을 환영합니다! 저희는 [객체
|
|||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>보기:</strong> 몇 줄의 코드로 Ultralytics YOLO 모델을 실행하세요.
|
||||
<strong>시청하기:</strong> 몇 줄의 코드로 Ultralytics YOLO 모델을 실행하세요.
|
||||
</p>
|
||||
|
||||
## 시작하기: 사용 예시
|
||||
## 시작하기: 사용 예제
|
||||
|
||||
이 예제는 YOLO 학습과 추론에 대한 간단한 예제를 제공합니다. 이에 대한 전체 문서는 [예측](../modes/predict.md), [학습](../modes/train.md), [검증](../modes/val.md), [내보내기](../modes/export.md) 문서 페이지에서 확인할 수 있습니다.
|
||||
|
||||
아래 예제는 객체 감지를 위한 YOLOv8 [감지](../tasks/detect.md) 모델에 대한 것입니다. 추가적으로 지원되는 작업들은 [분할](../tasks/segment.md), [분류](../tasks/classify.md), [자세](../tasks/pose.md) 문서를 참조하세요.
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "Python"
|
||||
|
||||
PyTorch로 사전훈련된 `*.pt` 모델과 구성 `*.yaml` 파일은 Python에서 `YOLO()`, `SAM()`, `NAS()` 및 `RTDETR()` 클래스에 전달하여 모델 인스턴스를 생성할 수 있습니다:
|
||||
PyTorch로 사전 학습된 `*.pt` 모델들과 구성 `*.yaml` 파일들은 `YOLO()`, `SAM()`, `NAS()`, `RTDETR()` 클래스에 전달하여 파이썬에서 모델 인스턴스를 생성할 수 있습니다:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# COCO 사전훈련된 YOLOv8n 모델을 로드
|
||||
# COCO로 사전 학습된 YOLOv8n 모델 불러오기
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 모델 정보 표시 (선택 사항)
|
||||
# 모델 정보 표시 (선택사항)
|
||||
model.info()
|
||||
|
||||
# COCO8 예시 데이터셋에서 YOLOv8n 모델로 100 에포크 동안 훈련
|
||||
# COCO8 예제 데이터셋에 대해 100 에포크 동안 모델 학습
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# 'bus.jpg' 이미지에 YOLOv8n 모델로 추론 실행
|
||||
# 'bus.jpg' 이미지에 대한 YOLOv8n 모델 추론 실행
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
모델을 직접 실행하기 위한 CLI 커맨드도 제공됩니다:
|
||||
모델을 직접 실행하기 위한 CLI 명령어가 제공됩니다:
|
||||
|
||||
```bash
|
||||
# COCO 사전훈련된 YOLOv8n 모델을 로드하고 COCO8 예시 데이터셋에서 100 에포크 동안 훈련
|
||||
# COCO로 사전 학습된 YOLOv8n 모델을 불러와 COCO8 예제 데이터셋에서 100 에포크 동안 학습
|
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# COCO 사전훈련된 YOLOv8n 모델을 로드하고 'bus.jpg' 이미지에서 추론 실행
|
||||
# COCO로 사전 학습된 YOLOv8n 모델을 불러와 'bus.jpg' 이미지에 대한 추론 실행
|
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## 새 모델 기여하기
|
||||
## 새로운 모델 기여하기
|
||||
|
||||
Ultralytics에 모델을 기여하고 싶으신가요? 훌륭합니다! 저희는 항상 모델 포트폴리오를 확장하는 것에 개방적입니다.
|
||||
Ultralytics에 여러분의 모델을 기여하고 싶으신가요? 훌륭합니다! 우리는 항상 모델 포트폴리오를 확장하는 것에 열려 있습니다.
|
||||
|
||||
1. **저장소를 포크하세요**: [Ultralytics GitHub 저장소](https://github.com/ultralytics/ultralytics)를 포크하며 시작하세요.
|
||||
1. **저장소 포크하기**: [Ultralytics GitHub 저장소](https://github.com/ultralytics/ultralytics)를 포크하여 시작합니다.
|
||||
|
||||
2. **포크를 클론하세요**: 로컬 기기에 포크한 저장소를 클론하고 작업할 새 브랜치를 만드세요.
|
||||
2. **포크 복제하기**: 포크한 저장소를 로컬 기계에 복제하고 새로운 브랜치를 생성하여 작업합니다.
|
||||
|
||||
3. **모델 구현하기**: 저희의 [기여 가이드](../../help/contributing.md)에 제시된 코딩 표준과 가이드라인을 따라 모델을 추가하세요.
|
||||
3. **모델 구현하기**: 우리의 [기여 가이드](../../help/contributing.md)에 제공된 코딩 표준 및 가이드라인을 따라 모델을 추가합니다.
|
||||
|
||||
4. **철저히 테스트하기**: 파이프라인의 일부로서 뿐만 아니라 독립적으로도 모델을 철저히 테스트하세요.
|
||||
4. **철저히 테스트하기**: 독립적으로뿐만 아니라 파이프라인의 일부로도 모델을 철저히 테스트해야 합니다.
|
||||
|
||||
5. **풀 리퀘스트 생성하기**: 모델에 만족하게 되면, 리뷰를 위해 메인 저장소로 풀 리퀘스트를 생성하세요.
|
||||
5. **풀 리퀘스트 생성하기**: 모델에 만족하게 되면, 리뷰를 위해 메인 저장소에 풀 리퀘스트를 생성합니다.
|
||||
|
||||
6. **코드 리뷰 및 병합**: 리뷰 이후, 모델이 저희의 기준을 만족한다면 메인 저장소로 병합될 것입니다.
|
||||
6. **코드 리뷰 & 병합**: 리뷰 후, 여러분의 모델이 우리 기준에 부합한다면 메인 저장소에 병합됩니다.
|
||||
|
||||
자세한 단계는 저희의 [기여 가이드](../../help/contributing.md)를 참조하세요.
|
||||
자세한 단계는 [기여 가이드](../../help/contributing.md)를 참조해주십시오.
|
||||
|
|
|
|||
116
docs/ko/models/mobile-sam.md
Normal file
116
docs/ko/models/mobile-sam.md
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
---
|
||||
comments: true
|
||||
description: Ultralytics 프레임워크에서 MobileSAM을 다운로드하고 테스트하는 방법, MobileSAM의 구현 방식, 원본 SAM과의 비교, 모바일 애플리케이션 향상 등에 대해 자세히 알아보세요. 오늘부터 모바일 애플리케이션을 개선하세요.
|
||||
keywords: MobileSAM, Ultralytics, SAM, 모바일 애플리케이션, Arxiv, GPU, API, 이미지 인코더, 마스크 디코더, 모델 다운로드, 테스트 방법
|
||||
---
|
||||
|
||||
|
||||
|
||||
# Mobile Segment Anything (MobileSAM)
|
||||
|
||||
MobileSAM 논문은 이제 [arXiv](https://arxiv.org/pdf/2306.14289.pdf)에서 사용할 수 있습니다.
|
||||
|
||||
MobileSAM을 CPU에서 실행하는 데모는 이 [데모 링크](https://huggingface.co/spaces/dhkim2810/MobileSAM)에서 확인할 수 있습니다. Mac i5 CPU에서의 성능은 약 3초입니다. Hugging Face 데모에서는 인터페이스와 낮은 성능의 CPU가 느린 응답으로 이어지지만, 여전히 효과적으로 작동합니다.
|
||||
|
||||
MobileSAM은 [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling) 및 [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D)를 비롯한 여러 프로젝트에서 구현되었습니다.
|
||||
|
||||
MobileSAM은 1%의 원본 이미지로 구성된 100k 데이터셋에서 하루 이내에 단일 GPU로 학습됩니다. 이 학습을 위한 코드는 나중에 공개될 예정입니다.
|
||||
|
||||
## 사용 가능한 모델, 지원되는 작업 및 작동 모드
|
||||
|
||||
이 표에서는 사용 가능한 모델과 해당 모델에 대한 사전 훈련 가중치, 지원되는 작업, [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) 및 [Export](../modes/export.md)와 같은 다양한 작동 모드의 호환성을 나타냅니다. 지원되는 모드는 ✅ 이모지로 표시되고, 지원되지 않는 모드는 ❌ 이모지로 표시됩니다.
|
||||
|
||||
| 모델 유형 | 사전 훈련 가중치 | 지원되는 작업 | Inference | Validation | Training | Export |
|
||||
|-----------|-----------------|------------------------------------|-----------|------------|----------|--------|
|
||||
| MobileSAM | `mobile_sam.pt` | [인스턴스 세그멘테이션](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## SAM에서 MobileSAM으로의 적응
|
||||
|
||||
MobileSAM은 원본 SAM과 동일한 파이프라인을 유지하므로, 원본의 전처리, 후처리 및 모든 다른 인터페이스를 통합했습니다. 따라서 현재 원본 SAM을 사용 중인 경우, MobileSAM으로 전환하는 데 최소한의 노력이 필요합니다.
|
||||
|
||||
MobileSAM은 원본 SAM과 비교 가능한 성능을 발휘하며, 이미지 인코더만 변경되었습니다. 구체적으로, 원본의 무거운 ViT-H 인코더 (632M)를 더 작은 Tiny-ViT (5M)로 대체했습니다. 단일 GPU에서 MobileSAM은 이미지 당 약 12ms의 작업 시간이 소요됩니다. 이미지 인코더에는 8ms가 소요되고, 마스크 디코더에는 4ms가 소요됩니다.
|
||||
|
||||
다음 표는 ViT 기반 이미지 인코더를 비교합니다:
|
||||
|
||||
| 이미지 인코더 | 원본 SAM | MobileSAM |
|
||||
|---------|--------|-----------|
|
||||
| 매개변수 | 611M | 5M |
|
||||
| 속도 | 452ms | 8ms |
|
||||
|
||||
원본 SAM과 MobileSAM은 동일한 프롬프트 가이드 마스크 디코더를 사용합니다:
|
||||
|
||||
| 마스크 디코더 | 원본 SAM | MobileSAM |
|
||||
|---------|--------|-----------|
|
||||
| 매개변수 | 3.876M | 3.876M |
|
||||
| 속도 | 4ms | 4ms |
|
||||
|
||||
전체 파이프라인의 비교는 다음과 같습니다:
|
||||
|
||||
| 전체 파이프라인 (인코더+디코더) | 원본 SAM | MobileSAM |
|
||||
|--------------------|--------|-----------|
|
||||
| 매개변수 | 615M | 9.66M |
|
||||
| 속도 | 456ms | 12ms |
|
||||
|
||||
MobileSAM과 원본 SAM의 성능은 포인트 및 박스를 사용한 프롬프트를 통해 확인할 수 있습니다.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
MobileSAM은 우수한 성능을 자랑하며, 현재의 FastSAM보다 약 5배 작고 7배 빠릅니다. 자세한 내용은 [MobileSAM 프로젝트 페이지](https://github.com/ChaoningZhang/MobileSAM)에서 확인할 수 있습니다.
|
||||
|
||||
## Ultralytics에서 MobileSAM 테스트
|
||||
|
||||
원본 SAM과 마찬가지로, 포인트 및 박스 프롬프트 모드를 포함한 Ultralytics에서 간단한 테스트 방법을 제공합니다.
|
||||
|
||||
### 모델 다운로드
|
||||
|
||||
모델을 [여기](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt)에서 다운로드할 수 있습니다.
|
||||
|
||||
### 포인트 프롬프트
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# 모델 불러오기
|
||||
model = SAM('mobile_sam.pt')
|
||||
|
||||
# 포인트 프롬프트를 기반으로 세그먼트 예측
|
||||
model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
|
||||
```
|
||||
|
||||
### 박스 프롬프트
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# 모델 불러오기
|
||||
model = SAM('mobile_sam.pt')
|
||||
|
||||
# 박스 프롬프트를 기반으로 세그먼트 예측
|
||||
model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
|
||||
```
|
||||
|
||||
`MobileSAM`과 `SAM`은 동일한 API를 사용하여 구현되었습니다. 더 많은 사용법에 대해서는 [SAM 페이지](sam.md)를 참조하세요.
|
||||
|
||||
## 인용 및 감사의 글
|
||||
|
||||
MobileSAM이 연구 또는 개발에 유용하게 사용된 경우, 다음의 논문을 인용해 주시기 바랍니다:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{mobile_sam,
|
||||
title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications},
|
||||
author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon},
|
||||
journal={arXiv preprint arXiv:2306.14289},
|
||||
year={2023}
|
||||
}
|
||||
93
docs/ko/models/rtdetr.md
Normal file
93
docs/ko/models/rtdetr.md
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
---
|
||||
comments: true
|
||||
description: 비둘기(Baidu)가 개발한 RT-DETR은 비전 트랜스포머(Vision Transformers)를 기반으로 한 실시간 객체 검출기로, 사전 훈련된 모델을 사용하여 시간지연이 없는 고성능을 제공합니다.
|
||||
keywords: RT-DETR, 비둘기, 비전 트랜스포머, 객체 검출, 실시간 성능, CUDA, TensorRT, IoU-aware query selection, Ultralytics, 파이썬 API, PaddlePaddle
|
||||
---
|
||||
|
||||
# 비둘기의 RT-DETR: 비전 트랜스포머 기반 실시간 객체 검출기
|
||||
|
||||
## 개요
|
||||
|
||||
비둘기(Baidu)가 개발한 Real-Time Detection Transformer(RT-DETR)은 고정밀도를 유지하면서 실시간 성능을 제공하는 첨단 엔드 투 엔드 객체 검출기입니다. 비전 트랜스포머(Vision Transformers, ViT)의 성능을 활용하여, 다중 스케일 특징을 효율적으로 처리할 수 있도록 인트라 스케일 상호 작용과 크로스 스케일 퓨전을 분리합니다. RT-DETR은 다양한 디코더 레이어를 사용하여 추론 속도를 유연하게 조정할 수 있으므로 재훈련 없이 실시간 객체 검출에 적용하기에 매우 적합합니다. 이 모델은 CUDA와 TensorRT와 같은 가속화된 백엔드에서 많은 다른 실시간 객체 검출기보다 뛰어난 성능을 발휘합니다.
|
||||
|
||||
|
||||
**비둘기의 RT-DETR 개요** 비둘기의 RT-DETR 모델 구조 다이어그램은 백본 네트워크의 마지막 세 단계 {S3, S4, S5}를 인코더의 입력으로 보여줍니다. 효율적인 하이브리드 인코더는 인트라스케일 특징 상호 작용(AIFI, intrascale feature interaction)과 크로스 스케일 특징 퓨전 모듈(CCFM, cross-scale feature-fusion module)을 통해 다중 스케일 특징을 이미지 특징의 시퀀스로 변환합니다. IoU-aware query selection은 디코더에 대한 초기 객체 쿼리로 작동하기 위해 일정한 수의 이미지 특징을 선택하는 데 사용됩니다. 마지막으로, 보조 예측 헤드와 함께 디코더는 객체 쿼리를 반복하여 박스와 신뢰도 점수를 최적화합니다. ([원문](https://arxiv.org/pdf/2304.08069.pdf) 참조).
|
||||
|
||||
### 주요 기능
|
||||
|
||||
- **효율적인 하이브리드 인코더:** 비둘기의 RT-DETR은 다중 스케일 특징을 인트라 스케일 상호 작용과 크로스 스케일 퓨전을 분리하여 처리하는 효율적인 하이브리드 인코더를 사용합니다. 이 독특한 비전 트랜스포머 기반 디자인은 계산 비용을 줄이고 실시간 객체 검출이 가능하도록 합니다.
|
||||
- **IoU-aware 쿼리 선택:** 비둘기의 RT-DETR은 IoU-aware 쿼리 선택을 사용하여 개체 쿼리 초기화를 개선합니다. 이를 통해 모델은 장면에서 가장 관련성 있는 개체에 집중하며 검출 정확도를 향상시킵니다.
|
||||
- **융통성 있는 추론 속도 조정:** 비둘기의 RT-DETR은 훈련 없이 다른 디코더 레이어를 사용하여 추론 속도를 유연하게 조정할 수 있습니다. 이러한 적응성은 다양한 실시간 객체 검출 시나리오에서 실용적인 응용을 용이하게 합니다.
|
||||
|
||||
## 사전 훈련된 모델
|
||||
|
||||
Ultralytics의 파이썬 API는 다양한 스케일의 사전 훈련된 PaddlePaddle RT-DETR 모델을 제공합니다:
|
||||
|
||||
- RT-DETR-L: COCO val2017에서 53.0% AP, T4 GPU에서 114 FPS
|
||||
- RT-DETR-X: COCO val2017에서 54.8% AP, T4 GPU에서 74 FPS
|
||||
|
||||
## 사용 예시
|
||||
|
||||
이 예시는 간단한 RT-DETRR 훈련 및 추론 예시를 제공합니다. [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md), [Export](../modes/export.md) 등의 자세한 문서는 [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md), [Export](../modes/export.md) 문서 페이지를 참조하십시오.
|
||||
|
||||
!!! 예시
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import RTDETR
|
||||
|
||||
# COCO 사전 훈련된 RT-DETR-l 모델 로드
|
||||
model = RTDETR('rtdetr-l.pt')
|
||||
|
||||
# 모델 정보 표시 (선택 사항)
|
||||
model.info()
|
||||
|
||||
# COCO8 예제 데이터셋에 대해 100 epoch 동안 모델 훈련
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# 'bus.jpg' 이미지에서 RT-DETR-l 모델로 추론 실행
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# COCO 사전 훈련된 RT-DETR-l 모델 로드하고 COCO8 예제 데이터셋에 대해 100 epoch 동안 훈련
|
||||
yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# COCO 사전 훈련된 RT-DETR-l 모델 로드하고 'bus.jpg' 이미지에서 추론 실행
|
||||
yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## 지원되는 작업 및 모드
|
||||
|
||||
이 테이블은 각 모델의 유형, 특정 사전 훈련 가중치, 각 모델이 지원하는 작업 및 [모드](../modes/train.md), [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)와 같은 다양한 모드를 나타내는 ✅ 이모지로 표시된 모드를 지원합니다.
|
||||
|
||||
| 모델 유형 | 사전 훈련 가중치 | 지원되는 작업 | 추론 | 검증 | 훈련 | 출력 |
|
||||
|---------------------|---------------|-----------------------------|----|----|----|----|
|
||||
| RT-DETR Large | `rtdetr-l.pt` | [객체 검출](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| RT-DETR Extra-Large | `rtdetr-x.pt` | [객체 검출](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
## 인용 및 감사의 말
|
||||
|
||||
만약 연구나 개발 작업에서 비둘기(Baidu)의 RT-DETR을 사용한다면, [원래 논문을](https://arxiv.org/abs/2304.08069) 인용해주시기 바랍니다:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lv2023detrs,
|
||||
title={DETRs Beat YOLOs on Real-time Object Detection},
|
||||
author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu},
|
||||
year={2023},
|
||||
eprint={2304.08069},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
컴퓨터 비전 커뮤니티에게 귀중한 자료인 비전 트랜스포머 기반 실시간 객체 검출기인 비둘기(Baidu)의 RT-DETR을 만들고 유지하기 위해 비둘기와 [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) 팀에게 감사의 인사를 전합니다.
|
||||
|
||||
*Keywords: RT-DETR, Transformer, ViT, 비전 트랜스포머, 비둘기 RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, 실시간 객체 검출, 비전 트랜스포머 기반 객체 검출, 사전 훈련된 PaddlePaddle RT-DETR 모델, 비둘기 RT-DETR 사용법, Ultralytics 파이썬 API*
|
||||
226
docs/ko/models/sam.md
Normal file
226
docs/ko/models/sam.md
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
---
|
||||
comments: true
|
||||
description: 얼트라리얼리틱스(Ultralytics)의 최첨단 이미지 세분화 모델인 Segment Anything Model(SAM)에 대해 알아보세요. 해당 모델은 실시간 이미지 세분화를 가능하게 하며, 프롬프트를 이용한 세분화, 제로샷 성능 및 사용법에 대해 알아봅니다.
|
||||
keywords: 얼트라리얼리틱스, 이미지 세분화, Segment Anything Model, SAM, SA-1B 데이터셋, 실시간 성능, 제로샷 전이, 객체 감지, 이미지 분석, 머신 러닝
|
||||
---
|
||||
|
||||
# Segment Anything Model (SAM)
|
||||
|
||||
Segment Anything Model(SAM) 을 어서 오세요. 이 혁신적인 모델은 프롬프트 기반의 실시간 세분화를 통해 세분화 분야에서 새로운 기준을 세웠습니다.
|
||||
|
||||
## SAM 소개: Segment Anything Model의 소개
|
||||
|
||||
Segment Anything Model(SAM)은 프롬프트 기반의 세분화를 가능하게 하는 뛰어난 이미지 세분화 모델입니다. SAM은 이미지 세분석 작업에서 독창성을 보여주는 Segment Anything 이니셔티브의 핵심을 형성하고 있으며, 이미지 세분화를 위한 새로운 모델, 작업 및 데이터셋을 소개하는 혁신적인 프로젝트입니다.
|
||||
|
||||
SAM의 고급설계는 모델이 기존 지식 없이도 새로운 이미지 분포 및 작업에 대응할 수 있는 기능인 제로샷 전이를 보여줍니다. 1,100만 개의 정교하게 선별된 이미지에 분포된 10억 개 이상의 마스크를 포함한 SA-1B 데이터셋으로 학습된 SAM은 많은 경우에 전적으로 감독된 학습 결과를 능가하는 인상적인 제로샷 성능을 보여줍니다.
|
||||
|
||||
|
||||
새롭게 도입된 SA-1B 데이터셋에서 오버레이된 마스크를 포함한 예시 이미지입니다. SA-1B는 다양한 고해상도의 이미지를 라이선스 보호하며 사생활을 보호하고 있으며, 1,100만 개의 고품질 세분화 마스크를 가지고 있습니다. 이러한 마스크는 SAM에 의해 자동으로 주석이 달렸으며, 인간 평가 및 다양한 실험을 통해 높은 품질과 다양성을 갖추었음이 검증되었습니다. 시각화를 위해 이미지는 이미지 당 평균 100개의 마스크로 그룹화되었습니다.
|
||||
|
||||
## Segment Anything Model (SAM)의 주요 기능
|
||||
|
||||
- **프롬프트 기반 세분화 작업:** SAM은 프롬프트 기반의 세분화 작업을 위해 설계되어, 공간 또는 텍스트 단서를 이용하여 개체를 식별합니다.
|
||||
- **고급설계:** Segment Anything Model은 강력한 이미지 인코더, 프롬프트 인코더 및 가벼운 마스크 디코더를 사용합니다. 이 독특한 아키텍처는 유연한 프롬프팅, 실시간 마스크 계산 및 세분화 작업에서의 모호성 인식을 가능케 합니다.
|
||||
- **SA-1B 데이터셋:** Segment Anything 프로젝트에서 소개된 SA-1B 데이터셋은 1,100만 개의 이미지에 10억 개 이상의 세분화 마스크를 가지고 있습니다. 이는 지금까지 가장 큰 세분화 데이터셋으로, SAM에게 다양하고 대규모의 학습 데이터를 제공합니다.
|
||||
- **제로샷 성능:** SAM은 다양한 세분화 작업에서 뛰어난 제로샷 성능을 보여주므로, 프롬프트 엔지니어링의 필요성을 최소화하고 다양한 응용 프로그램에 즉시 사용할 수 있는 도구입니다.
|
||||
|
||||
Segment Anything Model 및 SA-1B 데이터셋에 대한 자세한 내용은 [Segment Anything 웹사이트](https://segment-anything.com)와 연구 논문 [Segment Anything](https://arxiv.org/abs/2304.02643)을 참조해 주세요.
|
||||
|
||||
## 사용 가능한 모델, 지원하는 작업 및 운영 모드
|
||||
|
||||
아래 표는 사용 가능한 모델과 해당 모델의 사전 훈련 가중치, 지원하는 작업 및 [추론](../modes/predict.md), [검증](../modes/val.md), [훈련](../modes/train.md) 및 [내보내기](../modes/export.md)와 같은 다른 운영 모드와의 호환성을 나타냅니다. 지원되는 모드는 ✅ 이모지로, 지원되지 않는 모드는 ❌ 이모지로 표시되었습니다.
|
||||
|
||||
| 모델 유형 | 사전 훈련 가중치 | 지원 작업 | 추론 | 검증 | 훈련 | 내보내기 |
|
||||
|-----------|------------|---------------------------------|----|----|----|------|
|
||||
| SAM base | `sam_b.pt` | [인스턴스 세분화](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
| SAM large | `sam_l.pt` | [인스턴스 세분화](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## SAM 사용 방법: 이미지 세분화에서의 다재다능함과 강력함
|
||||
|
||||
Segment Anything Model은 훈련 데이터를 초월하는 다양한 하위 작업에 대해서도 사용될 수 있습니다. 이에는 가장자리 검출, 객체 제안 생성, 인스턴스 세분장 및 초기 텍스트-마스크 예측 등이 포함됩니다. SAM은 프롬프팅 엔지니어링을 통해 새로운 작업 및 데이터 분포에 빠르게 적응할 수 있으므로, 이미지 세분화에 대한 다재다능하고 강력한 도구로 사용될 수 있습니다.
|
||||
|
||||
### SAM 예측 예제
|
||||
|
||||
!!! Example "프롬프트를 이용한 세분화"
|
||||
|
||||
주어진 프롬프트로 이미지 세분화를 실행합니다.
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# 모델 로드
|
||||
model = SAM('sam_b.pt')
|
||||
|
||||
# 모델 정보 표시 (선택 사항)
|
||||
model.info()
|
||||
|
||||
# bboxes 프롬프트로 추론 실행
|
||||
model('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
|
||||
|
||||
# points 프롬프트로 추론 실행
|
||||
model('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
|
||||
```
|
||||
|
||||
!!! Example "전체 이미지 세분화"
|
||||
|
||||
전체 이미지 세분화를 실행합니다.
|
||||
|
||||
=== "파이썬"
|
||||
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# 모델 로드
|
||||
model = SAM('sam_b.pt')
|
||||
|
||||
# 모델 정보 표시 (선택 사항)
|
||||
model.info()
|
||||
|
||||
# 추론 실행
|
||||
model('path/to/image.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# SAM 모델로 추론 실행
|
||||
yolo predict model=sam_b.pt source=path/to/image.jpg
|
||||
```
|
||||
|
||||
- 여기서 전체 이미지 세분화는 프롬프트(bboxes/points/masks)를 전달하지 않으면 실행됩니다.
|
||||
|
||||
!!! Example "SAMPredictor 예제"
|
||||
|
||||
이미지를 설정하고 이미지 인코더를 여러번 실행하지 않고 여러번 프롬프트 추론을 실행할 수 있습니다.
|
||||
|
||||
=== "프롬프트 추론"
|
||||
|
||||
```python
|
||||
from ultralytics.models.sam import Predictor as SAMPredictor
|
||||
|
||||
# SAMPredictor 생성
|
||||
overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
|
||||
predictor = SAMPredictor(overrides=overrides)
|
||||
|
||||
# 이미지 설정
|
||||
predictor.set_image("ultralytics/assets/zidane.jpg") # 이미지 파일로 설정
|
||||
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # np.ndarray로 설정
|
||||
results = predictor(bboxes=[439, 437, 524, 709])
|
||||
results = predictor(points=[900, 370], labels=[1])
|
||||
|
||||
# 이미지 리셋
|
||||
predictor.reset_image()
|
||||
```
|
||||
|
||||
추가 인수로 전체 이미지를 세분화합니다.
|
||||
|
||||
=== "전체 이미지 세분화"
|
||||
|
||||
```python
|
||||
from ultralytics.models.sam import Predictor as SAMPredictor
|
||||
|
||||
# SAMPredictor 생성
|
||||
overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
|
||||
predictor = SAMPredictor(overrides=overrides)
|
||||
|
||||
# 추가 인수로 이미지 세분화
|
||||
results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64)
|
||||
```
|
||||
|
||||
- `전체 이미지 세분화`에 대한 자세한 추가 인수는 [`Predictor/generate` 참조](../../reference/models/sam/predict.md)를 참조하세요.
|
||||
|
||||
## YOLOv8과의 SAM 비교
|
||||
|
||||
여기서는 Meta의 가장 작은 SAM 모델인 SAM-b를 얼트라리얼리틱스의 가장 작은 세분화 모델, [YOLOv8n-seg](../tasks/segment.md),과 비교합니다:
|
||||
|
||||
| 모델 | 크기 | 파라미터 | 속도 (CPU) |
|
||||
|------------------------------------------------|-----------------------|----------------------|------------------------|
|
||||
| Meta's SAM-b | 358 MB | 94.7 M | 51096 ms/im |
|
||||
| [MobileSAM](mobile-sam.md) | 40.7 MB | 10.1 M | 46122 ms/im |
|
||||
| [FastSAM-s](fast-sam.md) with YOLOv8 backbone | 23.7 MB | 11.8 M | 115 ms/im |
|
||||
| Ultralytics [YOLOv8n-seg](../tasks/segment.md) | **6.7 MB** (53.4배 작음) | **3.4 M** (27.9배 적음) | **59 ms/im** (866배 빠름) |
|
||||
|
||||
이 비교는 모델 크기 및 속도에 대한 상당한 차이를 보여줍니다. SAM은 자동으로 세분화하는 독특한 기능을 제공하지만, 작은 크기와 높은 처리 속도로 인해 YOLOv8 세분화 모델과 직접 경쟁하지는 않습니다.
|
||||
|
||||
이 테스트는 2023년 애플 M2 맥북(16GB RAM)에서 수행되었습니다. 이 테스트를 재현하려면:
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "파이썬"
|
||||
```python
|
||||
from ultralytics import FastSAM, SAM, YOLO
|
||||
|
||||
# SAM-b 프로파일링
|
||||
model = SAM('sam_b.pt')
|
||||
model.info()
|
||||
model('ultralytics/assets')
|
||||
|
||||
# MobileSAM 프로파일링
|
||||
model = SAM('mobile_sam.pt')
|
||||
model.info()
|
||||
model('ultralytics/assets')
|
||||
|
||||
# FastSAM-s 프로파일링
|
||||
model = FastSAM('FastSAM-s.pt')
|
||||
model.info()
|
||||
model('ultralytics/assets')
|
||||
|
||||
# YOLOv8n-seg 프로파일링
|
||||
model = YOLO('yolov8n-seg.pt')
|
||||
model.info()
|
||||
model('ultralytics/assets')
|
||||
```
|
||||
|
||||
## 자동 주석: 세분화 데이터셋을 위한 신속한 경로
|
||||
|
||||
자동 주석은 SAM의 핵심 기능으로, 미리 훈련된 탐지 모델을 사용하여 [세분화 데이터셋](https://docs.ultralytics.com/datasets/segment)을 생성할 수 있습니다. 이 기능을 사용하면 번거롭고 시간이 오래 걸리는 수작업 주석 작업을 건너뛰고 대량의 이미지를 신속하게 정확하게 주석을 달 수 있습니다.
|
||||
|
||||
### 탐지 모델을 사용하여 세분화 데이터셋 생성하기
|
||||
|
||||
Ultralytics 프레임워크를 사용하여 미리 훈련된 탐지 및 SAM 세분화 모델과 함께 데이터셋을 자동으로 주석할 수 있습니다. 아래와 같이 `auto_annotate` 함수를 사용하세요:
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "파이썬"
|
||||
```python
|
||||
from ultralytics.data.annotator import auto_annotate
|
||||
|
||||
auto_annotate(data="path/to/images", det_model="yolov8x.pt", sam_model='sam_b.pt')
|
||||
```
|
||||
|
||||
| 인수 | 유형 | 설명 | 기본값 |
|
||||
|------------|-----------------|-------------------------------------------------------------------|--------------|
|
||||
| data | 문자열 | 주석을 달 이미지가 포함된 폴더 경로. | |
|
||||
| det_model | 문자열, 선택사항 | 미리 훈련된 YOLO 탐지 모델. 기본값은 'yolov8x.pt'. | 'yolov8x.pt' |
|
||||
| sam_model | 문자열, 선택사항 | 미리 훈련된 SAM 세분화 모델. 기본값은 'sam_b.pt'. | 'sam_b.pt' |
|
||||
| device | 문자열, 선택사항 | 모델을 실행할 디바이스. 기본값은 빈 문자열 (CPU 또는 사용 가능한 GPU 사용). | |
|
||||
| output_dir | 문자열, None, 선택사항 | 주석이 포함된 결과를 저장할 디렉토리 경로. 기본값은 'data'와 같은 디렉토리 내부의 'labels' 폴더입니다. | None |
|
||||
|
||||
`auto_annotate` 함수는 이미지 경로를 입력으로 받아, 입력한 미리 훈련된 탐지와 SAM 세분화 모델, 이 함수를 실행할 디바이스 및 주석이 포함된 결과를 저장할 디렉토리 경로를 선택적으로 지정할 수 있는 기능을 제공합니다.
|
||||
|
||||
미리 훈련된 모델을 사용한 자동 주석 기능을 활용하면 높은 품질의 세분화 데이터셋을 생성하는 데 소요되는 시간과 노력을 크게 줄일 수 있습니다. 이 기능은 특히 대량의 이미지 컬렉션을 다루는 연구원과 개발자에게 유용하며, 수작업 주석 대신 모델 개발과 평가에 집중할 수 있습니다.
|
||||
|
||||
## 인용 및 감사의 말
|
||||
|
||||
귀하의 연구 또는 개발 작업에 SAM이 유용하게 사용된 경우, 저희 논문을 인용해 주시기 바랍니다:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{kirillov2023segment,
|
||||
title={Segment Anything},
|
||||
author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollár and Ross Girshick},
|
||||
year={2023},
|
||||
eprint={2304.02643},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
모델 개발과 알고리즘 개발을 위한 귀중한 리소스를 만들고 유지 관리하는 Meta AI에게 감사의 말씀을 드립니다.
|
||||
|
||||
*keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, 이미지 세분화, 프롬프트 기반 세분화, 제로샷 성능, SA-1B 데이터셋, 고급설계, 자동 주석, 얼트라리얼리틱스, 사전 훈련 모델, SAM base, SAM large, 인스턴스 세분화, 컴퓨터 비전, 인공 지능, 머신 러닝, 데이터 주석, 세분화 마스크, 탐지 모델, YOLO 탐지 모델, bibtex, Meta AI.*
|
||||
119
docs/ko/models/yolo-nas.md
Normal file
119
docs/ko/models/yolo-nas.md
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLO-NAS는 우수한 물체 감지 모델로서 자세한 설명서를 탐색해보세요. Ultralytics Python API를 사용한 기능, 사전 훈련된 모델, 사용법 등을 자세히 알아보세요.
|
||||
keywords: YOLO-NAS, Deci AI, 물체 감지, 딥러닝, 신경 아키텍처 검색, Ultralytics Python API, YOLO 모델, 사전 훈련된 모델, 양자화, 최적화, COCO, Objects365, Roboflow 100
|
||||
---
|
||||
|
||||
# YOLO-NAS
|
||||
|
||||
## 개요
|
||||
|
||||
Deci AI에서 개발한 YOLO-NAS는 원래의 YOLO 모델의 한계를 해결하기 위해 고도의 신경 아키텍처 검색(Neural Architecture Search) 기술로 만들어진 혁신적인 물체 감지 기반 모델입니다. 양자화 지원과 정확성-지연 트레이드오프의 중요한 개선을 통해 YOLO-NAS는 물체 감지 분야에서 주목할 만한 성능 향상을 제공합니다.
|
||||
|
||||
|
||||
**YOLO-NAS 개요.** YOLO-NAS는 양자화 관련 블록과 선택적 양자화를 적용하여 최적의 성능을 달성합니다. 모델은 INT8 양자화 버전으로 변환될 때 최소한의 정확도 감소를 경험하므로 다른 모델들과 비교했을 때 상당한 개선을 이끌어냅니다. 이러한 혁신은 예측할 수 없는 물체 감지 능력과 높은 성능을 가진 우수한 아키텍처로 이어집니다.
|
||||
|
||||
### 주요 기능
|
||||
|
||||
- **양자화 친화적인 기본 블록**: YOLO-NAS는 이전 YOLO 모델의 한계 중 하나인 양자화에 적합한 새로운 기본 블록을 도입합니다.
|
||||
- **정교한 훈련과 양자화**: YOLO-NAS는 고급 훈련 방식과 훈련 후 양자화를 활용하여 성능을 향상시킵니다.
|
||||
- **AutoNAC 최적화와 사전 훈련**: YOLO-NAS는 AutoNAC 최적화를 활용하며 COCO, Objects365, Roboflow 100과 같은 유명한 데이터셋에서 사전 훈련됩니다. 이를 통해 YOLO-NAS는 본격적인 프로덕션 환경에서의 물체 감지 작업에 매우 적합합니다.
|
||||
|
||||
## 사전 훈련된 모델
|
||||
|
||||
Ultralytics가 제공하는 사전 훈련된 YOLO-NAS 모델로 다음 세대의 물체 감지 기술의 힘을 체험해 보세요. 이러한 모델은 속도와 정확성 측면에서 최고의 성능을 제공하기 위해 설계되었습니다. 특정 요구에 맞게 다양한 옵션 중 선택하세요:
|
||||
|
||||
| 모델 | mAP | 지연 시간 (밀리초) |
|
||||
|------------------|-------|-------------|
|
||||
| YOLO-NAS S | 47.5 | 3.21 |
|
||||
| YOLO-NAS M | 51.55 | 5.85 |
|
||||
| YOLO-NAS L | 52.22 | 7.87 |
|
||||
| YOLO-NAS S INT-8 | 47.03 | 2.36 |
|
||||
| YOLO-NAS M INT-8 | 51.0 | 3.78 |
|
||||
| YOLO-NAS L INT-8 | 52.1 | 4.78 |
|
||||
|
||||
각 모델 변형은 평균 평균 정밀도(mAP)와 지연 시간 간의 균형을 제공하여 물체 감지 작업을 성능과 속도 모두 최적화할 수 있도록 합니다.
|
||||
|
||||
## 사용 예시
|
||||
|
||||
Ultralytics는 YOLO-NAS 모델을 `ultralytics` Python 패키지를 통해 Python 애플리케이션에 쉽게 통합할 수 있도록 지원합니다. 이 패키지는 프로세스를 간소화하기 위한 사용자 친화적인 Python API를 제공합니다.
|
||||
|
||||
다음 예시에서는 추론과 유효성 검사를 위해 `ultralytics` 패키지와 함께 YOLO-NAS 모델을 사용하는 방법을 보여줍니다:
|
||||
|
||||
### 추론과 유효성 검사 예시
|
||||
|
||||
이 예시에서는 COCO8 데이터셋에서 YOLO-NAS-s 모델을 유효성 검사합니다.
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
이 예시에서는 YOLO-NAS를 위한 간단한 추론 및 유효성 검사 코드를 제공합니다. 추론 결과를 처리하기 위한 방법은 [예측](../modes/predict.md) 모드를 참조하세요. 추가 모드에서 YOLO-NAS를 사용하는 방법은 [Val](../modes/val.md) 및 [Export](../modes/export.md)를 참조하세요. `ultralytics` 패키지에서 YOLO-NAS의 훈련은 지원하지 않습니다.
|
||||
|
||||
=== "Python"
|
||||
|
||||
PyTorch 사전 훈련된 `*.pt` 모델 파일을 `NAS()` 클래스에 전달하여 Python에서 모델 인스턴스를 생성할 수 있습니다:
|
||||
|
||||
```python
|
||||
from ultralytics import NAS
|
||||
|
||||
# COCO 사전 훈련된 YOLO-NAS-s 모델 로드
|
||||
model = NAS('yolo_nas_s.pt')
|
||||
|
||||
# 모델 정보 표시 (선택 사항)
|
||||
model.info()
|
||||
|
||||
# COCO8 예제 데이터셋에서 모델 유효성 검사
|
||||
results = model.val(data='coco8.yaml')
|
||||
|
||||
# YOLO-NAS-s 모델로 'bus.jpg' 이미지에 추론 실행
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
CLI 명령을 사용하여 모델을 직접 실행할 수 있습니다:
|
||||
|
||||
```bash
|
||||
# COCO 사전 훈련된 YOLO-NAS-s 모델로 COCO8 예제 데이터셋의 성능 유효성 검사
|
||||
yolo val model=yolo_nas_s.pt data=coco8.yaml
|
||||
|
||||
# COCO 사전 훈련된 YOLO-NAS-s 모델로 'bus.jpg' 이미지에 추론 실행
|
||||
yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## 지원되는 작업 및 모드
|
||||
|
||||
YOLO-NAS 모델은 Small (s), Medium (m) 및 Large (l) 세 가지 변형이 있습니다. 각 변형은 다른 계산 및 성능 요구 사항을 충족시키기 위해 설계되었습니다:
|
||||
|
||||
- **YOLO-NAS-s**: 계산 자원이 제한되고 효율성이 중요한 환경에 최적화되었습니다.
|
||||
- **YOLO-NAS-m**: 더 높은 정확성을 가지는 일반적인 물체 감지 작업에 적합한 균형잡힌 모델입니다.
|
||||
- **YOLO-NAS-l**: 계산 자원이 제한되지 않는 환경에서 가장 높은 정확성이 필요한 시나리오에 맞게 설계되었습니다.
|
||||
|
||||
아래는 각 모델에 대한 자세한 개요로, 사전 훈련된 가중치, 지원하는 작업, 다양한 작동 모드와의 호환성에 대한 링크가 제공됩니다.
|
||||
|
||||
| 모델 유형 | 사전 훈련된 가중치 | 지원되는 작업 | 추론 | 유효성 검사 | 훈련 | 내보내기 |
|
||||
|------------|-----------------------------------------------------------------------------------------------|-----------------------------|----|--------|----|------|
|
||||
| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_s.pt) | [물체 감지](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_m.pt) | [물체 감지](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_l.pt) | [물체 감지](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
|
||||
## 인용 및 감사의 말씀
|
||||
|
||||
YOLO-NAS를 연구 또는 개발 작업에 활용한 경우 SuperGradients를 인용해 주세요.
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{supergradients,
|
||||
doi = {10.5281/ZENODO.7789328},
|
||||
url = {https://zenodo.org/record/7789328},
|
||||
author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}},
|
||||
title = {Super-Gradients},
|
||||
publisher = {GitHub},
|
||||
journal = {GitHub repository},
|
||||
year = {2021},
|
||||
}
|
||||
```
|
||||
|
||||
Deci AI의 [SuperGradients](https://github.com/Deci-AI/super-gradients/) 팀에게 컴퓨터 비전 커뮤니티를 위해 이 가치 있는 자료를 만들고 유지 관리한 데 대해 감사의 말씀을 전합니다. 혁신적인 아키텍처와 우수한 물체 감지 능력을 갖춘 YOLO-NAS가 개발자와 연구자에게 중요한 도구가 될 것으로 기대합니다.
|
||||
98
docs/ko/models/yolov3.md
Normal file
98
docs/ko/models/yolov3.md
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv3, YOLOv3-Ultralytics 및 YOLOv3u에 대한 개요를 얻으세요. 물체 탐지를 위한 주요 기능, 사용법 및 지원 작업에 대해 알아보세요.
|
||||
keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, 물체 탐지, 추론, 훈련, Ultralytics
|
||||
---
|
||||
|
||||
# YOLOv3, YOLOv3-Ultralytics 및 YOLOv3u
|
||||
|
||||
## 개요
|
||||
|
||||
이 문서는 세 가지 밀접하게 관련된 물체 탐지 모델인 [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) 및 [YOLOv3u](https://github.com/ultralytics/ultralytics)에 대한 개요를 제공합니다.
|
||||
|
||||
1. **YOLOv3:** 이것은 You Only Look Once (YOLO) 물체 탐지 알고리즘의 세 번째 버전입니다. Joseph Redmon이 처음 개발한 YOLOv3는 다중 스케일 예측 및 세 가지 다른 크기의 탐지 커널과 같은 기능을 도입하여 이전 모델보다 향상됐습니다.
|
||||
|
||||
2. **YOLOv3-Ultralytics:** 이것은 Ultralytics의 YOLOv3 모델 구현입니다. 이 모델은 원본 YOLOv3 아키텍처를 복제하며 더 많은 사전 훈련 모델 및 쉬운 사용자 정의 옵션과 같은 추가 기능을 제공합니다.
|
||||
|
||||
3. **YOLOv3u:** 이것은 YOLOv8 모델에서 사용되는 앵커 없이 물체 없음 분리 헤드를 통합한 YOLOv3-Ultralytics의 업데이트된 버전입니다. YOLOv3u는 YOLOv3와 동일한 백본 및 네크 아키텍처를 유지하지만 YOLOv8에서 업데이트된 탐지 헤드를 사용합니다.
|
||||
|
||||
|
||||
|
||||
## 주요 기능
|
||||
|
||||
- **YOLOv3:** 이 모델은 탐지를 위해 13x13, 26x26 및 52x52의 세 가지 다른 크기의 탐지 커널을 활용하는 세 가지 다른 스케일을 도입했습니다. 이는 다양한 크기의 객체에 대한 탐지 정확도를 크게 향상시켰습니다. 또한 YOLOv3은 각 경계 상자에 대한 다중 레이블 예측과 더 나은 특징 추출기 네트워크와 같은 기능을 추가했습니다.
|
||||
|
||||
- **YOLOv3-Ultralytics:** Ultralytics의 YOLOv3 구현은 원본 모델과 동일한 성능을 제공하지만 더 많은 사전 훈련 모델, 추가적인 훈련 방법 및 쉬운 사용자 정의 옵션을 제공합니다. 이로써 실제 응용 분야에 대해 더 다양하고 사용자 친화적인 모델이 됩니다.
|
||||
|
||||
- **YOLOv3u:** 이 업데이트된 모델은 YOLOv8의 앵커 없음, 물체 없는 분리 헤드를 통합합니다. 미리 정의된 앵커 박스 및 물체 점수가 필요 없어진 이 탐지 헤드 설계는 다양한 크기와 모양의 객체를 탐지하는 능력을 향상시킬 수 있습니다. 이로써 YOLOv3u는 물체 탐지 작업에 대해 더 견고하고 정확한 모델이 됩니다.
|
||||
|
||||
## 지원되는 작업 및 모드
|
||||
|
||||
YOLOv3, YOLOv3-Ultralytics 및 YOLOv3u 시리즈는 물체 탐지 작업을 위해 특별히 설계되었습니다. 이러한 모델은 정확성과 속도를 균형있게 유지하여 다양한 실제 시나리오에서 효과적으로 사용될 수 있습니다. 각 버전은 독특한 기능과 최적화를 제공하여 다양한 응용 분야에 적합합니다.
|
||||
|
||||
세 가지 모델은 [추론](../modes/predict.md), [유효성 검사](../modes/val.md), [훈련](../modes/train.md) 및 [내보내기](../modes/export.md)와 같은 포괄적인 모드를 지원하여 효과적인 물체 탐지를 위한 완벽한 도구 세트를 제공합니다.
|
||||
|
||||
| 모델 유형 | 지원되는 작업 | 추론 | 유효성 검사 | 훈련 | 내보내기 |
|
||||
|--------------------|-----------------------------|----|--------|----|------|
|
||||
| YOLOv3 | [물체 탐지](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv3-Ultralytics | [물체 탐지](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv3u | [물체 탐지](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
이 표는 각 YOLOv3 버전의 기능을 한 눈에 보여주며, 물체 탐지 워크플로우의 다양한 작업 및 운영 모드에 대해 다양성과 적합성을 강조합니다.
|
||||
|
||||
## 사용 예제
|
||||
|
||||
다음 예제는 간단한 YOLOv3 훈련 및 추론 예제를 제공합니다. 이와 다른 [모드](../modes/index.md)의 전체 설명은 [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) 및 [Export](../modes/export.md) 문서 페이지를 참조하세요.
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Python에서 PyTorch 사전 훈련된 `*.pt` 모델 및 설정 `*.yaml` 파일을 YOLO() 클래스에 전달하여 모델 인스턴스를 만들 수 있습니다.
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# COCO 사전 훈련된 YOLOv3n 모델 로드
|
||||
model = YOLO('yolov3n.pt')
|
||||
|
||||
# 모델 정보 표시 (선택 사항)
|
||||
model.info()
|
||||
|
||||
# COCO8 예제 데이터셋에서 100 epoch 동안 모델 훈련
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# YOLOv3n 모델로 'bus.jpg' 이미지에 추론 실행
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
CLI 명령어를 사용하여 모델을 직접 실행할 수 있습니다.
|
||||
|
||||
```bash
|
||||
# COCO 사전 훈련된 YOLOv3n 모델 로드하고 COCO8 예제 데이터셋에서 100 epoch 동안 훈련
|
||||
yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# COCO 사전 훈련된 YOLOv3n 모델 로드하고 'bus.jpg' 이미지에 추론 실행
|
||||
yolo predict model=yolov3n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## 인용 및 감사의 글
|
||||
|
||||
본인의 연구에서 YOLOv3를 사용한다면, 원본 YOLO 논문과 Ultralytics YOLOv3 저장소를 인용해 주십시오.
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{redmon2018yolov3,
|
||||
title={YOLOv3: An Incremental Improvement},
|
||||
author={Redmon, Joseph and Farhadi, Ali},
|
||||
journal={arXiv preprint arXiv:1804.02767},
|
||||
year={2018}
|
||||
}
|
||||
```
|
||||
|
||||
Joseph Redmon과 Ali Farhadi에게 원본 YOLOv3 개발에 대한 감사의 글을 전합니다.
|
||||
71
docs/ko/models/yolov4.md
Normal file
71
docs/ko/models/yolov4.md
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv4에 대한 상세 가이드를 살펴보세요. 최신 실시간 객체 감지기의 아키텍처 하이라이트, 혁신적인 기능 및 응용 예제를 이해하세요.
|
||||
keywords: ultralytics, YOLOv4, 객체 감지, 신경망, 실시간 감지, 객체 감지기, 기계 학습
|
||||
---
|
||||
|
||||
# YOLOv4: 높은 속도와 정밀도를 갖는 객체 감지
|
||||
|
||||
Ultralytics YOLOv4 문서 페이지에 오신 것을 환영합니다. YOLOv4는 아키텍처 및 알고리즘 개선으로 실시간 객체 감지의 최적 속도와 정확도를 제공하는 최신 객체 감지기입니다. 2020년에 Alexey Bochkovskiy가 [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet)에서 출시되었습니다. YOLOv4는 많은 응용 분야에서 우수한 선택입니다.
|
||||
|
||||
|
||||
**YOLOv4 아키텍처 다이어그램**. YOLOv4의 복잡한 네트워크 설계를 보여줍니다. 최적의 실시간 객체 감지를 위해 백본, 넥 및 헤드 구성 요소와 이들의 상호 연결된 레이어가 포함되어 있습니다.
|
||||
|
||||
## 소개
|
||||
|
||||
YOLOv4는 You Only Look Once의 4번째 버전을 의미합니다. 이전 YOLO 버전인 [YOLOv3](yolov3.md) 및 기타 객체 감지 모델의 한계를 극복하기 위해 개발된 실시간 객체 감지 모델입니다. 다른 합성곱 신경망(Convolutional Neural Network, CNN) 기반 객체 감지기와는 달리 YOLOv4는 추천 시스템뿐만 아니라 독립적인 프로세스 관리 및 인적 감소에도 적용할 수 있습니다. 이는 일반적인 그래픽 처리 장치(Graphics Processing Unit, GPU)에서 작동함으로써 저렴한 가격에 대량 사용을 가능하게 합니다. 또한, 훈련을 위해 하나의 GPU만 필요합니다.
|
||||
|
||||
## 아키텍처
|
||||
|
||||
YOLOv4는 성능을 최적화하기 위해 여러 혁신적인 기능을 사용합니다. 이에는 Weighted-Residual-Connections (WRC), Cross-Stage-Partial-connections (CSP), Cross mini-Batch Normalization (CmBN), Self-adversarial-training (SAT), Mish-activation, Mosaic data augmentation, DropBlock regularization 및 CIoU loss가 포함됩니다. 이러한 기능들은 최첨단 결과를 달성하기 위해 결합되었습니다.
|
||||
|
||||
일반적인 객체 감지기는 입력, 백본, 넥 및 헤드와 같은 여러 부분으로 구성됩니다. YOLOv4의 백본은 ImageNet에서 사전 훈련되며, 객체의 클래스 및 경계 상자를 예측하는 데 사용됩니다. 백본은 VGG, ResNet, ResNeXt 또는 DenseNet과 같은 여러 모델에서 가져올 수 있습니다. 객체 감지기의 넥 부분은 다양한 단계에서 피처 맵을 수집하는 데 사용되며, 일반적으로 여러 하향 경로 및 여러 상향 경로를 포함합니다. 헤드 부분은 최종 객체 감지 및 분류에 사용됩니다.
|
||||
|
||||
## 베고 오브 프리비스
|
||||
|
||||
YOLOv4는 학습 중 모델의 정확성을 향상시키는 기법인 "베고 오브 프리비스"를 사용하기도 합니다. 데이터 증강은 객체 감지에서 주로 사용되는 베고 오브 프리비스 기법으로, 입력 이미지의 다양성을 높여 모델의 견고성을 향상시킵니다. 데이터 증강의 몇 가지 예는 화질 왜곡(이미지의 밝기, 대조도, 색상, 채도 및 노이즈 조정) 및 기하학적 왜곡(임의의 스케일링, 크롭, 뒤집기, 회전 추가)입니다. 이러한 기술은 모델이 다양한 유형의 이미지에 대해 더 잘 일반화되도록 돕습니다.
|
||||
|
||||
## 기능 및 성능
|
||||
|
||||
YOLOv4는 객체 감지의 최적 속도와 정확도를 위해 설계되었습니다. YOLOv4의 아키텍처에는 백본으로 CSPDarknet53, 넥으로 PANet, 감지 헤드로 YOLOv3가 포함되어 있습니다. 이 설계를 통해 YOLOv4는 뛰어난 속도로 객체 감지를 수행하며, 실시간 응용 프로그램에 적합합니다. YOLOv4는 객체 감지 벤치마크에서 최첨단 결과를 달성하고 정확도 면에서도 뛰어난 성능을 보입니다.
|
||||
|
||||
## 사용 예제
|
||||
|
||||
작성 시점 기준으로 Ultralytics는 현재 YOLOv4 모델을 지원하지 않습니다. 따라서 YOLOv4를 사용하려는 사용자는 YOLOv4 GitHub 저장소의 설치 및 사용 지침을 직접 참조해야 합니다.
|
||||
|
||||
다음은 YOLOv4를 사용하는 일반적인 단계에 대한 간략한 개요입니다:
|
||||
|
||||
1. YOLOv4 GitHub 저장소를 방문하세요: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
|
||||
|
||||
2. 설치에 대한 README 파일에 제공된 지침을 따르세요. 일반적으로 저장소를 클론하고 필요한 종속성을 설치하고 필요한 환경 변수를 설정하는 과정을 포함합니다.
|
||||
|
||||
3. 설치가 완료되면, 저장소에서 제공하는 사용 지침에 따라 모델을 훈련하고 사용할 수 있습니다. 이는 일반적으로 데이터셋을 준비하고 모델 매개변수를 설정하고 모델을 훈련한 다음 훈련된 모델을 사용하여 객체 감지를 수행하는 것을 포함합니다.
|
||||
|
||||
특정 단계는 사용 사례와 YOLOv4 저장소의 현재 상태에 따라 다를 수 있습니다. 따라서 YOLOv4 GitHub 저장소에서 제공되는 지침을 직접 참조하는 것이 강력히 권장됩니다.
|
||||
|
||||
YOLOv4의 지원이 구현되면 Ultralytics를 위한 사용 예제로 이 문서를 업데이트하기 위해 노력하겠습니다.
|
||||
|
||||
## 결론
|
||||
|
||||
YOLOv4는 속도와 정확도의 균형을 이루는 강력하고 효율적인 객체 감지 모델입니다. 학습 중 특정 기법 및 베고 오브 프리비스 기법의 사용으로 실시간 객체 감지 작업에서 탁월한 성능을 발휘합니다. 일반적인 GPU를 가진 사용자 누구나 사용하고 훈련할 수 있어 다양한 응용 분야에 접근 가능하고 실용적입니다.
|
||||
|
||||
## 인용 및 감사의 글
|
||||
|
||||
실시간 객체 감지 분야에서 중요한 기여를 한 YOLOv4 저자들에게 감사드립니다:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{bochkovskiy2020yolov4,
|
||||
title={YOLOv4: Optimal Speed and Accuracy of Object Detection},
|
||||
author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao},
|
||||
year={2020},
|
||||
eprint={2004.10934},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
원본 YOLOv4 논문은 [arXiv](https://arxiv.org/pdf/2004.10934.pdf)에서 확인할 수 있습니다. 저자들은 자신들의 작업을 일반에 공개하고 코드베이스는 [GitHub](https://github.com/AlexeyAB/darknet)에서 액세스할 수 있도록 했습니다. 저자들의 노력과 널리 알려진 커뮤니티에 작업을 제공해 준 사항을 감사히 여깁니다.
|
||||
113
docs/ko/models/yolov5.md
Normal file
113
docs/ko/models/yolov5.md
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv5u는 YOLOv5 모델의 개선된 정확도-속도 절충 모델로, 다양한 객체 감지 작업에 대한 사전 훈련된 모델을 제공합니다.
|
||||
keywords: YOLOv5u, 객체 감지, 사전 훈련된 모델, Ultralytics, 추론, 검증, YOLOv5, YOLOv8, 앵커 없음, 객체 여부 없음, 실시간 응용, 머신 러닝
|
||||
---
|
||||
|
||||
# YOLOv5
|
||||
|
||||
## 개요
|
||||
|
||||
YOLOv5u는 객체 감지 기법에서의 진보를 나타냅니다. Ultralytics에서 개발한 [YOLOv5](https://github.com/ultralytics/yolov5) 모델의 기본 아키텍처를 기반으로 한 YOLOv5u는 [YOLOv8](yolov8.md) 모델에서 도입된 앵커 없음, 객체 여부 없음 분리 헤드(head) 기능을 통합합니다. 이러한 적응으로 인해 모델의 아키텍처가 개선되어, 객체 감지 작업의 정확도와 속도 절충을 더욱 향상시킵니다. 경험적 결과와 해당 기능을 고려할 때, YOLOv5u는 연구 및 실제 응용 모두에서 견고한 솔루션을 찾고 있는 사용자들에게 효율적인 대안을 제공합니다.
|
||||
|
||||
|
||||
|
||||
## 주요 기능
|
||||
|
||||
- **앵커 없는 분리 Ultralytics 헤드:** 기존의 객체 감지 모델은 사전 정의된 앵커 박스를 사용하여 객체의 위치를 예측합니다. 그러나 YOLOv5u는 이 방식을 현대화합니다. 앵커 없는 분리 Ultralytics 헤드를 도입함으로써 더욱 유연하고 적응적인 감지 메커니즘을 보장하여 다양한 시나리오에서 성능을 향상시킵니다.
|
||||
|
||||
- **정확도-속도 절충의 최적화:** 속도와 정확도는 종종 상충하는 관계에 있습니다. 그러나 YOLOv5u는 이러한 절충을 도전합니다. 실시간 탐지를 보장하면서도 정확도를 희생하지 않는 균형을 제시합니다. 이 기능은 자율주행 차량, 로봇 공학, 실시간 비디오 분석 등 신속한 응답을 요구하는 응용 프로그램에서 특히 중요합니다.
|
||||
|
||||
- **다양한 사전 훈련된 모델:** 다른 작업에는 다른 도구 세트가 필요하다는 것을 이해하는 YOLOv5u는 다양한 사전 훈련된 모델을 제공합니다. 추론, 검증 또는 훈련에 집중하고 있는지 여부에 관계없이 맞춤형 모델이 기다리고 있습니다. 이 다양성은 일반적인 솔루션이 아닌 독특한 도전 과제에 대해 특별히 세밀하게 조정된 모델을 사용하고 있다는 것을 보장합니다.
|
||||
|
||||
## 지원되는 작업 및 모드
|
||||
|
||||
разнобойacionales of YOLOv5u 모델은 다양한 사전 훈련된 가중치로 [객체 감지](../tasks/detect.md) 작업에서 뛰어난 성능을 발휘합니다. 이들은 개발부터 배포까지 다양한 응용 프로그램에 적합한 다양한 모드를 지원합니다.
|
||||
|
||||
| 모델 유형 | 사전 훈련된 가중치 | 작업 | 추론 | 검증 | 훈련 | 내보내기 |
|
||||
|---------|-----------------------------------------------------------------------------------------------------------------------------|-----------------------------|----|----|----|------|
|
||||
| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [객체 감지](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
이 표는 YOLOv5u 모델의 다양한 변형을 상세히 보여주며, 객체 감지 작업에서의 적용 가능성과 [추론](../modes/predict.md), [검증](../modes/val.md), [훈련](../modes/train.md), [내보내기](../modes/export.md)와 같은 다양한 작업 모드의 지원을 강조합니다. 이러한 포괄적인 지원을 통해 사용자는 다양한 객체 감지 시나리오에서 YOLOv5u 모델의 기능을 완전히 활용할 수 있습니다.
|
||||
|
||||
## 성능 지표
|
||||
|
||||
!!! 성능
|
||||
|
||||
=== "감지"
|
||||
|
||||
[COCO](https://docs.ultralytics.com/datasets/detect/coco/)에서 학습된 이러한 모델을 사용한 사용 예제는 [감지 문서](https://docs.ultralytics.com/tasks/detect/)를 참조하세요. 이 문서에는 80개의 사전 훈련된 클래스를 포함합니다.
|
||||
|
||||
| 모델 | YAML | 크기<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) |
|
||||
|---------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
|
||||
| [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34.3 | 73.6 | 1.06 | 2.6 | 7.7 |
|
||||
| [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43.0 | 120.7 | 1.27 | 9.1 | 24.0 |
|
||||
| [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49.0 | 233.9 | 1.86 | 25.1 | 64.2 |
|
||||
| [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52.2 | 408.4 | 2.50 | 53.2 | 135.0 |
|
||||
| [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53.2 | 763.2 | 3.81 | 97.2 | 246.4 |
|
||||
| | | | | | | | |
|
||||
| [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 42.1 | 211.0 | 1.83 | 4.3 | 7.8 |
|
||||
| [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 48.6 | 422.6 | 2.34 | 15.3 | 24.6 |
|
||||
| [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 53.6 | 810.9 | 4.36 | 41.2 | 65.7 |
|
||||
| [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 55.7 | 1470.9 | 5.47 | 86.1 | 137.4 |
|
||||
| [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 56.8 | 2436.5 | 8.98 | 155.4 | 250.7 |
|
||||
|
||||
## 사용 예제
|
||||
|
||||
이 예제는 간단한 YOLOv5 훈련 및 추론 예제를 제공합니다. 이와 기타 [모드](../modes/index.md)의 자세한 설명은 [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) 및 [Export](../modes/export.md) 문서 페이지를 참조하세요.
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Python에서 `YOLO()` 클래스로 `*.pt` 사전 훈련된 모델과 구성 `*.yaml` 파일을 전달하여 모델 인스턴스를 만들 수 있습니다.
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# COCO 사전 훈련된 YOLOv5n 모델 로드
|
||||
model = YOLO('yolov5n.pt')
|
||||
|
||||
# 모델 정보 표시 (선택 사항)
|
||||
model.info()
|
||||
|
||||
# COCO8 예제 데이터셋을 사용하여 모델을 100번 에포크로 훈련
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# 'bus.jpg' 이미지에 대해 YOLOv5n 모델로 추론 실행
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
CLI 명령을 사용하여 모델을 직접 실행할 수 있습니다.
|
||||
|
||||
```bash
|
||||
# COCO 사전 훈련된 YOLOv5n 모델 로드 및 COCO8 예제 데이터셋을 사용하여 모델을 100번 에포크로 훈련
|
||||
yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# COCO 사전 훈련된 YOLOv5n 모델 로드 및 'bus.jpg' 이미지에서 추론 실행
|
||||
yolo predict model=yolov5n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## 인용 및 감사의 글
|
||||
|
||||
연구에서 YOLOv5 또는 YOLOv5u를 사용하는 경우 Ultralytics YOLOv5 리포지토리를 다음과 같이 인용하세요.
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
```bibtex
|
||||
@software{yolov5,
|
||||
title = {Ultralytics YOLOv5},
|
||||
author = {Glenn Jocher},
|
||||
year = {2020},
|
||||
version = {7.0},
|
||||
license = {AGPL-3.0},
|
||||
url = {https://github.com/ultralytics/yolov5},
|
||||
doi = {10.5281/zenodo.3908559},
|
||||
orcid = {0000-0001-5950-6979}
|
||||
}
|
||||
```
|
||||
|
||||
YOLOv5 모델은 [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) 및 [Enterprise](https://ultralytics.com/license) 라이선스로 제공됩니다.
|
||||
107
docs/ko/models/yolov6.md
Normal file
107
docs/ko/models/yolov6.md
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
---
|
||||
comments: true
|
||||
description: 최첨단 물체 감지(오브젝트 디텍션) 모델인 'Meituan YOLOv6'을 알아보세요. 속도와 정확도 사이의 균형을 유지하는 이 모델은 실시간 애플리케이션에 인기 있는 선택입니다. 이 모델은 BiC(Bi-directional Concatenation) 모듈, AAT(Anchor-Aided Training) 전략, COCO 데이터셋에서 최첨단 정확도를 실현하기 위한 개선된 백본(backbone) 및 네크(neck) 설계 등에 대한 여러 주목할만한 향상 사항을 도입하고 있습니다.
|
||||
keywords: Meituan YOLOv6, 오브젝트 디텍션, Ultralytics, YOLOv6 문서, Bi-directional Concatenation, Anchor-Aided Training, 사전 훈련 모델, 실시간 애플리케이션
|
||||
---
|
||||
|
||||
# Meituan YOLOv6
|
||||
|
||||
## 개요
|
||||
|
||||
[Meituan](https://about.meituan.com/) YOLOv6은 속도와 정확도 사이에서 현저한 균형을 제공하는 최첨단 물체 감지기입니다. 이 모델은 Bi-directional Concatenation(BiC) 모듈, Anchor-Aided Training(AAT) 전략, 그리고 COCO 데이터셋에서 최첨단 정확도를 실현하기 위한 개선된 백본(backbone) 및 네크(neck) 디자인 등, 아키텍처와 훈련 방식에 대한 여러 주목할만한 향상 사항을 제공합니다.
|
||||
|
||||
|
||||
|
||||
**YOLOv6 개요**. 아키텍처 다이어그램으로, 다시 설계된 네트워크 구성 요소와 훈련 전략이 중요한 성능 개선을 이끈 모습을 보여줍니다. (a) YOLOv6의 네크(neck) (N과 S 표시)입니다. M/L의 경우, RepBlocks은 CSPStackRep으로 대체됩니다. (b) BiC 모듈의 구조입니다. (c) SimCSPSPPF 블록입니다. ([출처](https://arxiv.org/pdf/2301.05586.pdf)).
|
||||
|
||||
### 주요 특징
|
||||
|
||||
- **Bi-directional Concatenation (BiC) 모듈**: YOLOv6은 감지기(neck)에 BiC 모듈을 도입하여 위치 신호(localization signals)를 강화하고 성능을 향상시키는데, 속도 저하가 거의 없습니다.
|
||||
- **Anchor-Aided Training (AAT) 전략**: 이 모델은 추론 효율을 저하시키지 않고 앵커 기반(anchor-based)과 앵커 없음(anchor-free) 패러다임의 이점을 모두 누릴 수 있도록 AAT를 제안합니다.
|
||||
- **개선된 백본 및 네크 디자인**: YOLOv6을 백본과 네크에 추가적인 단계를 포함하여 깊게 만들어 COCO 데이터셋에서 최첨단 성능을 달성합니다.
|
||||
- **셀프 디스틸레이션 전략**: YOLOv6의 작은 모델 성능을 강화하기 위해 새로운 셀프 디스틸레이션 전략이 도입되었습니다. 이는 훈련 중 보조 회귀 브랜치를 강화하고 추론 중에는 이를 제거하여 성능 저하를 방지합니다.
|
||||
|
||||
## 성능 메트릭
|
||||
|
||||
YOLOv6은 다양한 스케일의 사전 훈련 모델을 제공합니다:
|
||||
|
||||
- YOLOv6-N: NVIDIA Tesla T4 GPU에서 1187 FPS로 COCO val2017에서 37.5% AP.
|
||||
- YOLOv6-S: 484 FPS로 45.0% AP.
|
||||
- YOLOv6-M: 226 FPS로 50.0% AP.
|
||||
- YOLOv6-L: 116 FPS로 52.8% AP.
|
||||
- YOLOv6-L6: 실시간에서 최첨단 정확성.
|
||||
|
||||
또한, YOLOv6은 다양한 정밀도에 대한 양자화 모델과 모바일 플랫폼에 최적화된 모델도 제공합니다.
|
||||
|
||||
## 사용 예시
|
||||
|
||||
다음은 간단한 YOLOv6 훈련 및 추론 예시입니다. 이 외에도 [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md), [Export](../modes/export.md) 문서 페이지에서 자세한 내용을 확인할 수 있습니다.
|
||||
|
||||
!!! Example "예제"
|
||||
|
||||
=== "Python"
|
||||
|
||||
`*.pt` 사전 훈련된 PyTorch 모델과 구성 `*.yaml` 파일을 `YOLO()` 클래스에 전달하여 파이썬에서 모델 인스턴스를 만들 수 있습니다:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# YOLOv6n 모델을 처음부터 만듭니다
|
||||
model = YOLO('yolov6n.yaml')
|
||||
|
||||
# 모델 정보를 표시합니다 (선택 사항)
|
||||
model.info()
|
||||
|
||||
# COCO8 예시 데이터셋으로 모델을 100 에폭 동안 훈련합니다
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# YOLOv6n 모델로 'bus.jpg' 이미지에서 추론을 실행합니다
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
CLI 명령을 사용하여 모델을 직접 실행할 수 있습니다:
|
||||
|
||||
```bash
|
||||
# 처음부터 YOLOv6n 모델을 만들고 COCO8 예시 데이터셋으로 100 에폭 동안 훈련합니다
|
||||
yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# 처음부터 YOLOv6n 모델을 만들고 'bus.jpg' 이미지에서 추론을 실행합니다
|
||||
yolo predict model=yolov6n.yaml source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## 지원되는 작업 및 모드
|
||||
|
||||
YOLOv6 시리즈는 높은 성능의 [오브젝트 디텍션](../tasks/detect.md)을 위해 최적화된 다양한 모델을 제공합니다. 이 모델들은 다양한 계산 요구 사항과 정확도 요구 사항에 맞추어 다용도로 사용할 수 있습니다.
|
||||
|
||||
| 모델 유형 | 사전 훈련 가중치 | 지원되는 작업 | 추론 | 검증 | 훈련 | 익스포트 |
|
||||
|-----------|----------------|--------------------------------|----|----|----|------|
|
||||
| YOLOv6-N | `yolov6-n.pt` | [오브젝트 디텍션](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-S | `yolov6-s.pt` | [오브젝트 디텍션](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-M | `yolov6-m.pt` | [오브젝트 디텍션](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-L | `yolov6-l.pt` | [오브젝트 디텍션](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-L6 | `yolov6-l6.pt` | [오브젝트 디텍션](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
이 표는 YOLOv6 모델의 다양한 변형에 대한 자세한 개요를 제공하며, 오브젝트 디텍션 작업과 [추론](../modes/predict.md), [검증](../modes/val.md), [훈련](../modes/train.md), [익스포트](../modes/export.md)와 같은 다양한 운영 모드와의 호환성을 강조합니다. 이러한 포괄적인 지원을 통해 사용자들은 다양한 오브젝트 디텍션 시나리오에서 YOLOv6 모델의 기능을 최대한 활용할 수 있습니다.
|
||||
|
||||
## 인용 및 감사의 글
|
||||
|
||||
실시간 물체 감지 분야에서의 중요한 기여에 대해 작성자들에게 감사의 말씀을 전합니다:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{li2023yolov6,
|
||||
title={YOLOv6 v3.0: A Full-Scale Reloading},
|
||||
author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
|
||||
year={2023},
|
||||
eprint={2301.05586},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
YOLOv6 원본 논문은 [arXiv](https://arxiv.org/abs/2301.05586)에서 찾을 수 있습니다. 작성자들이 자신의 작업을 공개하지 않았으며, 코드는 [GitHub](https://github.com/meituan/YOLOv6)에서 액세스할 수 있습니다. 우리는 그들의 노력과 업계 발전을 위해 노력해 널리 알려져 있게 한 저자들에게 감사의 말씀을 전합니다.
|
||||
65
docs/ko/models/yolov7.md
Normal file
65
docs/ko/models/yolov7.md
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv7은 실시간 객체 검출기로, 뛰어난 속도, 강력한 정확성, 독특한 trainable bag-of-freebies 최적화에 대해 알아봅니다.
|
||||
keywords: YOLOv7, 실시간 객체 검출기, 최첨단, Ultralytics, MS COCO 데이터셋, 모델 재파라미터화, 동적 라벨 할당, 확장 스케일, 복합 스케일
|
||||
---
|
||||
|
||||
# YOLOv7: Trainable Bag-of-Freebies
|
||||
|
||||
YOLOv7은 5 FPS에서 160 FPS까지의 범위에서 알려진 모든 객체 검출기를 속도와 정확성에서 능가하는 최첨단 실시간 객체 검출기입니다. 이 모델은 GPU V100에서 30 FPS 이상을 달성하여, 알려진 실시간 객체 검출기 중 가장 높은 정확도(56.8% AP)를 보여줍니다. 게다가, YOLOv7은 다른 객체 검출기인 YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 등에 비해 속도와 정확성 면에서 더 뛰어납니다. 이 모델은 다른 데이터셋이나 사전 학습된 가중치를 사용하지 않고 MS COCO 데이터셋에서 처음부터 훈련되었습니다. YOLOv7의 소스 코드는 GitHub에서 확인할 수 있습니다.
|
||||
|
||||
|
||||
**최첨단 객체 검출기 비교**. 표 2의 결과에서 볼 수 있듯이, 제안된 방법은 최상의 속도-정확성 균형을 가지고 있습니다. YOLOv7-tiny-SiLU를 YOLOv5-N(r6.1)과 비교해보면, 저희 방법은 약 127 fps가 더 빠르고 AP에서 10.7% 정확도가 향상됩니다. 게다가, YOLOv7은 161 fps 프레임 속도에서 51.4% AP를 달성하는 반면, PPYOLOE-L은 동일한 AP에서 78 fps 프레임 속도만 갖습니다. 매개 변수 사용 측면에서 YOLOv7는 PPYOLOE-L의 41%를 줄입니다. YOLOv7-X를 114 fps의 추론 속도로 YOLOv5-L(r6.1)의 99 fps 추론 속도와 비교하면, YOLOv7-X는 AP를 3.9% 향상시킵니다. YOLOv7-X를 유사한 스케일의 YOLOv5-X(r6.1)와 비교하면, YOLOv7-X의 추론 속도가 31 fps 더 빨라집니다. 또한, 매개 변수 및 계산의 양 측면에서 YOLOv7-X는 YOLOv5-X(r6.1)과 비교하여 매개 변수 22%와 계산 8%를 줄이고 AP를 2.2% 향상시킵니다 ([출처](https://arxiv.org/pdf/2207.02696.pdf)).
|
||||
|
||||
## 개요
|
||||
|
||||
실시간 객체 검출은 다중 객체 추적, 자율 주행, 로봇 공학 및 의료 이미지 분석을 비롯한 많은 컴퓨터 비전 시스템의 중요한 구성 요소입니다. 최근 몇 년간 실시간 객체 검출 개발은 효율적인 구조 설계와 다양한 CPU, GPU 및 신경 처리 장치(NPU)의 추론 속도 향상에 초점을 맞추고 있습니다. YOLOv7은 모바일 GPU와 GPU 장치를 모두 지원하여 엣지부터 클라우드까지 다양한 환경에서 사용할 수 있습니다.
|
||||
|
||||
기존의 실시간 객체 검출기가 아키텍처 최적화에 중점을 둔 것과는 달리, YOLOv7은 훈련 과정 최적화에 초점을 두고 있습니다. 이는 추론 비용을 증가시키지 않고 객체 검출의 정확도를 향상시키는 모듈과 최적화 방법을 포함한 "trainable bag-of-freebies" 개념을 도입합니다.
|
||||
|
||||
## 주요 기능
|
||||
|
||||
YOLOv7은 다음과 같은 주요 기능을 도입합니다:
|
||||
|
||||
1. **모델 재파라미터화**: YOLOv7은 그래디언트 전파 경로 개념을 이용한 다른 네트워크의 레이어에 적용 가능한 전략인 계획된 재파라미터화 모델을 제안합니다.
|
||||
|
||||
2. **동적 라벨 할당**: 다중 출력 레이어 모델의 훈련에서는 "다른 브랜치의 출력에 대해 동적 타깃을 어떻게 할당할 것인가?"라는 새로운 문제가 발생합니다. 이를 해결하기 위해 YOLOv7은 coarse-to-fine 리드 가이드 라벨 할당이라는 새로운 라벨 할당 방법을 도입합니다.
|
||||
|
||||
3. **확장 및 복합 스케일링**: YOLOv7은 매개 변수와 계산을 효과적으로 활용할 수 있는 실시간 객체 검출기를 위한 "확장" 및 "복합 스케일링" 방법을 제안합니다.
|
||||
|
||||
4. **효율성**: YOLOv7이 제안한 방법은 최첨단 실시간 객체 검출기의 매개 변수 약 40%, 계산 약 50%를 효과적으로 줄일 수 있으며, 더 빠른 추론 속도와 더 높은 검출 정확도를 달성할 수 있습니다.
|
||||
|
||||
## 사용 예시
|
||||
|
||||
기술 시점에서 Ultralytics은 현재 YOLOv7 모델을 지원하지 않습니다. 따라서 YOLOv7을 사용하려는 사용자는 YOLOv7 GitHub 저장소의 설치 및 사용 지침을 직접 참조해야 합니다.
|
||||
|
||||
YOLOv7을 사용하는 일반적인 단계에 대해 간략히 설명해 드리겠습니다:
|
||||
|
||||
1. YOLOv7 GitHub 저장소를 방문합니다: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7).
|
||||
|
||||
2. 설치에 대한 README 파일에서 제공하는 지침을 따릅니다. 일반적으로 저장소를 복제하고 필요한 종속성을 설치하고 필요한 환경 변수를 설정하는 것이 포함됩니다.
|
||||
|
||||
3. 설치가 완료되면 저장소에서 제공하는 사용 지침에 따라 모델을 훈련하고 사용할 수 있습니다. 이는 데이터셋을 준비하고 모델 매개 변수를 구성하고 모델을 훈련한 다음 훈련된 모델을 사용하여 객체 검출을 수행하는 것을 일반적으로 포함합니다.
|
||||
|
||||
특정 단계는 사용 사례와 YOLOv7 저장소의 현재 상태에 따라 달라질 수 있습니다. 따라서 YOLOv7 GitHub 저장소에서 제공하는 지침을 직접 참조하는 것이 권장됩니다.
|
||||
|
||||
YOLOv7을 지원하게 되면, Ultralytics의 사용 예시를 포함하여 이 문서를 업데이트하기 위해 최선을 다하겠습니다.
|
||||
|
||||
## 인용 및 감사의 글
|
||||
|
||||
실시간 객체 검출 분야에서의 중요한 기여로 인해 YOLOv7의 저자들에게 감사의 말씀을 전하고자 합니다:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{wang2022yolov7,
|
||||
title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
|
||||
author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
|
||||
journal={arXiv preprint arXiv:2207.02696},
|
||||
year={2022}
|
||||
}
|
||||
```
|
||||
|
||||
원본 YOLOv7 논문은 [arXiv](https://arxiv.org/pdf/2207.02696.pdf)에서 찾을 수 있습니다. 저자들은 작업을 공개적으로 사용 가능하게 하였고, 코드베이스는 [GitHub](https://github.com/WongKinYiu/yolov7)에서 확인할 수 있습니다. 저희는 이들이 해당 분야의 발전에 기여하고 작업을 폭넓은 커뮤니티에게 공개 가능하게 한 노력에 감사드립니다.
|
||||
162
docs/ko/models/yolov8.md
Normal file
162
docs/ko/models/yolov8.md
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
---
|
||||
comments: true
|
||||
description: YOLOv8는 실시간 객체 탐지기인 YOLO 시리즈의 최신 버전으로, 최신 아키텍처, 사전 훈련된 모델 및 정확도와 속도의 최적 균형을 제공함으로써 다양한 객체 탐지 작업에 적합한 선택지입니다.
|
||||
keywords: YOLOv8, Ultralytics, 실시간 객체 탐지기, 사전 훈련된 모델, 문서, 객체 탐지, YOLO 시리즈, 고급 아키텍처, 정확도, 속도
|
||||
---
|
||||
|
||||
# YOLOv8
|
||||
|
||||
## 개요
|
||||
|
||||
YOLOv8는 실시간 객체 탐지기인 YOLO 시리즈의 최신 버전으로, 정확도와 속도면에서 최신 기술을 제공합니다. 이전 YOLO 버전의 기술적 발전을 바탕으로, YOLOv8은 새로운 기능과 최적화를 도입하여 다양한 응용 분야에서 다양한 객체 탐지 작업에 이상적인 선택지가 됩니다.
|
||||
|
||||
|
||||
|
||||
## 주요 기능
|
||||
|
||||
- **고급 백본 및 넥 아키텍처:** YOLOv8은 최첨단 백본 및 넥 아키텍처를 사용하여 향상된 특징 추출과 객체 탐지 성능을 제공합니다.
|
||||
- **앵커 없는 분리된 Ultralytics 헤드:** YOLOv8은 앵커 기반 접근법에 비해 더 나은 정확도와 효율적인 탐지 과정을 위한 앵커 없는 분리된 Ultralytics 헤드를 채택합니다.
|
||||
- **정확도와 속도의 최적 균형화:** 정확도와 속도의 최적 균형을 유지하는 것에 초점을 맞춘 YOLOv8은 다양한 응용 분야에서 실시간 객체 탐지 작업에 적합합니다.
|
||||
- **다양한 사전 훈련된 모델:** YOLOv8은 다양한 작업과 성능 요건에 맞는 사전 훈련된 모델을 제공하여 특정 사용 사례에 적합한 모델을 쉽게 찾을 수 있도록 합니다.
|
||||
|
||||
## 지원하는 작업 및 모드
|
||||
|
||||
YOLOv8 시리즈는 컴퓨터 비전의 특정 작업을 위해 특화된 다양한 모델을 제공합니다. 이러한 모델은 객체 탐지부터 인스턴스 세그멘테이션, 포즈/키포인트 탐지, 분류와 같은 복잡한 작업까지 다양한 요구 사항을 충족시킬 수 있도록 설계되었습니다.
|
||||
|
||||
각 YOLOv8 시리즈의 변형은 해당 작업에 최적화되어 고성능과 정확도를 제공합니다. 또한 이러한 모델은 [추론](../modes/predict.md), [검증](../modes/val.md), [훈련](../modes/train.md) 및 [내보내기](../modes/export.md)와 같은 다양한 운영 모드와 호환되어 배포 및 개발의 다양한 단계에서 사용할 수 있도록 지원합니다.
|
||||
|
||||
| 모델 | 파일 이름 | 작업 | 추론 | 검증 | 훈련 | 내보내기 |
|
||||
|-------------|----------------------------------------------------------------------------------------------------------------|------------------------------------|----|----|----|------|
|
||||
| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [객체 탐지](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [인스턴스 세그멘테이션](../tasks/segment.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [포즈/키포인트](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [분류](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
이 표는 YOLOv8 모델의 변형을 개요로 제공하며, 특정 작업에서의 적용 가능성 및 추론, 검증, 훈련 및 내보내기와 같은 다양한 운영 모드와의 호환성을 강조합니다. 이는 컴퓨터 비전의 다양한 응용 분야에 적합한 YOLOv8 시리즈의 다재다능함과 견고성을 보여줍니다.
|
||||
|
||||
## 성능 지표
|
||||
|
||||
!!! 성능
|
||||
|
||||
=== "객체 탐지 (COCO)"
|
||||
|
||||
[COCO](https://docs.ultralytics.com/datasets/detect/coco/)에서 사전 훈련된 이러한 모델을 사용한 사용 예제에 대한 정보는 [객체 탐지 문서](https://docs.ultralytics.com/tasks/detect/)를 참조하십시오. 이는 80개의 사전 훈련된 클래스를 포함합니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | mAP<br>val 50-95 | 속도<br><sup>CPU ONNX<br>(밀리초) | 속도<br><sup>A100 TensorRT<br>(밀리초) | 매개변수<br><sup>(백만) | FLOPs<br><sup>(십억) |
|
||||
| ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------- | ----------------- |
|
||||
| [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 |
|
||||
|
||||
=== "객체 탐지 (Open Images V7)"
|
||||
|
||||
[Open Images V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/)에서 사전 훈련된 이러한 모델을 사용한 사용 예제에 대한 정보는 [객체 탐지 문서](https://docs.ultralytics.com/tasks/detect/)를 참조하십시오. 이는 600개의 사전 훈련된 클래스를 포함합니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | mAP<br>val 50-95 | 속도<br><sup>CPU ONNX<br>(밀리초) | 속도<br><sup>A100 TensorRT<br>(밀리초) | 매개변수<br><sup>(백만) | FLOPs<br><sup>(십억) |
|
||||
| ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------- | ----------------- |
|
||||
| [YOLOv8n-oiv7](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
|
||||
| [YOLOv8s-oiv7](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
|
||||
| [YOLOv8m-oiv7](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
|
||||
| [YOLOv8l-oiv7](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
|
||||
| [YOLOv8x-oiv7](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
|
||||
|
||||
=== "세그멘테이션 (COCO)"
|
||||
|
||||
[COCO](https://docs.ultralytics.com/datasets/segment/coco/)에서 사전 훈련된 이러한 모델을 사용한 사용 예제에 대한 정보는 [세그멘테이션 문서](https://docs.ultralytics.com/tasks/segment/)를 참조하십시오. 이는 80개의 사전 훈련된 클래스를 포함합니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | mAP<br>box 50-95 | mAP<br>mask 50-95 | 속도<br><sup>CPU ONNX<br>(밀리초) | 속도<br><sup>A100 TensorRT<br>(밀리초) | 매개변수<br><sup>(백만) | FLOPs<br><sup>(십억) |
|
||||
| -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------ | ------------------------------ | ----------------------------------- | ------------------- | ----------------- |
|
||||
| [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 |
|
||||
|
||||
=== "분류 (ImageNet)"
|
||||
|
||||
[ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/)에서 사전 훈련된 이러한 모델을 사용한 사용 예제에 대한 정보는 [분류 문서](https://docs.ultralytics.com/tasks/classify/)를 참조하십시오. 이는 1000개의 사전 훈련된 클래스를 포함합니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | top1 정확도 | top5 정확도 | 속도<br><sup>CPU ONNX<br>(밀리초) | 속도<br><sup>A100 TensorRT<br>(밀리초) | 매개변수<br><sup>(백만) | FLOPs<br><sup>(백만) 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 |
|
||||
|
||||
=== "포즈 (COCO)"
|
||||
|
||||
[COCO](https://docs.ultralytics.com/datasets/pose/coco/)에서 사전 훈련된 이러한 모델을 사용한 사용 예제에 대한 정보는 [포즈 문서](https://docs.ultralytics.com/tasks/pose/)를 참조하십시오. 이는 'person' 하나의 사전 훈련된 클래스를 포함합니다.
|
||||
|
||||
| 모델 | 크기<br><sup>(픽셀) | mAP<br>pose 50-95 | mAP<br>pose 50 | 속도<br><sup>CPU ONNX<br>(밀리초) | 속도<br><sup>A100 TensorRT<br>(밀리초) | 매개변수<br><sup>(백만) | FLOPs<br><sup>(십억) |
|
||||
| ---------------------------------------------------------------------------------------------------- | --------------------- | -------------------- | ----------------- | ------------------------------ | ----------------------------------- | ------------------- | ----------------- |
|
||||
| [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 |
|
||||
|
||||
## 사용 예제
|
||||
|
||||
이 예제는 간단한 YOLOv8 훈련 및 추론 예제를 제공합니다. 이와 다른 [모드](../modes/index.md)의 전체 문서는 [예측](../modes/predict.md), [훈련](../modes/train.md), [검증](../modes/val.md) 및 [내보내기](../modes/export.md) 문서를 참조하십시오.
|
||||
|
||||
아래 예제는 객체 탐지를 위한 YOLOv8 [Detect](../tasks/detect.md) 모델을 대상으로 합니다. 추가 지원되는 작업에 대해서는 [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) 및 [Pose](../tasks/pose.md) 문서를 참조하십시오.
|
||||
|
||||
!!! 예시
|
||||
|
||||
=== "Python"
|
||||
|
||||
python에서 PyTorch 사전 훈련된 `*.pt` 모델 및 구성 `*.yaml` 파일을 `YOLO()` 클래스에 전달하여 모델 인스턴스를 만들 수 있습니다.
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# COCO 사전 훈련된 YOLOv8n 모델 로드
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# 모델 정보 표시 (옵션)
|
||||
model.info()
|
||||
|
||||
# COCO8 예제 데이터셋에서 모델을 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
|
||||
```
|
||||
|
||||
## 인용 및 감사의 글
|
||||
|
||||
이 저장소에서 YOLOv8 모델이나 다른 소프트웨어를 사용한 작업에 대해서는 다음 형식으로 인용해주시기 바랍니다.
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@software{yolov8_ultralytics,
|
||||
author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu},
|
||||
title = {Ultralytics YOLOv8},
|
||||
version = {8.0.0},
|
||||
year = {2023},
|
||||
url = {https://github.com/ultralytics/ultralytics},
|
||||
orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069},
|
||||
license = {AGPL-3.0}
|
||||
}
|
||||
```
|
||||
|
||||
DOI는 준비 중이며 이용 가능해지면 인용문에 추가될 예정입니다. YOLOv8 모델은 [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) 및 [Enterprise](https://ultralytics.com/license) 라이센스에 따라 제공됩니다.
|
||||
Loading…
Add table
Add a link
Reference in a new issue