728x90
반응형
목차
1. 들어가며
1.1 YOLO26을 검토하게 된 계기
최근 중고 의류 자동 검수 AI 시스템을 설계하면서 객체 탐지 모델을 검토하던 중이었습니다. 반품된 중고 의류의 결함(오염, 손상, 변색 등)을 자동으로 탐지하고, S/A/B/F 등급을 판정하는 시스템인데요. 처리 속도 목표가 의류 1벌당 1초 이내였고, 향후 물류센터 현장의 엣지 디바이스 배포도 고려해야 했습니다.
마침 2025년 1월 14일, Ultralytics에서 YOLO 시리즈의 최신 버전인 YOLO26을 공식 출시했다는 소식을 접했습니다. 릴리스 노트를 보자마자 눈에 들어온 키워드들이 있었습니다:
- End-to-End NMS-Free: 후처리 파이프라인 단순화
- CPU에서 최대 43% 빠른 추론: 엣지 환경에 적합
- DFL 제거: 내보내기 간소화, 하드웨어 호환성 향상
기존에 YOLO11을 검토하고 있었는데, YOLO26의 이런 특징들이 제가 설계 중인 시스템의 요구사항과 정확히 맞아떨어졌습니다.
1.2 왜 YOLO26인가?
제 프로젝트 기준으로 YOLO26을 선택한 이유를 정리하면:
| 요구사항 | YOLO26 해결책 |
|---|---|
| 1초 이내 3장 처리 | CPU 추론 43% 개선 → 3장 ~117ms (39ms × 3) |
| 배포 파이프라인 간소화 | NMS-Free End-to-End → 후처리 코드 제거 |
| 엣지 디바이스 대응 | DFL 제거 → TensorRT, ONNX 내보내기 용이 |
| 작은 결함 탐지 | ProgLoss + STAL → 소형 객체 정확도 향상 |
이 글에서는 YOLO26의 핵심 특징, 성능 지표, 실무 적용 방법까지 상세히 다뤄보겠습니다. 저처럼 실시간 객체 탐지가 필요한 프로젝트를 진행 중이시라면 도움이 되실 겁니다.
2. YOLO26이란?
YOLO26은 실시간 객체 탐지기 YOLO 시리즈의 최신 진화 버전으로, 세 가지 핵심 원칙에 따라 설계되었습니다.
┌─────────────────────────────────────────────────────────────────────────┐
│ YOLO26 설계 철학 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ 단순성 │ NMS 없이 직접 예측 생성 (End-to-End) │
│ │ (Simplicity) │ → 추론 파이프라인 단순화 │
│ └────────┬────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ 배포 효율성 │ 후처리 단계 제거로 통합 간소화 │
│ │ (Deployability) │ → 다양한 환경에서 안정적 배포 │
│ └────────┬────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ 훈련 혁신 │ MuSGD Optimizer 도입 │
│ │ (Innovation) │ → 안정적 훈련 + 빠른 수렴 │
│ └─────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘2.1 핵심 목표
| 목표 | 설명 |
|---|---|
| 엣지 최적화 | 저전력 디바이스에서 효율적 동작 |
| 배포 간소화 | NMS 제거로 프로덕션 통합 용이 |
| 성능 향상 | CPU에서 최대 43% 빠른 추론 |
3. 핵심 개선사항
3.1 DFL(Distribution Focal Loss) 제거
기존 YOLO 모델의 DFL 모듈은 효과적이지만, 내보내기가 복잡하고 하드웨어 호환성이 제한적이었습니다. YOLO26은 DFL을 완전히 제거하여 추론을 간소화했습니다.
기존 YOLO (DFL 포함) YOLO26 (DFL 제거)
┌─────────────────────┐ ┌─────────────────────┐
│ Backbone │ │ Backbone │
│ ↓ │ │ ↓ │
│ Neck (FPN) │ │ Neck (FPN) │
│ ↓ │ │ ↓ │
│ Head + DFL │ ─────────► │ Head (Simple) │
│ ↓ │ DFL 제거 │ ↓ │
│ NMS 후처리 │ │ 직접 출력 │
│ ↓ │ │ ↓ │
│ 최종 결과 │ │ 최종 결과 │
└─────────────────────┘ └─────────────────────┘3.2 End-to-End NMS-Free 추론
YOLO26의 가장 큰 특징은 네이티브 End-to-End 모델이라는 점입니다. NMS(Non-Maximum Suppression)를 별도 후처리 단계로 사용하지 않고, 예측이 직접 생성됩니다.
| 항목 | 기존 YOLO | YOLO26 |
|---|---|---|
| NMS 필요 여부 | 필요 | 불필요 |
| 후처리 단계 | 있음 | 없음 |
| 배포 복잡도 | 높음 | 낮음 |
| 추론 지연시간 | 상대적으로 높음 | 낮음 |
3.3 MuSGD Optimizer
YOLO26은 MuSGD라는 새로운 하이브리드 Optimizer를 도입했습니다. Moonshot AI의 Kimi K2 LLM 훈련에서 영감을 받아 SGD와 Muon을 결합한 방식입니다.
┌───────────────────────────────────────────────────────────────┐
│ MuSGD Optimizer │
├───────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────────┐ │
│ │ SGD │ + │ Muon │ = │ MuSGD │ │
│ │ (안정성) │ │ (효율성) │ │ (하이브리드) │ │
│ └─────────┘ └─────────┘ └─────────────┘ │
│ │
│ 특징: │
│ • LLM 훈련 최적화 기법을 CV에 적용 │
│ • 더 안정적인 훈련 │
│ • 더 빠른 수렴 │
│ │
└───────────────────────────────────────────────────────────────┘3.4 태스크별 최적화
| 태스크 | 개선 내용 |
|---|---|
| Segmentation | 의미론적 분할 손실 + 다중 스케일 프로토 모듈 |
| Pose | 잔차 로그-우도 추정(RLE)으로 고정밀 추정 |
| OBB | 각도 손실 함수로 경계 불연속성 문제 해결 |
4. 지원 태스크
YOLO26은 5가지 주요 컴퓨터 비전 태스크를 지원합니다.
| 모델 | 파일명 | 태스크 | 추론 | 검증 | 훈련 | 내보내기 |
|---|---|---|---|---|---|---|
| YOLO26 | yolo26n/s/m/l/x.pt |
객체 탐지 | ✅ | ✅ | ✅ | ✅ |
| YOLO26-seg | yolo26n/s/m/l/x-seg.pt |
인스턴스 분할 | ✅ | ✅ | ✅ | ✅ |
| YOLO26-pose | yolo26n/s/m/l/x-pose.pt |
포즈 추정 | ✅ | ✅ | ✅ | ✅ |
| YOLO26-obb | yolo26n/s/m/l/x-obb.pt |
방향 감지 | ✅ | ✅ | ✅ | ✅ |
| YOLO26-cls | yolo26n/s/m/l/x-cls.pt |
분류 | ✅ | ✅ | ✅ | ✅ |
5. 성능 벤치마크
5.1 객체 탐지 (COCO Dataset)
| 모델 | 크기 | mAP 50-95 | mAP (E2E) | CPU ONNX (ms) | T4 TensorRT (ms) | 파라미터 (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n | 640 | 40.9 | 40.1 | 38.9 | 1.7 | 2.4 | 5.4 |
| YOLO26s | 640 | 48.6 | 47.8 | 87.2 | 2.5 | 9.5 | 20.7 |
| YOLO26m | 640 | 53.1 | 52.5 | 220.0 | 4.7 | 20.4 | 68.2 |
| YOLO26l | 640 | 55.0 | 54.4 | 286.2 | 6.2 | 24.8 | 86.4 |
| YOLO26x | 640 | 57.5 | 56.9 | 525.8 | 11.8 | 55.7 | 193.9 |
5.2 인스턴스 분할 (COCO Dataset)
| 모델 | mAP Box (E2E) | mAP Mask (E2E) | CPU ONNX (ms) | 파라미터 (M) |
|---|---|---|---|---|
| YOLO26n-seg | 39.6 | 33.9 | 53.3 | 2.7 |
| YOLO26s-seg | 47.3 | 40.0 | 118.4 | 10.4 |
| YOLO26m-seg | 52.5 | 44.1 | 328.2 | 23.6 |
| YOLO26l-seg | 54.4 | 45.5 | 387.0 | 28.0 |
| YOLO26x-seg | 56.5 | 47.0 | 787.0 | 62.8 |
5.3 포즈 추정 (COCO Dataset)
| 모델 | mAP Pose (E2E) | mAP 50 (E2E) | CPU ONNX (ms) | 파라미터 (M) |
|---|---|---|---|---|
| YOLO26n-pose | 57.2 | 83.3 | 40.3 | 2.9 |
| YOLO26s-pose | 63.0 | 86.6 | 85.3 | 10.4 |
| YOLO26m-pose | 68.8 | 89.6 | 218.0 | 21.5 |
| YOLO26l-pose | 70.4 | 90.5 | 275.4 | 25.9 |
| YOLO26x-pose | 71.6 | 91.6 | 565.4 | 57.6 |
6. 사용 방법
6.1 설치
# ultralytics 패키지 설치/업데이트
pip install ultralytics --upgrade6.2 Python 코드
from ultralytics import YOLO
# 1. 사전 훈련된 모델 로드
model = YOLO("yolo26n.pt")
# 2. 이미지 추론
results = model("path/to/image.jpg")
# 3. 결과 시각화
results[0].show()
# 4. 결과 저장
results[0].save("output.jpg")6.3 커스텀 데이터셋 훈련
from ultralytics import YOLO
# 모델 로드
model = YOLO("yolo26n.pt")
# 훈련 실행
results = model.train(
data="custom_dataset.yaml", # 데이터셋 설정 파일
epochs=100, # 훈련 에폭 수
imgsz=640, # 입력 이미지 크기
batch=16, # 배치 크기
device=0 # GPU 디바이스 (0, 1, ... 또는 'cpu')
)6.4 CLI 사용법
# 추론
yolo predict model=yolo26n.pt source=path/to/image.jpg
# 훈련
yolo train model=yolo26n.pt data=coco8.yaml epochs=100 imgsz=640
# 검증
yolo val model=yolo26n.pt data=coco.yaml
# 모델 내보내기 (ONNX)
yolo export model=yolo26n.pt format=onnx6.5 내보내기 지원 형식
| 형식 | 명령어 | 용도 |
|---|---|---|
| ONNX | format=onnx |
범용 배포 |
| TensorRT | format=engine |
NVIDIA GPU 최적화 |
| CoreML | format=coreml |
Apple 디바이스 |
| TFLite | format=tflite |
모바일/엣지 |
| OpenVINO | format=openvino |
Intel 디바이스 |
7. YOLOE-26: 개방형 어휘 지원
YOLO26은 YOLOE-26이라는 개방형 어휘(Open-Vocabulary) 버전도 제공합니다. 텍스트 프롬프트, 시각적 프롬프트, 또는 프롬프트 없이도 객체를 탐지할 수 있습니다.
7.1 프롬프팅 방식 비교
┌─────────────────────────────────────────────────────────────────────────┐
│ YOLOE-26 프롬프팅 방식 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ 텍스트 프롬프트 │ "person", "bus" 등 클래스명 지정 │
│ └─────────────────┘ │
│ │
│ ┌─────────────────┐ │
│ │ 시각적 프롬프트 │ 바운딩 박스로 대상 객체 예시 제공 │
│ └─────────────────┘ │
│ │
│ ┌─────────────────┐ │
│ │ 프롬프트 없음 │ 4,585개 사전 정의 클래스 자동 탐지 (RAM++ 기반) │
│ └─────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘7.2 텍스트 프롬프트 사용 예시
from ultralytics import YOLO
# 모델 로드
model = YOLO("yoloe-26l-seg.pt")
# 탐지할 클래스 설정 (한 번만 실행)
names = ["person", "bus", "car"]
model.set_classes(names, model.get_text_pe(names))
# 추론 실행
results = model.predict("path/to/image.jpg")
results[0].show()7.3 시각적 프롬프트 사용 예시
import numpy as np
from ultralytics import YOLO
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor
# 모델 로드
model = YOLO("yoloe-26l-seg.pt")
# 시각적 프롬프트 정의 (바운딩 박스 + 클래스 ID)
visual_prompts = dict(
bboxes=np.array([
[221.52, 405.8, 344.98, 857.54], # 사람 영역
[120, 425, 160, 445], # 안경 영역
]),
cls=np.array([0, 1]) # 각각의 클래스 ID
)
# 추론 실행
results = model.predict(
"path/to/image.jpg",
visual_prompts=visual_prompts,
predictor=YOLOEVPSegPredictor,
)
results[0].show()8. 이전 버전과의 비교
8.1 YOLO26 vs YOLO11 핵심 차이점
| 항목 | YOLO11 | YOLO26 | 개선 효과 |
|---|---|---|---|
| NMS | 필요 | 불필요 (End-to-End) | 배포 간소화 |
| DFL | 포함 | 제거 | 엣지 호환성 향상 |
| Optimizer | SGD/Adam | MuSGD | 훈련 안정성/수렴 속도 |
| CPU 추론 | 기준 | 최대 43% 빠름 | 엣지 디바이스 적합 |
8.2 성능 비교 (Detection, COCO val)
| 모델 | mAP 50-95 | CPU (ms) | 파라미터 (M) |
|---|---|---|---|
| YOLO11n | 39.5 | 56.1 | 2.6 |
| YOLO26n | 40.9 | 38.9 | 2.4 |
| YOLO11s | 47.0 | 90.0 | 9.4 |
| YOLO26s | 48.6 | 87.2 | 9.5 |
주목할 점: YOLO26n은 YOLO11n 대비 mAP 1.4 향상, CPU 추론 속도 31% 개선
9. 실무 적용 가이드
9.1 실제 도입 사례: 중고 의류 자동 검수 시스템
제가 현재 설계 중인 중고 의류 자동 검수 AI 시스템에서 YOLO26n을 어떻게 활용하려는지 공유합니다.
┌─────────────────────────────────────────────────────────────────────────┐
│ 중고 의류 자동 검수 시스템 아키텍처 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 카메라1 │ │ 카메라2 │ │ 카메라3 │ ← 다각도 촬영 (3대) │
│ │ 전면 │ │ 후면 │ │ 측면 │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │
│ └─────────────┼─────────────┘ │
│ ▼ │
│ ┌─────────────┐ │
│ │ YOLO26n │ ← 1차 탐지: 의류/결함 검출 (~117ms) │
│ │ (E2E) │ NMS 불필요, 직접 결과 출력 │
│ └──────┬──────┘ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 규칙 엔진 │ ← 2차 판정: S/F 확정, A/B 후보 선별 │
│ └──────┬──────┘ │
│ ▼ │
│ ┌─────────────┐ │
│ │ Qwen2-VL │ ← 3차 분석: 경계 케이스만 VLM 검토 │
│ └──────┬──────┘ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 최종 등급 │ → S / A / B / F │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘YOLO26n 선택 이유
| 기존 YOLO11n | YOLO26n | 프로젝트 이점 |
|---|---|---|
| NMS 후처리 필요 | NMS-Free (E2E) | 파이프라인 코드 간소화 |
| CPU 56.1ms | CPU 38.9ms | 3장 처리 시 51ms 절약 |
| DFL 포함 | DFL 제거 | TensorRT 내보내기 용이 |
| mAP 39.5 | mAP 40.9 | 작은 결함 탐지율 향상 |
예상 처리 시간
┌────────────────────────────────────────────────────────────┐
│ 처리 시간 분석 │
├────────────────────────────────────────────────────────────┤
│ │
│ 이미지 전처리 : ~15ms │
│ YOLO26n 탐지 (3장) : ~117ms (39ms × 3) │
│ 규칙 기반 판정 : ~5ms │
│ ───────────────────────────────────── │
│ S/F 확정 케이스 합계 : ~137ms ✓ (목표 1초 이내 달성) │
│ │
│ + VLM 호출 시 (A/B 경계): ~400ms 추가 │
│ VLM 호출 케이스 합계 : ~537ms ✓ │
│ │
└────────────────────────────────────────────────────────────┘탐지 대상 클래스 설계
# 의류 검수용 커스텀 클래스 정의
CLOTHING_CLASSES = [
# 의류 카테고리 (8종)
"top", "bottom", "dress", "outerwear",
"shoes", "bag", "accessory", "other",
# 결함 유형 (9종)
"stain", "tear", "hole", "discoloration",
"pilling", "fading", "scratch", "deformation", "other_defect"
]
# YOLO26n 기반 커스텀 훈련
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="clothing_defect.yaml",
epochs=100,
imgsz=640,
batch=16,
# Recall 우선 (결함 누락 방지)
conf=0.3 # 결함 탐지 시 낮은 threshold
)9.2 모델 선택 가이드
| 사용 환경 | 권장 모델 | 이유 |
|---|---|---|
| 라즈베리파이/엣지 | YOLO26n | 최소 파라미터, 빠른 CPU 추론 |
| 모바일 앱 | YOLO26n/s | 경량 + 적절한 정확도 |
| 실시간 서버 | YOLO26s/m | 속도-정확도 균형 |
| 고정밀 분석 | YOLO26l/x | 최고 정확도 |
9.2 프로젝트별 태스크 선택
┌─────────────────────────────────────────────────────────────────────────┐
│ 태스크 선택 가이드 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ [객체 탐지] │
│ └── 사용 케이스: 재고 관리, 불량품 탐지, 자율주행 │
│ └── 모델: yolo26n.pt ~ yolo26x.pt │
│ │
│ [인스턴스 분할] │
│ └── 사용 케이스: 의료 영상, 자율주행 세그멘테이션 │
│ └── 모델: yolo26n-seg.pt ~ yolo26x-seg.pt │
│ │
│ [포즈 추정] │
│ └── 사용 케이스: 피트니스 앱, 동작 분석, AR/VR │
│ └── 모델: yolo26n-pose.pt ~ yolo26x-pose.pt │
│ │
│ [방향 감지 (OBB)] │
│ └── 사용 케이스: 항공 영상, 위성 이미지, 문서 탐지 │
│ └── 모델: yolo26n-obb.pt ~ yolo26x-obb.pt │
│ │
│ [분류] │
│ └── 사용 케이스: 품질 분류, 제품 카테고리화 │
│ └── 모델: yolo26n-cls.pt ~ yolo26x-cls.pt │
│ │
└─────────────────────────────────────────────────────────────────────────┘9.3 배포 환경별 내보내기 전략
| 타겟 환경 | 내보내기 형식 | 명령어 |
|---|---|---|
| NVIDIA Jetson | TensorRT | yolo export model=yolo26n.pt format=engine |
| Apple M1/M2 | CoreML | yolo export model=yolo26n.pt format=coreml |
| Android/iOS | TFLite | yolo export model=yolo26n.pt format=tflite |
| Intel NUC | OpenVINO | yolo export model=yolo26n.pt format=openvino |
| 웹 브라우저 | ONNX + ONNX.js | yolo export model=yolo26n.pt format=onnx |
10. 마치며
10.1 YOLO26의 의의
YOLO26은 단순한 버전 업데이트가 아닌, 엣지 AI 시대를 위한 패러다임 전환입니다.
| 혁신 포인트 | 의미 |
|---|---|
| End-to-End 설계 | 복잡한 후처리 파이프라인 제거 |
| MuSGD Optimizer | LLM 훈련 기법의 CV 적용 |
| CPU 최적화 | 저전력 디바이스 대중화 가능 |
10.2 중고 의류 검수 프로젝트를 통해 느낀 점
실제로 YOLO26을 프로젝트에 적용하려고 검토하면서 느낀 점들입니다:
좋았던 점:
- NMS 제거로 추론 코드가 깔끔해짐 (후처리 함수 불필요)
- CPU 성능 향상이 체감됨 (3장 처리 시 50ms+ 절약)
- Ultralytics의 통일된 API로 기존 코드 마이그레이션 용이
고려할 점:
- 2025년 1월 출시라 아직 커뮤니티 레퍼런스가 적음
- 커스텀 데이터셋 Fine-tuning 시 MuSGD 하이퍼파라미터 튜닝 필요
- YOLOE-26 (Open Vocabulary)은 아직 실험적 단계
결론:
엣지 배포가 목표이거나, 실시간 처리가 중요한 프로젝트라면 YOLO26은 현재 최선의 선택지 중 하나입니다. 특히 NMS-Free 설계는 프로덕션 파이프라인을 크게 단순화해줍니다.
10.3 활용 추천
- 스타트업/PoC: YOLO26n으로 빠른 프로토타이핑
- 프로덕션: YOLO26s/m으로 속도-정확도 균형
- 연구/고정밀: YOLO26x로 SOTA 성능 달성
- 오픈 월드: YOLOE-26으로 새로운 클래스 대응
10.3 참고 자료
728x90
반응형
'AI · ML > Computer Vision' 카테고리의 다른 글
| PyTorch 하드웨어 의존성 제거하기: Hugging Face Accelerate로 갈아타야 하는 이유 (0) | 2026.01.28 |
|---|---|
| YOLO만 쓰던 개발자가 RT-DETR을 선택한 이유 (1) | 2026.01.21 |