Add YOLO training and evaluation scripts

- Add split_train_val.py: Train/Val 8:2 분할 스크립트
- Add train_yolo.py: YOLOv8 모델 학습 스크립트 (100 epochs)
- Add quick_train.py: 빠른 테스트 학습 (5 epochs)
- Add evaluate.py: 모델 성능 평가 및 시각화
- Add inference.py: 추론 테스트 스크립트
- Update requirements.txt: 필요 패키지 추가
- Update README.md: 학습 프로세스 가이드 추가
- Update .gitignore: 학습 결과 디렉토리 제외

Features:
- Train/Validation split for proper model evaluation
- Comprehensive evaluation with confusion matrix
- Class-wise performance analysis
- Inference testing with visualization

.gitignore

@@ -29,3 +29,16 @@ Thumbs.db
 # Temporary files
 *.tmp
 *.temp
+
+# YOLO training outputs
+runs/
+waste_classification/
+test_run/
+dataset_split/
+evaluation_results/
+*.pt
+*.onnx
+
+# Cached files
+__pycache__/
+*.pyc

README.md

@@ -62,13 +62,71 @@ size_categories:
 │   ├── classes.txt
 │   ├── classes_kr.txt
 │   └── data.yaml
+├── dataset_split/             # Train/Val 분할 데이터 (실행 후 생성)
+│   ├── images/
+│   │   ├── train/            # 1,200개 (80%)
+│   │   └── val/              # 300개 (20%)
+│   ├── labels/
+│   │   ├── train/
+│   │   └── val/
+│   └── data.yaml
 ├── coco_to_yolo.py            # COCO → YOLO 변환 스크립트
 ├── remap_to_5_classes.py      # 60개 → 5개 재분류 스크립트
+├── split_train_val.py         # Train/Val 분할 스크립트
+├── train_yolo.py              # 모델 학습 스크립트
+├── quick_train.py             # 빠른 테스트 학습
+├── evaluate.py                # 모델 평가 스크립트
+├── inference.py               # 추론 테스트 스크립트
+├── requirements.txt           # 필요 패키지
 └── README.md
 ```
 
 ## 사용 방법
 
+### 전체 학습 프로세스
+
+#### 1단계: 환경 설치
+
+```bash
+pip install -r requirements.txt
+```
+
+#### 2단계: 데이터 분할 (Train 80% / Val 20%)
+
+```bash
+python split_train_val.py
+```
+
+이 스크립트는 데이터를 Train/Validation으로 8:2 비율로 분할하고 `dataset_split/` 디렉토리를 생성합니다.
+
+#### 3단계: 모델 학습
+
+```bash
+# 빠른 테스트 (5 에포크)
+python quick_train.py
+
+# 본격 학습 (100 에포크)
+python train_yolo.py
+```
+
+#### 4단계: 모델 평가
+
+```bash
+python evaluate.py waste_classification/yolov8n_5class/weights/best.pt
+```
+
+이 스크립트는 다음을 생성합니다:
+- 혼동 행렬 (Confusion Matrix)
+- 클래스별 성능 분석 그래프
+- 상세 분류 리포트
+- JSON 결과 파일
+
+#### 5단계: 추론 테스트
+
+```bash
+python inference.py waste_classification/yolov8n_5class/weights/best.pt data/batch_1/000006.jpg
+```
+
 ### YOLOv8 학습 예시 (5개 클래스)
 
 ```python

evaluate.py

@@ -0,0 +1,323 @@
+"""
+학습된 모델 성능 평가 스크립트
+- Validation 데이터로 상세 평가
+- 클래스별 성능 분석
+- 혼동 행렬, PR 곡선 등 시각화
+"""
+
+from ultralytics import YOLO
+from pathlib import Path
+import json
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+from sklearn.metrics import classification_report, confusion_matrix
+
+
+def evaluate_model(model_path, data_yaml='dataset_split/data.yaml', save_dir='evaluation_results'):
+    """
+    모델 상세 평가
+
+    Args:
+        model_path: 학습된 모델 경로 (.pt 파일)
+        data_yaml: 데이터셋 설정 파일
+        save_dir: 결과 저장 디렉토리
+    """
+
+    print("=" * 70)
+    print("모델 성능 평가")
+    print("=" * 70)
+
+    # 모델 로드
+    print(f"\n모델 로드: {model_path}")
+    model = YOLO(model_path)
+
+    # 저장 디렉토리 생성
+    save_path = Path(save_dir)
+    save_path.mkdir(exist_ok=True)
+
+    # ========================================
+    # 1. 전체 Validation 평가
+    # ========================================
+    print("\n" + "=" * 70)
+    print("1. Validation 데이터셋 평가")
+    print("=" * 70)
+
+    metrics = model.val(
+        data=data_yaml,
+        split='val',
+        save_json=True,
+        save_hybrid=True,
+        conf=0.001,
+        iou=0.6,
+        max_det=300,
+        plots=True,
+    )
+
+    # 전체 성능 출력
+    print("\n📊 전체 성능 지표:")
+    print(f"  mAP50     : {metrics.box.map50:.4f}  (50% IoU에서 정확도)")
+    print(f"  mAP50-95  : {metrics.box.map:.4f}  (50-95% IoU 평균)")
+    print(f"  Precision : {metrics.box.mp:.4f}  (정밀도)")
+    print(f"  Recall    : {metrics.box.mr:.4f}  (재현율)")
+
+    # 클래스별 성능
+    print("\n📋 클래스별 성능:")
+    print(f"{'Class':<15} {'mAP50':>8} {'mAP50-95':>10} {'Precision':>10} {'Recall':>8}")
+    print("-" * 65)
+
+    class_names = ['Plastic', 'Vinyl', 'Can', 'Glass', 'Paper']
+
+    for i, name in enumerate(class_names):
+        if i < len(metrics.box.ap50):
+            map50 = metrics.box.ap50[i]
+            map50_95 = metrics.box.ap[i]
+            precision = metrics.box.p[i] if i < len(metrics.box.p) else 0
+            recall = metrics.box.r[i] if i < len(metrics.box.r) else 0
+
+            print(f"{name:<15} {map50:>8.4f} {map50_95:>10.4f} {precision:>10.4f} {recall:>8.4f}")
+
+    # ========================================
+    # 2. 상세 분석 - 예측 결과 수집
+    # ========================================
+    print("\n" + "=" * 70)
+    print("2. 상세 분석 - Validation 이미지 예측")
+    print("=" * 70)
+
+    # Validation 이미지 경로 읽기
+    val_txt = Path('dataset_split/val.txt')
+    if val_txt.exists():
+        with open(val_txt, 'r') as f:
+            val_images = [line.strip() for line in f.readlines()]
+    else:
+        # val.txt가 없으면 직접 찾기
+        val_images_dir = Path('dataset_split/images/val')
+        val_images = list(val_images_dir.glob('**/*.[jJ][pP][gG]'))
+
+    print(f"Validation 이미지 수: {len(val_images)}")
+
+    # 예측 결과 수집
+    all_true_labels = []
+    all_pred_labels = []
+    all_confidences = []
+
+    print("예측 진행 중...")
+    for img_path in val_images[:100]:  # 일부만 샘플링 (시간 절약)
+        # 예측
+        results = model.predict(img_path, verbose=False, conf=0.25)
+
+        # Ground Truth 레이블 읽기
+        label_path = str(img_path).replace('/images/', '/labels/').replace('\\images\\', '\\labels\\')
+        label_path = label_path.replace('.jpg', '.txt').replace('.JPG', '.txt')
+
+        if Path(label_path).exists():
+            with open(label_path, 'r') as f:
+                for line in f:
+                    parts = line.strip().split()
+                    if len(parts) >= 5:
+                        true_class = int(parts[0])
+                        all_true_labels.append(true_class)
+
+        # 예측 결과
+        for r in results:
+            for box in r.boxes:
+                pred_class = int(box.cls[0])
+                conf = float(box.conf[0])
+                all_pred_labels.append(pred_class)
+                all_confidences.append(conf)
+
+    # ========================================
+    # 3. 혼동 행렬 (Confusion Matrix)
+    # ========================================
+    print("\n" + "=" * 70)
+    print("3. 혼동 행렬 생성")
+    print("=" * 70)
+
+    if len(all_true_labels) > 0 and len(all_pred_labels) > 0:
+        # 길이 맞추기
+        min_len = min(len(all_true_labels), len(all_pred_labels))
+        all_true_labels = all_true_labels[:min_len]
+        all_pred_labels = all_pred_labels[:min_len]
+
+        # Confusion Matrix
+        cm = confusion_matrix(all_true_labels, all_pred_labels, labels=range(5))
+
+        # 시각화
+        plt.figure(figsize=(10, 8))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
+                    xticklabels=class_names,
+                    yticklabels=class_names)
+        plt.title('Confusion Matrix', fontsize=16, fontweight='bold')
+        plt.ylabel('True Label', fontsize=12)
+        plt.xlabel('Predicted Label', fontsize=12)
+        plt.tight_layout()
+
+        cm_path = save_path / 'confusion_matrix_detailed.png'
+        plt.savefig(cm_path, dpi=300, bbox_inches='tight')
+        print(f"✅ 혼동 행렬 저장: {cm_path}")
+        plt.close()
+
+        # Classification Report
+        print("\n📊 Classification Report:")
+        report = classification_report(
+            all_true_labels,
+            all_pred_labels,
+            target_names=class_names,
+            digits=4
+        )
+        print(report)
+
+        # 리포트 저장
+        with open(save_path / 'classification_report.txt', 'w') as f:
+            f.write(report)
+
+    # ========================================
+    # 4. 성능 분석 그래프
+    # ========================================
+    print("\n" + "=" * 70)
+    print("4. 성능 분석 그래프 생성")
+    print("=" * 70)
+
+    # 클래스별 mAP 비교
+    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
+
+    # (1) 클래스별 mAP50
+    ax1 = axes[0, 0]
+    map50_values = [metrics.box.ap50[i] if i < len(metrics.box.ap50) else 0
+                    for i in range(5)]
+    colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A', '#98D8C8']
+    bars1 = ax1.bar(class_names, map50_values, color=colors, alpha=0.7, edgecolor='black')
+    ax1.set_ylabel('mAP50', fontsize=12, fontweight='bold')
+    ax1.set_title('클래스별 mAP50', fontsize=14, fontweight='bold')
+    ax1.set_ylim(0, 1)
+    ax1.grid(axis='y', alpha=0.3)
+
+    # 값 표시
+    for bar in bars1:
+        height = bar.get_height()
+        ax1.text(bar.get_x() + bar.get_width()/2., height,
+                f'{height:.3f}', ha='center', va='bottom', fontsize=10)
+
+    # (2) 클래스별 mAP50-95
+    ax2 = axes[0, 1]
+    map50_95_values = [metrics.box.ap[i] if i < len(metrics.box.ap) else 0
+                       for i in range(5)]
+    bars2 = ax2.bar(class_names, map50_95_values, color=colors, alpha=0.7, edgecolor='black')
+    ax2.set_ylabel('mAP50-95', fontsize=12, fontweight='bold')
+    ax2.set_title('클래스별 mAP50-95', fontsize=14, fontweight='bold')
+    ax2.set_ylim(0, 1)
+    ax2.grid(axis='y', alpha=0.3)
+
+    for bar in bars2:
+        height = bar.get_height()
+        ax2.text(bar.get_x() + bar.get_width()/2., height,
+                f'{height:.3f}', ha='center', va='bottom', fontsize=10)
+
+    # (3) Precision vs Recall
+    ax3 = axes[1, 0]
+    precision_values = [metrics.box.p[i] if i < len(metrics.box.p) else 0
+                       for i in range(5)]
+    recall_values = [metrics.box.r[i] if i < len(metrics.box.r) else 0
+                    for i in range(5)]
+
+    x = np.arange(len(class_names))
+    width = 0.35
+    ax3.bar(x - width/2, precision_values, width, label='Precision',
+            color='skyblue', alpha=0.8, edgecolor='black')
+    ax3.bar(x + width/2, recall_values, width, label='Recall',
+            color='lightcoral', alpha=0.8, edgecolor='black')
+    ax3.set_ylabel('Score', fontsize=12, fontweight='bold')
+    ax3.set_title('Precision vs Recall', fontsize=14, fontweight='bold')
+    ax3.set_xticks(x)
+    ax3.set_xticklabels(class_names)
+    ax3.legend()
+    ax3.set_ylim(0, 1)
+    ax3.grid(axis='y', alpha=0.3)
+
+    # (4) F1-Score
+    ax4 = axes[1, 1]
+    f1_scores = [2 * (p * r) / (p + r) if (p + r) > 0 else 0
+                 for p, r in zip(precision_values, recall_values)]
+    bars4 = ax4.bar(class_names, f1_scores, color=colors, alpha=0.7, edgecolor='black')
+    ax4.set_ylabel('F1-Score', fontsize=12, fontweight='bold')
+    ax4.set_title('클래스별 F1-Score', fontsize=14, fontweight='bold')
+    ax4.set_ylim(0, 1)
+    ax4.grid(axis='y', alpha=0.3)
+
+    for bar in bars4:
+        height = bar.get_height()
+        ax4.text(bar.get_x() + bar.get_width()/2., height,
+                f'{height:.3f}', ha='center', va='bottom', fontsize=10)
+
+    plt.tight_layout()
+    performance_path = save_path / 'performance_analysis.png'
+    plt.savefig(performance_path, dpi=300, bbox_inches='tight')
+    print(f"✅ 성능 분석 그래프 저장: {performance_path}")
+    plt.close()
+
+    # ========================================
+    # 5. 결과 JSON 저장
+    # ========================================
+    results_dict = {
+        'overall': {
+            'mAP50': float(metrics.box.map50),
+            'mAP50_95': float(metrics.box.map),
+            'precision': float(metrics.box.mp),
+            'recall': float(metrics.box.mr),
+        },
+        'per_class': {}
+    }
+
+    for i, name in enumerate(class_names):
+        if i < len(metrics.box.ap50):
+            results_dict['per_class'][name] = {
+                'mAP50': float(metrics.box.ap50[i]),
+                'mAP50_95': float(metrics.box.ap[i]),
+                'precision': float(metrics.box.p[i]) if i < len(metrics.box.p) else 0,
+                'recall': float(metrics.box.r[i]) if i < len(metrics.box.r) else 0,
+                'f1_score': f1_scores[i],
+            }
+
+    json_path = save_path / 'evaluation_results.json'
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(results_dict, f, indent=2, ensure_ascii=False)
+
+    print(f"✅ 결과 JSON 저장: {json_path}")
+
+    # ========================================
+    # 최종 요약
+    # ========================================
+    print("\n" + "=" * 70)
+    print("평가 완료!")
+    print("=" * 70)
+    print(f"\n저장 위치: {save_path.absolute()}")
+    print("\n생성된 파일:")
+    print(f"  - confusion_matrix_detailed.png")
+    print(f"  - performance_analysis.png")
+    print(f"  - classification_report.txt")
+    print(f"  - evaluation_results.json")
+
+    return metrics, results_dict
+
+
+if __name__ == '__main__':
+    import sys
+
+    # 모델 경로 입력
+    if len(sys.argv) > 1:
+        model_path = sys.argv[1]
+    else:
+        # 기본값: 최신 학습 모델
+        default_path = 'waste_classification/yolov8n_5class/weights/best.pt'
+
+        print(f"모델 경로를 입력하세요 (엔터: {default_path}):")
+        user_input = input().strip()
+        model_path = user_input if user_input else default_path
+
+    # 모델 존재 확인
+    if not Path(model_path).exists():
+        print(f"❌ 모델 파일을 찾을 수 없습니다: {model_path}")
+        sys.exit(1)
+
+    # 평가 실행
+    evaluate_model(model_path)

inference.py

@@ -0,0 +1,240 @@
+"""
+학습된 모델로 추론 (예측) 테스트
+- 단일 이미지 또는 폴더 예측
+- 결과 시각화 및 저장
+"""
+
+from ultralytics import YOLO
+from pathlib import Path
+import cv2
+import matplotlib.pyplot as plt
+from PIL import Image
+import numpy as np
+
+
+def predict_image(model_path, image_path, conf=0.25, save=True, show=False):
+    """
+    이미지 예측
+
+    Args:
+        model_path: 모델 경로
+        image_path: 이미지 경로
+        conf: 신뢰도 임계값 (0.0 ~ 1.0)
+        save: 결과 저장 여부
+        show: 결과 표시 여부
+    """
+
+    print("=" * 60)
+    print("이미지 예측")
+    print("=" * 60)
+
+    # 모델 로드
+    print(f"모델 로드: {model_path}")
+    model = YOLO(model_path)
+
+    # 예측
+    print(f"이미지: {image_path}")
+    print(f"신뢰도 임계값: {conf}")
+
+    results = model.predict(
+        source=image_path,
+        save=save,
+        conf=conf,
+        iou=0.7,
+        show_labels=True,
+        show_conf=True,
+        line_width=2,
+    )
+
+    # 결과 분석
+    for r in results:
+        print(f"\n탐지 결과:")
+        print(f"  이미지 크기: {r.orig_shape}")
+        print(f"  탐지된 객체 수: {len(r.boxes)}")
+
+        if len(r.boxes) > 0:
+            print(f"\n  {'클래스':<12} {'신뢰도':>8} {'좌표 (x, y, w, h)'}")
+            print("  " + "-" * 50)
+
+            for box in r.boxes:
+                cls_id = int(box.cls[0])
+                conf_val = float(box.conf[0])
+                cls_name = r.names[cls_id]
+                xyxy = box.xyxy[0].cpu().numpy()
+
+                print(f"  {cls_name:<12} {conf_val:>7.2%}  "
+                      f"({xyxy[0]:.0f}, {xyxy[1]:.0f}, "
+                      f"{xyxy[2]-xyxy[0]:.0f}, {xyxy[3]-xyxy[1]:.0f})")
+        else:
+            print("  객체가 탐지되지 않았습니다.")
+
+    # 시각화
+    if show:
+        for r in results:
+            img = r.plot()  # BGR
+            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+            plt.figure(figsize=(12, 8))
+            plt.imshow(img_rgb)
+            plt.axis('off')
+            plt.title(f"Detection Results (conf={conf})", fontsize=14)
+            plt.tight_layout()
+            plt.show()
+
+    print("\n✅ 예측 완료!")
+    if save:
+        print(f"결과 저장: runs/detect/predict/")
+
+    return results
+
+
+def predict_folder(model_path, folder_path, conf=0.25, save=True):
+    """
+    폴더 내 모든 이미지 예측
+
+    Args:
+        model_path: 모델 경로
+        folder_path: 이미지 폴더 경로
+        conf: 신뢰도 임계값
+        save: 결과 저장 여부
+    """
+
+    print("=" * 60)
+    print("폴더 예측")
+    print("=" * 60)
+
+    # 모델 로드
+    model = YOLO(model_path)
+
+    # 이미지 파일 찾기
+    folder = Path(folder_path)
+    image_files = list(folder.glob('*.[jJ][pP][gG]')) + \
+                  list(folder.glob('*.[pP][nN][gG]'))
+
+    print(f"폴더: {folder_path}")
+    print(f"발견된 이미지: {len(image_files)}개")
+
+    if len(image_files) == 0:
+        print("❌ 이미지를 찾을 수 없습니다.")
+        return None
+
+    # 예측
+    results = model.predict(
+        source=folder_path,
+        save=save,
+        conf=conf,
+        iou=0.7,
+        show_labels=True,
+        show_conf=True,
+    )
+
+    # 통계
+    total_detections = sum(len(r.boxes) for r in results)
+
+    print(f"\n예측 완료!")
+    print(f"  처리한 이미지: {len(results)}개")
+    print(f"  총 탐지 객체: {total_detections}개")
+    print(f"  평균 객체/이미지: {total_detections/len(results):.2f}개")
+
+    if save:
+        print(f"\n결과 저장: runs/detect/predict/")
+
+    return results
+
+
+def compare_predictions(model_path, image_path, conf_levels=[0.1, 0.25, 0.5, 0.75]):
+    """
+    다양한 신뢰도 임계값으로 예측 비교
+
+    Args:
+        model_path: 모델 경로
+        image_path: 이미지 경로
+        conf_levels: 신뢰도 임계값 리스트
+    """
+
+    print("=" * 60)
+    print("신뢰도 임계값 비교")
+    print("=" * 60)
+
+    model = YOLO(model_path)
+
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    axes = axes.flatten()
+
+    for i, conf in enumerate(conf_levels):
+        print(f"\n신뢰도 {conf:.2f} 예측 중...")
+
+        results = model.predict(
+            source=image_path,
+            conf=conf,
+            save=False,
+            verbose=False
+        )
+
+        for r in results:
+            img = r.plot()
+            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+            axes[i].imshow(img_rgb)
+            axes[i].axis('off')
+            axes[i].set_title(f'Confidence = {conf} ({len(r.boxes)} objects)',
+                             fontsize=12, fontweight='bold')
+
+    plt.tight_layout()
+    plt.savefig('confidence_comparison.png', dpi=150, bbox_inches='tight')
+    print("\n✅ 비교 결과 저장: confidence_comparison.png")
+    plt.show()
+
+
+if __name__ == '__main__':
+    import sys
+
+    # 기본 모델 경로
+    default_model = 'waste_classification/yolov8n_5class/weights/best.pt'
+
+    print("=" * 60)
+    print("YOLO 추론 테스트")
+    print("=" * 60)
+
+    # 모델 경로
+    if len(sys.argv) > 1:
+        model_path = sys.argv[1]
+    else:
+        print(f"\n모델 경로 (엔터: {default_model}):")
+        user_input = input().strip()
+        model_path = user_input if user_input else default_model
+
+    if not Path(model_path).exists():
+        print(f"❌ 모델을 찾을 수 없습니다: {model_path}")
+        sys.exit(1)
+
+    # 이미지 경로
+    if len(sys.argv) > 2:
+        image_path = sys.argv[2]
+    else:
+        default_image = 'data/batch_1/000006.jpg'
+        print(f"이미지 경로 (엔터: {default_image}):")
+        user_input = input().strip()
+        image_path = user_input if user_input else default_image
+
+    if not Path(image_path).exists():
+        print(f"❌ 이미지를 찾을 수 없습니다: {image_path}")
+        sys.exit(1)
+
+    # 예측 실행
+    print("\n작업 선택:")
+    print("  1. 단일 이미지 예측")
+    print("  2. 폴더 예측")
+    print("  3. 신뢰도 비교")
+
+    choice = input("선택 (1/2/3, 엔터: 1): ").strip() or '1'
+
+    if choice == '1':
+        predict_image(model_path, image_path, conf=0.25, save=True, show=True)
+    elif choice == '2':
+        folder = Path(image_path).parent if Path(image_path).is_file() else image_path
+        predict_folder(model_path, folder, conf=0.25, save=True)
+    elif choice == '3':
+        compare_predictions(model_path, image_path)
+    else:
+        print("잘못된 선택입니다.")

quick_train.py

@@ -0,0 +1,26 @@
+"""
+빠른 테스트용 학습 스크립트 (5 에포크만)
+"""
+
+from ultralytics import YOLO
+import torch
+
+print("GPU 사용 가능:", torch.cuda.is_available())
+
+# 모델 로드
+model = YOLO('yolov8n.pt')
+
+# 빠른 테스트 학습 (5 에포크만)
+results = model.train(
+    data='dataset_split/data.yaml',
+    epochs=5,
+    imgsz=640,
+    batch=8,
+    device='0' if torch.cuda.is_available() else 'cpu',
+    project='test_run',
+    name='quick_test',
+    exist_ok=True,
+)
+
+print("\n테스트 학습 완료!")
+print("결과 확인: test_run/quick_test/")

requirements.txt

@@ -0,0 +1,19 @@
+# YOLO 학습을 위한 패키지
+ultralytics>=8.0.0
+torch>=2.0.0
+torchvision>=0.15.0
+opencv-python>=4.8.0
+pillow>=10.0.0
+pyyaml>=6.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+pandas>=2.0.0
+scipy>=1.10.0
+tqdm>=4.65.0
+scikit-learn>=1.3.0
+
+# Optional: Weights & Biases (학습 로깅)
+# wandb>=0.15.0
+
+# Optional: TensorBoard (학습 모니터링)
+# tensorboard>=2.13.0

split_train_val.py

@@ -0,0 +1,226 @@
+"""
+데이터셋을 Train/Val로 8:2 분할하는 스크립트
+"""
+
+import json
+import shutil
+from pathlib import Path
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+import random
+
+
+def split_dataset(
+    images_dir='data',
+    labels_dir='labels_5classes',
+    output_base='dataset_split',
+    train_ratio=0.8,
+    seed=42
+):
+    """
+    데이터셋을 train/val로 분할
+
+    Args:
+        images_dir: 원본 이미지 디렉토리
+        labels_dir: 원본 레이블 디렉토리
+        output_base: 출력 디렉토리 이름
+        train_ratio: 학습 데이터 비율
+        seed: 랜덤 시드
+    """
+
+    random.seed(seed)
+
+    print("=" * 60)
+    print("데이터셋 Train/Val 분할")
+    print("=" * 60)
+
+    images_path = Path(images_dir)
+    labels_path = Path(labels_dir)
+    output_path = Path(output_base)
+
+    # 모든 이미지 파일 찾기
+    all_images = []
+    for batch_dir in sorted(images_path.glob('batch_*')):
+        for img_file in batch_dir.glob('*.[jJ][pP][gG]'):
+            # 상대 경로 저장 (batch_1/000006.jpg)
+            rel_path = img_file.relative_to(images_path)
+            all_images.append(str(rel_path))
+
+    print(f"총 이미지 수: {len(all_images)}")
+
+    # Train/Val 분할
+    train_images, val_images = train_test_split(
+        all_images,
+        train_size=train_ratio,
+        random_state=seed,
+        shuffle=True
+    )
+
+    print(f"Train 이미지: {len(train_images)} ({len(train_images)/len(all_images)*100:.1f}%)")
+    print(f"Val 이미지: {len(val_images)} ({len(val_images)/len(all_images)*100:.1f}%)")
+
+    # 출력 디렉토리 생성
+    train_images_dir = output_path / 'images' / 'train'
+    train_labels_dir = output_path / 'labels' / 'train'
+    val_images_dir = output_path / 'images' / 'val'
+    val_labels_dir = output_path / 'labels' / 'val'
+
+    for dir_path in [train_images_dir, train_labels_dir, val_images_dir, val_labels_dir]:
+        dir_path.mkdir(parents=True, exist_ok=True)
+
+    # 배치 폴더 생성
+    for batch_num in range(1, 16):
+        (train_images_dir / f'batch_{batch_num}').mkdir(exist_ok=True)
+        (train_labels_dir / f'batch_{batch_num}').mkdir(exist_ok=True)
+        (val_images_dir / f'batch_{batch_num}').mkdir(exist_ok=True)
+        (val_labels_dir / f'batch_{batch_num}').mkdir(exist_ok=True)
+
+    # Train 데이터 복사
+    print("\nTrain 데이터 복사 중...")
+    for img_rel_path in tqdm(train_images, desc="Train"):
+        # 이미지 복사
+        src_img = images_path / img_rel_path
+        dst_img = train_images_dir / img_rel_path
+        shutil.copy2(src_img, dst_img)
+
+        # 레이블 복사
+        label_rel_path = img_rel_path.replace('.jpg', '.txt').replace('.JPG', '.txt')
+        src_label = labels_path / label_rel_path
+        dst_label = train_labels_dir / label_rel_path
+
+        if src_label.exists():
+            shutil.copy2(src_label, dst_label)
+
+    # Val 데이터 복사
+    print("Val 데이터 복사 중...")
+    for img_rel_path in tqdm(val_images, desc="Val"):
+        # 이미지 복사
+        src_img = images_path / img_rel_path
+        dst_img = val_images_dir / img_rel_path
+        shutil.copy2(src_img, dst_img)
+
+        # 레이블 복사
+        label_rel_path = img_rel_path.replace('.jpg', '.txt').replace('.JPG', '.txt')
+        src_label = labels_path / label_rel_path
+        dst_label = val_labels_dir / label_rel_path
+
+        if src_label.exists():
+            shutil.copy2(src_label, dst_label)
+
+    # train.txt, val.txt 생성 (이미지 경로 리스트)
+    print("\n이미지 리스트 파일 생성 중...")
+
+    with open(output_path / 'train.txt', 'w') as f:
+        for img_path in train_images:
+            abs_path = (output_path / 'images' / 'train' / img_path).absolute()
+            f.write(f"{abs_path}\n")
+
+    with open(output_path / 'val.txt', 'w') as f:
+        for img_path in val_images:
+            abs_path = (output_path / 'images' / 'val' / img_path).absolute()
+            f.write(f"{abs_path}\n")
+
+    # data.yaml 생성
+    print("data.yaml 생성 중...")
+
+    yaml_content = f"""# YOLO Dataset Configuration
+# Train/Val Split: {train_ratio*100:.0f}/{(1-train_ratio)*100:.0f}
+
+path: {output_path.absolute()}
+train: images/train
+val: images/val
+
+# Classes
+nc: 5
+names:
+  0: Plastic
+  1: Vinyl
+  2: Can
+  3: Glass
+  4: Paper
+"""
+
+    with open(output_path / 'data.yaml', 'w', encoding='utf-8') as f:
+        f.write(yaml_content)
+
+    # 통계 출력
+    print("\n" + "=" * 60)
+    print("분할 완료!")
+    print("=" * 60)
+    print(f"출력 디렉토리: {output_path.absolute()}")
+    print(f"\n디렉토리 구조:")
+    print(f"{output_base}/")
+    print(f"├── images/")
+    print(f"│   ├── train/  ({len(train_images)} images)")
+    print(f"│   └── val/    ({len(val_images)} images)")
+    print(f"├── labels/")
+    print(f"│   ├── train/  ({len(train_images)} labels)")
+    print(f"│   └── val/    ({len(val_images)} labels)")
+    print(f"├── data.yaml")
+    print(f"├── train.txt")
+    print(f"└── val.txt")
+
+    # 클래스별 분포 확인
+    print(f"\n클래스별 분포 (Train):")
+    check_class_distribution(train_labels_dir)
+
+    print(f"\n클래스별 분포 (Val):")
+    check_class_distribution(val_labels_dir)
+
+    return output_path
+
+
+def check_class_distribution(labels_dir):
+    """레이블 디렉토리에서 클래스 분포 확인"""
+    class_names = ['Plastic', 'Vinyl', 'Can', 'Glass', 'Paper']
+    class_counts = {i: 0 for i in range(5)}
+
+    labels_path = Path(labels_dir)
+
+    for label_file in labels_path.glob('**/*.txt'):
+        with open(label_file, 'r') as f:
+            for line in f:
+                parts = line.strip().split()
+                if len(parts) >= 5:
+                    class_id = int(parts[0])
+                    class_counts[class_id] += 1
+
+    total = sum(class_counts.values())
+
+    for class_id, count in class_counts.items():
+        percentage = (count / total * 100) if total > 0 else 0
+        print(f"  {class_id} ({class_names[class_id]:>8s}): {count:4d} ({percentage:5.2f}%)")
+
+    print(f"  {'Total':>11s}: {total:4d}")
+
+
+if __name__ == '__main__':
+    import sys
+
+    # scikit-learn 확인
+    try:
+        from sklearn.model_selection import train_test_split
+    except ImportError:
+        print("❌ scikit-learn이 설치되어 있지 않습니다.")
+        print("설치: pip install scikit-learn")
+        sys.exit(1)
+
+    print("\n데이터셋을 Train/Val로 분할합니다.")
+    print("비율: Train 80% / Val 20%")
+
+    response = input("\n계속하시겠습니까? (y/n): ")
+    if response.lower() != 'y':
+        print("취소되었습니다.")
+        sys.exit(0)
+
+    # 분할 실행
+    output_dir = split_dataset(
+        images_dir='data',
+        labels_dir='labels_5classes',
+        output_base='dataset_split',
+        train_ratio=0.8,
+        seed=42
+    )
+
+    print("\n✅ 완료! 이제 다음 명령으로 학습하세요:")
+    print(f"   python train_yolo.py")

train_yolo.py

@@ -0,0 +1,233 @@
+"""
+YOLO 쓰레기 분류 모델 학습 스크립트
+
+5개 클래스: 플라스틱, 비닐, 캔, 유리, 종이
+"""
+
+from ultralytics import YOLO
+import torch
+from pathlib import Path
+
+
+def check_environment():
+    """학습 환경 확인"""
+    print("=" * 60)
+    print("학습 환경 확인")
+    print("=" * 60)
+
+    # CUDA 사용 가능 여부
+    cuda_available = torch.cuda.is_available()
+    print(f"CUDA 사용 가능: {cuda_available}")
+
+    if cuda_available:
+        print(f"GPU 이름: {torch.cuda.get_device_name(0)}")
+        print(f"GPU 메모리: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+    else:
+        print("⚠️ GPU를 사용할 수 없습니다. CPU로 학습하면 매우 느립니다.")
+
+    # 데이터 경로 확인
+    data_yaml = Path('dataset_split/data.yaml')
+    if data_yaml.exists():
+        print(f"✅ 데이터 설정 파일 존재: {data_yaml}")
+    else:
+        print(f"❌ 데이터 설정 파일 없음: {data_yaml}")
+        print(f"먼저 'python split_train_val.py'를 실행하세요.")
+        return False
+
+    print("=" * 60)
+    return True
+
+
+def train_model(
+    model_size='n',  # n(nano), s(small), m(medium), l(large), x(xlarge)
+    epochs=100,
+    batch_size=16,
+    img_size=640,
+    device='0',  # '0' for GPU, 'cpu' for CPU
+    patience=50,  # Early stopping patience
+    project_name='waste_classification'
+):
+    """
+    YOLO 모델 학습
+
+    Args:
+        model_size: 모델 크기 (n/s/m/l/x)
+            - n (nano): 가장 빠름, 정확도 낮음 (3.2M params)
+            - s (small): 빠름 (11.2M params)
+            - m (medium): 균형 (25.9M params)
+            - l (large): 느림, 정확도 높음 (43.7M params)
+            - x (xlarge): 가장 느림, 정확도 최고 (68.2M params)
+        epochs: 학습 에포크 수
+        batch_size: 배치 크기 (GPU 메모리에 따라 조정)
+        img_size: 이미지 크기
+        device: 'cuda' 또는 'cpu'
+        patience: Early stopping 기다림 에포크
+        project_name: 프로젝트 이름
+    """
+
+    print("\n" + "=" * 60)
+    print(f"YOLO v8 {model_size.upper()} 모델 학습 시작")
+    print("=" * 60)
+
+    # 모델 로드
+    model = YOLO(f'yolov8{model_size}.pt')
+
+    # 학습 파라미터 출력
+    print(f"\n학습 설정:")
+    print(f"  - 모델: YOLOv8{model_size}")
+    print(f"  - 에포크: {epochs}")
+    print(f"  - 배치 크기: {batch_size}")
+    print(f"  - 이미지 크기: {img_size}")
+    print(f"  - 디바이스: {device}")
+    print(f"  - Early Stopping Patience: {patience}")
+    print()
+
+    # 학습 실행
+    results = model.train(
+        data='dataset_split/data.yaml',
+        epochs=epochs,
+        imgsz=img_size,
+        batch=batch_size,
+        device=device,
+        patience=patience,
+        save=True,
+        save_period=10,  # 10 에포크마다 체크포인트 저장
+        project=project_name,
+        name=f'yolov8{model_size}_5class',
+        exist_ok=True,
+        pretrained=True,
+        optimizer='auto',
+        verbose=True,
+        seed=42,
+        deterministic=True,
+        single_cls=False,
+        rect=False,
+        cos_lr=False,
+        close_mosaic=10,
+        resume=False,
+        amp=True,  # Automatic Mixed Precision
+        fraction=1.0,
+        profile=False,
+        overlap_mask=True,
+        mask_ratio=4,
+        dropout=0.0,
+        val=True,
+        plots=True,
+
+        # Augmentation
+        hsv_h=0.015,
+        hsv_s=0.7,
+        hsv_v=0.4,
+        degrees=0.0,
+        translate=0.1,
+        scale=0.5,
+        shear=0.0,
+        perspective=0.0,
+        flipud=0.0,
+        fliplr=0.5,
+        mosaic=1.0,
+        mixup=0.0,
+        copy_paste=0.0,
+    )
+
+    print("\n" + "=" * 60)
+    print("학습 완료!")
+    print("=" * 60)
+
+    return model, results
+
+
+def validate_model(model, project_name='waste_classification', model_size='n'):
+    """학습된 모델 검증"""
+    print("\n" + "=" * 60)
+    print("모델 검증 중...")
+    print("=" * 60)
+
+    # 검증 실행
+    metrics = model.val()
+
+    print(f"\n검증 결과:")
+    print(f"  - mAP50: {metrics.box.map50:.4f}")
+    print(f"  - mAP50-95: {metrics.box.map:.4f}")
+    print(f"  - Precision: {metrics.box.mp:.4f}")
+    print(f"  - Recall: {metrics.box.mr:.4f}")
+
+    return metrics
+
+
+def test_inference(model, test_image_path='data/batch_1/000006.jpg'):
+    """테스트 이미지로 추론"""
+    print("\n" + "=" * 60)
+    print("추론 테스트")
+    print("=" * 60)
+
+    # 추론 실행
+    results = model.predict(
+        source=test_image_path,
+        save=True,
+        conf=0.25,
+        iou=0.7,
+        show_labels=True,
+        show_conf=True,
+    )
+
+    # 결과 출력
+    for r in results:
+        print(f"\n이미지: {test_image_path}")
+        print(f"탐지된 객체 수: {len(r.boxes)}")
+        for box in r.boxes:
+            cls_id = int(box.cls[0])
+            conf = float(box.conf[0])
+            cls_name = r.names[cls_id]
+            print(f"  - {cls_name}: {conf:.2f}")
+
+    return results
+
+
+if __name__ == '__main__':
+    # 환경 확인
+    if not check_environment():
+        print("환경 설정을 확인해주세요.")
+        exit(1)
+
+    # GPU 사용 가능 여부에 따라 디바이스 설정
+    device = '0' if torch.cuda.is_available() else 'cpu'
+
+    # 학습 설정
+    MODEL_SIZE = 'n'  # nano 모델 (빠른 학습)
+    EPOCHS = 100
+    BATCH_SIZE = 16 if torch.cuda.is_available() else 4
+    IMG_SIZE = 640
+
+    print(f"\n사용할 설정:")
+    print(f"  모델: yolov8{MODEL_SIZE}")
+    print(f"  에포크: {EPOCHS}")
+    print(f"  배치: {BATCH_SIZE}")
+    print(f"  디바이스: {'GPU' if device == '0' else 'CPU'}")
+
+    # 사용자 확인
+    response = input("\n학습을 시작하시겠습니까? (y/n): ")
+    if response.lower() != 'y':
+        print("학습이 취소되었습니다.")
+        exit(0)
+
+    # 모델 학습
+    model, results = train_model(
+        model_size=MODEL_SIZE,
+        epochs=EPOCHS,
+        batch_size=BATCH_SIZE,
+        img_size=IMG_SIZE,
+        device=device,
+    )
+
+    # 모델 검증
+    metrics = validate_model(model, model_size=MODEL_SIZE)
+
+    # 추론 테스트
+    test_inference(model)
+
+    print("\n" + "=" * 60)
+    print("모든 작업 완료!")
+    print("=" * 60)
+    print(f"\n학습된 모델 위치: waste_classification/yolov8{MODEL_SIZE}_5class/weights/best.pt")
+    print(f"학습 결과 그래프: waste_classification/yolov8{MODEL_SIZE}_5class/")