Add analysis tools, update gitignore, and clean up data files

- Add test and validation scripts (YOLOv8, Roboflow API testing)
- Add ground truth validation and labeling quality check tools
- Update .gitignore to exclude venv_gpu, test results, and local settings
- Remove obsolete image files and backups from git tracking
- Update ground_truth.json with latest labeling data

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

.gitignore

@@ -22,6 +22,7 @@ wheels/
 
 # Virtual Environment
 venv/
+venv_gpu/
 env/
 ENV/
 .venv
@@ -89,8 +90,8 @@ data/**/*.bmp
 # 하지만 샘플/테스트 이미지는 포함 (예외)
 !data/samples/
 !data/test/
-!data/251015/*.jpg
-!data/251015/*.png
+!data/흰다리새우\ 실측\ 데이터_익투스에이아이\(주\)/251015/*.jpg
+!data/흰다리새우\ 실측\ 데이터_익투스에이아이\(주\)/251015/*.png
 !test_*.jpg
 !test_*.png
 !sample_*.jpg
@@ -105,6 +106,8 @@ data/**/*.bmp
 results/
 outputs/
 runs/
+test_results/
+test_results_*/
 wandb/
 
 # TensorBoard
@@ -128,3 +131,21 @@ logs/
 # Large documentation
 *.pdf
 *.docx
+
+# Backups (폴더 전체 제외, 로컬에만 보관)
+backups/
+ground_truth_backup_*.json
+
+# Ground Truth (중요 파일은 포함)
+# ground_truth.json - Git에 포함됨
+
+# Test and analysis results (JSON)
+*_results.json
+*_optimization.json
+fp_analysis_result.json
+yolo_evaluation_results.json
+yolo_with_filter_results.json
+yolov8m_confidence_optimization*.json
+
+# Claude settings
+.claude/settings.local.json

analyze_fp_patterns.py

@@ -0,0 +1,284 @@
+# -*- coding: utf-8 -*-
+"""
+False Positive 패턴 분석
+GT 박스 vs 오검출 박스의 특징 비교
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import os
+import json
+import numpy as np
+from PIL import Image
+from test_visual_validation import (
+    load_rtdetr_model,
+    detect_with_rtdetr,
+    apply_universal_filter,
+    calculate_morphological_features,
+    calculate_visual_features
+)
+
+def calculate_iou(bbox1, bbox2):
+    """IoU 계산"""
+    x1_min, y1_min, x1_max, y1_max = bbox1
+    x2_min, y2_min, x2_max, y2_max = bbox2
+
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+    bbox1_area = (x1_max - x1_min) * (y1_max - y1_min)
+    bbox2_area = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = bbox1_area + bbox2_area - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+
+def analyze_fp_patterns(test_image_dir, ground_truth_path, confidence=0.065):
+    """False Positive 패턴 분석"""
+    print("\n" + "="*80)
+    print("🔍 False Positive 패턴 분석")
+    print("="*80)
+
+    # Ground truth 로드
+    with open(ground_truth_path, 'r', encoding='utf-8') as f:
+        ground_truths = json.load(f)
+
+    # 모델 로드
+    processor, model = load_rtdetr_model()
+
+    # 결과 저장
+    tp_features = []  # True Positive (GT와 매칭된 박스)
+    fp_features = []  # False Positive (오검출)
+    gt_features = []  # Ground Truth 박스
+
+    print(f"\n분석 중...")
+
+    for filename, gt_list in ground_truths.items():
+        if not gt_list:
+            continue
+
+        # 이미지 경로
+        if 'folder' in gt_list[0]:
+            folder = gt_list[0]['folder']
+            img_path = os.path.join(test_image_dir, folder, filename)
+        else:
+            img_path = os.path.join(test_image_dir, filename)
+
+        if not os.path.exists(img_path):
+            continue
+
+        # 이미지 로드
+        image = Image.open(img_path).convert('RGB')
+
+        # GT 특징 추출
+        for gt in gt_list:
+            morph = calculate_morphological_features(gt['bbox'], image.size)
+            visual = calculate_visual_features(image, gt['bbox'])
+
+            gt_features.append({
+                'filename': filename,
+                'type': 'GT',
+                'bbox': gt['bbox'],
+                'morph': morph,
+                'visual': visual,
+                'confidence': gt['confidence']
+            })
+
+        # 검출
+        all_detections = detect_with_rtdetr(image, processor, model, confidence)
+
+        # 각 검출 박스 분석
+        for det in all_detections:
+            morph = calculate_morphological_features(det['bbox'], image.size)
+            visual = calculate_visual_features(image, det['bbox'])
+
+            # GT와 매칭 확인
+            matched = False
+            for gt in gt_list:
+                iou = calculate_iou(det['bbox'], gt['bbox'])
+                if iou >= 0.5:
+                    matched = True
+                    tp_features.append({
+                        'filename': filename,
+                        'type': 'TP',
+                        'bbox': det['bbox'],
+                        'morph': morph,
+                        'visual': visual,
+                        'confidence': det['confidence'],
+                        'iou': iou
+                    })
+                    break
+
+            if not matched:
+                fp_features.append({
+                    'filename': filename,
+                    'type': 'FP',
+                    'bbox': det['bbox'],
+                    'morph': morph,
+                    'visual': visual,
+                    'confidence': det['confidence']
+                })
+
+    print(f"✅ 분석 완료")
+    print(f"   GT: {len(gt_features)}개")
+    print(f"   TP: {len(tp_features)}개")
+    print(f"   FP: {len(fp_features)}개")
+
+    # 통계 비교
+    print("\n" + "="*80)
+    print("📊 특징 비교: GT vs FP")
+    print("="*80)
+
+    # 1. 장단축비
+    gt_ratios = [f['morph']['aspect_ratio'] for f in gt_features]
+    fp_ratios = [f['morph']['aspect_ratio'] for f in fp_features]
+
+    print(f"\n1️⃣ 장단축비 (Aspect Ratio)")
+    print(f"   GT:  평균={np.mean(gt_ratios):.2f}, 범위=[{np.min(gt_ratios):.2f}, {np.max(gt_ratios):.2f}], std={np.std(gt_ratios):.2f}")
+    print(f"   FP:  평균={np.mean(fp_ratios):.2f}, 범위=[{np.min(fp_ratios):.2f}, {np.max(fp_ratios):.2f}], std={np.std(fp_ratios):.2f}")
+    print(f"   → 차이: {abs(np.mean(gt_ratios) - np.mean(fp_ratios)):.2f}")
+
+    # 2. Compactness
+    gt_compact = [f['morph']['compactness'] for f in gt_features]
+    fp_compact = [f['morph']['compactness'] for f in fp_features]
+
+    print(f"\n2️⃣ Compactness (세장도)")
+    print(f"   GT:  평균={np.mean(gt_compact):.3f}, 범위=[{np.min(gt_compact):.3f}, {np.max(gt_compact):.3f}], std={np.std(gt_compact):.3f}")
+    print(f"   FP:  평균={np.mean(fp_compact):.3f}, 범위=[{np.min(fp_compact):.3f}, {np.max(fp_compact):.3f}], std={np.std(fp_compact):.3f}")
+    print(f"   → 차이: {abs(np.mean(gt_compact) - np.mean(fp_compact)):.3f}")
+
+    # 3. 면적
+    gt_area = [f['morph']['width'] * f['morph']['height'] for f in gt_features]
+    fp_area = [f['morph']['width'] * f['morph']['height'] for f in fp_features]
+
+    print(f"\n3️⃣ 면적 (px²)")
+    print(f"   GT:  평균={np.mean(gt_area):.0f}, 범위=[{np.min(gt_area):.0f}, {np.max(gt_area):.0f}], std={np.std(gt_area):.0f}")
+    print(f"   FP:  평균={np.mean(fp_area):.0f}, 범위=[{np.min(fp_area):.0f}, {np.max(fp_area):.0f}], std={np.std(fp_area):.0f}")
+    print(f"   → 차이: {abs(np.mean(gt_area) - np.mean(fp_area)):.0f}")
+
+    # 4. Hue
+    gt_hue = [f['visual']['hue'] for f in gt_features]
+    fp_hue = [f['visual']['hue'] for f in fp_features]
+
+    print(f"\n4️⃣ Hue (색상)")
+    print(f"   GT:  평균={np.mean(gt_hue):.1f}, 범위=[{np.min(gt_hue):.1f}, {np.max(gt_hue):.1f}], std={np.std(gt_hue):.1f}")
+    print(f"   FP:  평균={np.mean(fp_hue):.1f}, 범위=[{np.min(fp_hue):.1f}, {np.max(fp_hue):.1f}], std={np.std(fp_hue):.1f}")
+    print(f"   → 차이: {abs(np.mean(gt_hue) - np.mean(fp_hue)):.1f}")
+
+    # 5. Saturation
+    gt_sat = [f['visual']['saturation'] for f in gt_features]
+    fp_sat = [f['visual']['saturation'] for f in fp_features]
+
+    print(f"\n5️⃣ Saturation (채도)")
+    print(f"   GT:  평균={np.mean(gt_sat):.1f}, 범위=[{np.min(gt_sat):.1f}, {np.max(gt_sat):.1f}], std={np.std(gt_sat):.1f}")
+    print(f"   FP:  평균={np.mean(fp_sat):.1f}, 범위=[{np.min(fp_sat):.1f}, {np.max(fp_sat):.1f}], std={np.std(fp_sat):.1f}")
+    print(f"   → 차이: {abs(np.mean(gt_sat) - np.mean(fp_sat)):.1f}")
+
+    # 6. Color std
+    gt_cstd = [f['visual']['color_std'] for f in gt_features]
+    fp_cstd = [f['visual']['color_std'] for f in fp_features]
+
+    print(f"\n6️⃣ Color Std (색상 일관성)")
+    print(f"   GT:  평균={np.mean(gt_cstd):.1f}, 범위=[{np.min(gt_cstd):.1f}, {np.max(gt_cstd):.1f}], std={np.std(gt_cstd):.1f}")
+    print(f"   FP:  평균={np.mean(fp_cstd):.1f}, 범위=[{np.min(fp_cstd):.1f}, {np.max(fp_cstd):.1f}], std={np.std(fp_cstd):.1f}")
+    print(f"   → 차이: {abs(np.mean(gt_cstd) - np.mean(fp_cstd)):.1f}")
+
+    # 7. Confidence
+    gt_conf = [f['confidence'] for f in gt_features]
+    fp_conf = [f['confidence'] for f in fp_features]
+
+    print(f"\n7️⃣ RT-DETR Confidence")
+    print(f"   GT:  평균={np.mean(gt_conf):.3f}, 범위=[{np.min(gt_conf):.3f}, {np.max(gt_conf):.3f}], std={np.std(gt_conf):.3f}")
+    print(f"   FP:  평균={np.mean(fp_conf):.3f}, 범위=[{np.min(fp_conf):.3f}, {np.max(fp_conf):.3f}], std={np.std(fp_conf):.3f}")
+    print(f"   → 차이: {abs(np.mean(gt_conf) - np.mean(fp_conf)):.3f}")
+
+    # 가장 차이나는 특징 찾기
+    print("\n" + "="*80)
+    print("🎯 판별력 높은 특징 (GT vs FP 차이)")
+    print("="*80)
+
+    differences = [
+        ('장단축비', abs(np.mean(gt_ratios) - np.mean(fp_ratios)) / np.mean(gt_ratios)),
+        ('Compactness', abs(np.mean(gt_compact) - np.mean(fp_compact)) / np.mean(gt_compact)),
+        ('면적', abs(np.mean(gt_area) - np.mean(fp_area)) / np.mean(gt_area)),
+        ('Hue', abs(np.mean(gt_hue) - np.mean(fp_hue)) / max(np.mean(gt_hue), 1)),
+        ('Saturation', abs(np.mean(gt_sat) - np.mean(fp_sat)) / max(np.mean(gt_sat), 1)),
+        ('Color Std', abs(np.mean(gt_cstd) - np.mean(fp_cstd)) / max(np.mean(gt_cstd), 1)),
+        ('Confidence', abs(np.mean(gt_conf) - np.mean(fp_conf)) / np.mean(gt_conf))
+    ]
+
+    differences.sort(key=lambda x: x[1], reverse=True)
+
+    for i, (name, diff) in enumerate(differences, 1):
+        print(f"{i}. {name}: {diff*100:.1f}% 차이")
+
+    # 상세 분포
+    print("\n" + "="*80)
+    print("📈 FP 상세 분포 (상위 오검출 패턴)")
+    print("="*80)
+
+    # 장단축비 분포
+    fp_ratio_dist = {
+        '< 3': len([r for r in fp_ratios if r < 3]),
+        '3-4': len([r for r in fp_ratios if 3 <= r < 4]),
+        '4-9': len([r for r in fp_ratios if 4 <= r < 9]),
+        '9-15': len([r for r in fp_ratios if 9 <= r < 15]),
+        '>= 15': len([r for r in fp_ratios if r >= 15])
+    }
+
+    print(f"\nFP 장단축비 분포:")
+    for range_name, count in fp_ratio_dist.items():
+        print(f"   {range_name}: {count}개 ({count/len(fp_ratios)*100:.1f}%)")
+
+    # 추천사항
+    print("\n" + "="*80)
+    print("💡 필터 개선 제안")
+    print("="*80)
+
+    # 가장 차이나는 특징 기반 제안
+    top_diff = differences[0]
+    if top_diff[0] == '장단축비':
+        print(f"1. 장단축비 필터 강화")
+        print(f"   - GT 범위: {np.min(gt_ratios):.2f}~{np.max(gt_ratios):.2f}")
+        print(f"   - FP 평균: {np.mean(fp_ratios):.2f}")
+        if np.mean(fp_ratios) < np.mean(gt_ratios):
+            print(f"   → FP가 더 둥글음. 하한을 {np.percentile(gt_ratios, 10):.1f}로 상향")
+        else:
+            print(f"   → FP가 더 가늘음. 상한을 {np.percentile(gt_ratios, 90):.1f}로 하향")
+
+    # 결과 저장
+    result = {
+        'gt_count': len(gt_features),
+        'tp_count': len(tp_features),
+        'fp_count': len(fp_features),
+        'feature_comparison': {
+            'aspect_ratio': {'gt': gt_ratios, 'fp': fp_ratios},
+            'compactness': {'gt': gt_compact, 'fp': fp_compact},
+            'area': {'gt': gt_area, 'fp': fp_area},
+            'hue': {'gt': gt_hue, 'fp': fp_hue},
+            'saturation': {'gt': gt_sat, 'fp': fp_sat},
+            'color_std': {'gt': gt_cstd, 'fp': fp_cstd},
+            'confidence': {'gt': gt_conf, 'fp': fp_conf}
+        },
+        'discriminative_features': differences
+    }
+
+    with open('fp_analysis_result.json', 'w', encoding='utf-8') as f:
+        # numpy array를 list로 변환
+        for key in result['feature_comparison']:
+            result['feature_comparison'][key]['gt'] = [float(x) for x in result['feature_comparison'][key]['gt']]
+            result['feature_comparison'][key]['fp'] = [float(x) for x in result['feature_comparison'][key]['fp']]
+        json.dump(result, f, ensure_ascii=False, indent=2)
+
+    print(f"\n📄 분석 결과 저장: fp_analysis_result.json")
+
+if __name__ == "__main__":
+    TEST_DIR = r"data\흰다리새우 실측 데이터_익투스에이아이(주)"
+    GT_PATH = "ground_truth.json"
+
+    analyze_fp_patterns(TEST_DIR, GT_PATH, confidence=0.065)

app_demo.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+"""
+새우 검출 시스템 데모 웹앱
+최종 최적화 버전 (Precision=44.2%, Recall=94%, F1=56.1%)
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import gradio as gr
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+from test_visual_validation import (
+    load_rtdetr_model,
+    detect_with_rtdetr,
+    apply_universal_filter
+)
+
+# 모델 로드 (시작시 한번만)
+print("🔄 RT-DETR 모델 로딩 중...")
+processor, model = load_rtdetr_model()
+print("✅ RT-DETR 로딩 완료\n")
+
+def detect_shrimp(image, confidence_threshold, filter_threshold):
+    """새우 검출 함수"""
+    if image is None:
+        return None, "이미지를 업로드하세요."
+
+    # PIL Image로 변환
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+
+    # RT-DETR 검출
+    all_detections = detect_with_rtdetr(image, processor, model, confidence_threshold)
+
+    # 필터 적용
+    filtered_detections = apply_universal_filter(all_detections, image, filter_threshold)
+
+    # 시각화
+    result_image = image.copy()
+    draw = ImageDraw.Draw(result_image)
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 20)
+        font_small = ImageFont.truetype("arial.ttf", 14)
+    except:
+        font = ImageFont.load_default()
+        font_small = ImageFont.load_default()
+
+    # 박스 그리기
+    for i, det in enumerate(filtered_detections, 1):
+        x1, y1, x2, y2 = det['bbox']
+
+        # 박스
+        draw.rectangle([x1, y1, x2, y2], outline="lime", width=4)
+
+        # 라벨
+        score = det['filter_score']
+        conf = det['confidence']
+        label = f"#{i} | Score:{score:.0f} | Conf:{conf:.2f}"
+
+        # 배경
+        bbox = draw.textbbox((x1, y1-25), label, font=font_small)
+        draw.rectangle(bbox, fill="lime")
+        draw.text((x1, y1-25), label, fill="black", font=font_small)
+
+    # 결과 텍스트
+    info = f"""
+📊 검출 결과:
+   • RT-DETR 검출: {len(all_detections)}개
+   • 필터 통과: {len(filtered_detections)}개
+   • 제거됨: {len(all_detections) - len(filtered_detections)}개
+
+⚙️ 설정:
+   • RT-DETR Confidence: {confidence_threshold}
+   • Filter Threshold: {filter_threshold}
+
+🎯 성능 (50개 GT 기준):
+   • Precision: 44.2%
+   • Recall: 94.0%
+   • F1 Score: 56.1%
+"""
+
+    if len(filtered_detections) > 0:
+        info += f"\n✅ {len(filtered_detections)}개의 새우를 검출했습니다!"
+    else:
+        info += "\n⚠️ 새우가 검출되지 않았습니다. Threshold를 낮춰보세요."
+
+    return result_image, info
+
+# Gradio 인터페이스
+with gr.Blocks(title="🦐 새우 검출 시스템 v1.0") as demo:
+    gr.Markdown("""
+    # 🦐 새우 검출 시스템 v1.0
+    **RT-DETR + Universal Filter (최적화 완료)**
+
+    - **Precision**: 44.2% (검출된 박스 중 실제 새우 비율)
+    - **Recall**: 94.0% (실제 새우 중 검출된 비율)
+    - **F1 Score**: 56.1% (전체 성능)
+    """)
+
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(label="📤 이미지 업로드", type="pil")
+
+            with gr.Row():
+                conf_slider = gr.Slider(
+                    minimum=0.05,
+                    maximum=0.5,
+                    value=0.065,
+                    step=0.005,
+                    label="🎯 RT-DETR Confidence",
+                    info="낮을수록 더 많이 검출 (권장: 0.065)"
+                )
+
+                filter_slider = gr.Slider(
+                    minimum=50,
+                    maximum=100,
+                    value=90,
+                    step=5,
+                    label="🔍 Filter Threshold",
+                    info="높을수록 엄격한 필터링 (권장: 90)"
+                )
+
+            detect_btn = gr.Button("🚀 새우 검출 시작", variant="primary", size="lg")
+
+        with gr.Column():
+            output_image = gr.Image(label="📊 검출 결과")
+            output_text = gr.Textbox(label="📝 상세 정보", lines=15)
+
+    # 예제 이미지
+    gr.Examples(
+        examples=[
+            ["data/test_shrimp_tank.png", 0.065, 90],
+        ],
+        inputs=[input_image, conf_slider, filter_slider],
+        label="📁 예제 이미지 (클릭하여 테스트)"
+    )
+
+    # 이벤트 연결
+    detect_btn.click(
+        fn=detect_shrimp,
+        inputs=[input_image, conf_slider, filter_slider],
+        outputs=[output_image, output_text]
+    )
+
+# 앱 실행
+if __name__ == "__main__":
+    print("="*60)
+    print("🦐 새우 검출 시스템 v1.0 시작")
+    print("="*60)
+    print("⚙️  최적 설정:")
+    print("   - RT-DETR Confidence: 0.065")
+    print("   - Filter Threshold: 90")
+    print("\n📊 성능 (50개 GT 기준):")
+    print("   - Precision: 44.2%")
+    print("   - Recall: 94.0%")
+    print("   - F1 Score: 56.1%")
+    print("="*60)
+
+    demo.launch(
+        server_name="0.0.0.0",
+        share=False
+    )

check_250818_labeling.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""250818 폴더 라벨링 검수"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+import json
+
+with open('ground_truth.json', 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+print("=" * 70)
+print("📋 250818 폴더 라벨링 검수")
+print("=" * 70)
+
+folder_data = {k: v for k, v in data.items() if k.startswith('250818_') and not '-' in k}
+
+print(f"\n✅ 라벨링된 이미지: {len([v for v in folder_data.values() if v])}개")
+print(f"❌ 건너뛴 이미지: {len([v for v in folder_data.values() if not v])}개")
+
+print(f"\n{'파일명':<20} {'박스수':>6} {'종횡비':>8} {'신뢰도':>8} {'상태':>10}")
+print("-" * 70)
+
+issues = []
+
+for filename in sorted(folder_data.keys()):
+    boxes = folder_data[filename]
+
+    if not boxes:
+        print(f"{filename:<20} {'0':>6} {'-':>8} {'-':>8} {'⚠️ 건너뜀':>10}")
+        issues.append(f"{filename}: 건너뛴 이미지 (새우 없음?)")
+    else:
+        for box in boxes:
+            bbox = box['bbox']
+            x1, y1, x2, y2 = bbox
+            width = x2 - x1
+            height = y2 - y1
+            aspect = width / height if height > 0 else 0
+            conf = box['confidence']
+
+            # 이상치 판단
+            status = "✅ 정상"
+            if aspect < 0.5:  # 너무 세로로 긴 경우
+                status = "⚠️ 세로"
+                issues.append(f"{filename}: 종횡비 {aspect:.2f} (너무 세로로 김)")
+            elif aspect > 15:  # 너무 가로로 긴 경우
+                status = "⚠️ 가로"
+                issues.append(f"{filename}: 종횡비 {aspect:.2f} (너무 가로로 김)")
+            elif conf < 0.1:
+                status = "⚠️ 낮음"
+                issues.append(f"{filename}: 신뢰도 {conf:.3f} (매우 낮음)")
+
+            print(f"{filename:<20} {len(boxes):>6} {aspect:>8.2f} {conf:>8.3f} {status:>10}")
+
+print("\n" + "=" * 70)
+if issues:
+    print("⚠️  확인 필요한 항목:")
+    print("-" * 70)
+    for issue in issues:
+        print(f"  • {issue}")
+else:
+    print("✅ 모든 라벨링 정상!")
+
+print("\n" + "=" * 70)
+print("📊 통계")
+print("-" * 70)
+
+all_boxes = [box for boxes in folder_data.values() if boxes for box in boxes]
+if all_boxes:
+    aspects = [((box['bbox'][2]-box['bbox'][0])/(box['bbox'][3]-box['bbox'][1]))
+               for box in all_boxes if (box['bbox'][3]-box['bbox'][1]) > 0]
+    confs = [box['confidence'] for box in all_boxes]
+
+    print(f"평균 종횡비: {sum(aspects)/len(aspects):.2f}")
+    print(f"평균 신뢰도: {sum(confs)/len(confs):.3f}")
+    print(f"최소 신뢰도: {min(confs):.3f}")
+    print(f"최대 신뢰도: {max(confs):.3f}")
+
+print("\n" + "=" * 70)
+print("💡 권장사항")
+print("-" * 70)
+print("• 종횡비 3:1 ~ 10:1 범위가 새우의 일반적인 비율")
+print("• 신뢰도 0.1 이하는 오검출 가능성 높음")
+print("• 건너뛴 이미지는 실제로 새우가 없는지 재확인")
+print("=" * 70)

check_gt_split.py

@@ -0,0 +1,38 @@
+import json
+import os
+
+# Ground Truth 파일 로드
+with open('ground_truth.json', 'r', encoding='utf-8') as f:
+    gt = json.load(f)
+
+# GT가 있는 이미지 목록
+gt_images = [k for k, v in gt.items() if v]
+print(f'GT 이미지 총 {len(gt_images)}장')
+
+# Train/Val split 확인
+train_images = set(os.listdir('data/yolo_dataset/images/train'))
+val_images = set(os.listdir('data/yolo_dataset/images/val'))
+
+gt_in_train = []
+gt_in_val = []
+
+for img in gt_images:
+    base_name = img.replace('-1.jpg', '.jpg')
+    if img in train_images or base_name in train_images:
+        gt_in_train.append(img)
+    elif img in val_images or base_name in val_images:
+        gt_in_val.append(img)
+
+print(f'\nGT 분포:')
+print(f'  - Train set: {len(gt_in_train)}장')
+print(f'  - Val set: {len(gt_in_val)}장')
+
+if len(gt_in_train) > 0:
+    print(f'\n문제: GT {len(gt_in_train)}장이 학습 데이터에 포함됨!')
+    print(f'해결: Val set {len(gt_in_val)}장만으로 평가해야 함')
+
+print(f'\nVal set GT 이미지:')
+for img in gt_in_val[:10]:
+    print(f'  - {img}')
+if len(gt_in_val) > 10:
+    print(f'  ... and {len(gt_in_val)-10} more')

check_labeling_quality.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""올바른 라벨링 품질 검수"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+import json
+import math
+
+def calculate_iou(box1, box2):
+    """IoU 계산"""
+    x1_min, y1_min, x1_max, y1_max = box1
+    x2_min, y2_min, x2_max, y2_max = box2
+
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+    box1_area = (x1_max - x1_min) * (y1_max - y1_min)
+    box2_area = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = box1_area + box2_area - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+
+with open('ground_truth.json', 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+print("=" * 80)
+print("📋 라벨링 품질 검수 (올바른 기준)")
+print("=" * 80)
+
+folder_data = {k: v for k, v in data.items() if k.startswith('250818_') and not '-' in k}
+
+print(f"\n✅ 라벨링된 이미지: {len([v for v in folder_data.values() if v])}개")
+print(f"⚠️  건너뛴 이미지: {len([v for v in folder_data.values() if not v])}개")
+
+print(f"\n{'파일명':<20} {'박스':>4} {'장단축비':>8} {'면적':>10} {'신뢰도':>8} {'상태':>12}")
+print("-" * 80)
+
+issues = []
+warnings = []
+
+for filename in sorted(folder_data.keys()):
+    boxes = folder_data[filename]
+
+    if not boxes:
+        print(f"{filename:<20} {'0':>4} {'-':>8} {'-':>10} {'-':>8} {'⚠️ 건너뜀':>12}")
+        warnings.append(f"{filename}: 건너뛴 이미지")
+        continue
+
+    # 박스 수 확인
+    if len(boxes) > 10:
+        issues.append(f"{filename}: 박스 {len(boxes)}개 (너무 많음, 오검출 의심)")
+
+    # 중복 박스 확인
+    if len(boxes) > 1:
+        for i in range(len(boxes)):
+            for j in range(i+1, len(boxes)):
+                iou = calculate_iou(boxes[i]['bbox'], boxes[j]['bbox'])
+                if iou > 0.5:
+                    issues.append(f"{filename}: 박스 #{i+1}과 #{j+1} 중첩 (IoU={iou:.2f}, 중복 선택?)")
+
+    for idx, box in enumerate(boxes):
+        bbox = box['bbox']
+        x1, y1, x2, y2 = bbox
+        width = x2 - x1
+        height = y2 - y1
+        area = width * height
+        conf = box['confidence']
+
+        # 장축/단축 비율 (방향 무관)
+        long_axis = max(width, height)
+        short_axis = min(width, height)
+        axis_ratio = long_axis / short_axis if short_axis > 0 else 0
+
+        # 품질 판단
+        status = "✅ 정상"
+        issue_desc = []
+
+        # 1. 면적 체크
+        if area < 1000:
+            status = "❌ 너무작음"
+            issues.append(f"{filename} 박스#{idx+1}: 면적 {area:.0f}px² (너무 작음, 오검출?)")
+            issue_desc.append("면적↓")
+        elif area > 1000000:
+            status = "❌ 너무큼"
+            issues.append(f"{filename} 박스#{idx+1}: 면적 {area:.0f}px² (너무 큼, 배경 포함?)")
+            issue_desc.append("면적↑")
+
+        # 2. 장단축 비율 (새우는 길쭉해야 함)
+        if axis_ratio < 2.5:
+            status = "⚠️ 둥글음"
+            warnings.append(f"{filename} 박스#{idx+1}: 장단축비 {axis_ratio:.2f} (너무 둥글음, 새우 맞나?)")
+            issue_desc.append("둥글음")
+        elif axis_ratio > 20:
+            status = "⚠️ 가늘음"
+            warnings.append(f"{filename} 박스#{idx+1}: 장단축비 {axis_ratio:.2f} (너무 가늘음)")
+            issue_desc.append("가늘음")
+
+        # 3. 신뢰도 체크
+        if conf < 0.05:
+            status = "❌ 신뢰도↓"
+            issues.append(f"{filename} 박스#{idx+1}: 신뢰도 {conf:.3f} (매우 낮음, 오검출 의심)")
+            issue_desc.append("신뢰↓")
+        elif conf < 0.15:
+            if status == "✅ 정상":
+                status = "⚠️ 신뢰도↓"
+            warnings.append(f"{filename} 박스#{idx+1}: 신뢰도 {conf:.3f} (낮음, 재확인 권장)")
+            issue_desc.append("신뢰낮음")
+
+        issue_str = ",".join(issue_desc) if issue_desc else ""
+        if issue_str:
+            status = f"⚠️ {issue_str}"
+
+        print(f"{filename:<20} {len(boxes):>4} {axis_ratio:>8.2f} {area:>10.0f} {conf:>8.3f} {status:>12}")
+
+print("\n" + "=" * 80)
+if issues:
+    print("❌ 심각한 문제 (재확인 필수):")
+    print("-" * 80)
+    for issue in issues[:10]:  # 최대 10개만
+        print(f"  • {issue}")
+    if len(issues) > 10:
+        print(f"  ... 외 {len(issues)-10}개")
+else:
+    print("✅ 심각한 문제 없음")
+
+if warnings:
+    print(f"\n⚠️  경고 ({len(warnings)}개, 재확인 권장):")
+    print("-" * 80)
+    for warning in warnings[:10]:  # 최대 10개만
+        print(f"  • {warning}")
+    if len(warnings) > 10:
+        print(f"  ... 외 {len(warnings)-10}개")
+
+print("\n" + "=" * 80)
+print("📊 통계")
+print("-" * 80)
+
+all_boxes = [box for boxes in folder_data.values() if boxes for box in boxes]
+if all_boxes:
+    areas = [(box['bbox'][2]-box['bbox'][0])*(box['bbox'][3]-box['bbox'][1]) for box in all_boxes]
+    axis_ratios = []
+    for box in all_boxes:
+        w = box['bbox'][2] - box['bbox'][0]
+        h = box['bbox'][3] - box['bbox'][1]
+        axis_ratios.append(max(w,h)/min(w,h) if min(w,h) > 0 else 0)
+    confs = [box['confidence'] for box in all_boxes]
+
+    print(f"총 박스: {len(all_boxes)}개")
+    print(f"평균 면적: {sum(areas)/len(areas):,.0f} px²")
+    print(f"평균 장단축비: {sum(axis_ratios)/len(axis_ratios):.2f} (정상 범위: 3~15)")
+    print(f"평균 신뢰도: {sum(confs)/len(confs):.3f}")
+    print(f"신뢰도 범위: {min(confs):.3f} ~ {max(confs):.3f}")
+
+print("\n" + "=" * 80)
+print("💡 품질 기준")
+print("-" * 80)
+print("✅ 장단축비: 3:1 ~ 15:1 (새우는 길쭉함, 방향 무관)")
+print("✅ 면적: 1,000 ~ 1,000,000 px²")
+print("✅ 신뢰도: > 0.15")
+print("✅ 박스 수: 1~5개/이미지")
+print("✅ 중첩: IoU < 0.5 (중복 선택 방지)")
+print("=" * 80)
+
+# 최종 평가
+print("\n" + "=" * 80)
+print("📋 최종 평가")
+print("-" * 80)
+if not issues and len(warnings) <= 3:
+    print("🎉 우수: 라벨링 품질이 매우 좋습니다!")
+elif not issues:
+    print("✅ 양호: 몇 가지 재확인 권장")
+elif len(issues) <= 3:
+    print("⚠️  보통: 일부 박스 재확인 필요")
+else:
+    print("❌ 불량: 많은 박스 재라벨링 필요")
+print("=" * 80)

convert_gt_to_yolo.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""
+Ground Truth를 YOLO format으로 변환
+Train/Val split 포함
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import json
+import os
+import shutil
+from pathlib import Path
+import random
+from PIL import Image
+
+def convert_bbox_to_yolo(bbox, img_width, img_height):
+    """
+    [x1, y1, x2, y2] → [x_center, y_center, width, height] (normalized)
+    """
+    x1, y1, x2, y2 = bbox
+
+    # Center coordinates
+    x_center = (x1 + x2) / 2.0
+    y_center = (y1 + y2) / 2.0
+
+    # Width and height
+    width = x2 - x1
+    height = y2 - y1
+
+    # Normalize to [0, 1]
+    x_center_norm = x_center / img_width
+    y_center_norm = y_center / img_height
+    width_norm = width / img_width
+    height_norm = height / img_height
+
+    return x_center_norm, y_center_norm, width_norm, height_norm
+
+def main():
+    print("=" * 60)
+    print("Ground Truth → YOLO Format 변환 시작")
+    print("=" * 60)
+
+    # 경로 설정
+    gt_file = "ground_truth.json"
+    data_base_dir = "data/흰다리새우 실측 데이터_익투스에이아이(주)"
+    output_base_dir = "data/yolo_dataset"
+
+    # YOLO 디렉토리 구조 생성
+    train_img_dir = Path(output_base_dir) / "images" / "train"
+    val_img_dir = Path(output_base_dir) / "images" / "val"
+    train_label_dir = Path(output_base_dir) / "labels" / "train"
+    val_label_dir = Path(output_base_dir) / "labels" / "val"
+
+    for d in [train_img_dir, val_img_dir, train_label_dir, val_label_dir]:
+        d.mkdir(parents=True, exist_ok=True)
+
+    # Ground Truth 로드
+    print(f"\n📂 {gt_file} 로딩 중...")
+    with open(gt_file, 'r', encoding='utf-8') as f:
+        gt_data = json.load(f)
+
+    # 데이터 수집
+    all_samples = []
+
+    for filename, annotations in gt_data.items():
+        if not annotations:  # 빈 리스트는 건너뛰기
+            continue
+
+        # 첫 번째 annotation에서 폴더 정보 가져오기
+        folder = annotations[0].get('folder', '')
+
+        if not folder:
+            print(f"⚠️  {filename}: 폴더 정보 없음, 건너뜀")
+            continue
+
+        # 이미지 경로 확인
+        img_path = os.path.join(data_base_dir, folder, filename)
+
+        if not os.path.exists(img_path):
+            print(f"⚠️  이미지 없음: {img_path}")
+            continue
+
+        all_samples.append({
+            'filename': filename,
+            'folder': folder,
+            'img_path': img_path,
+            'annotations': annotations
+        })
+
+    print(f"\n✅ 총 {len(all_samples)}개 샘플 수집 완료")
+
+    # Train/Val Split (80/20)
+    random.seed(42)  # 재현성을 위해
+    random.shuffle(all_samples)
+
+    split_idx = int(len(all_samples) * 0.8)
+    train_samples = all_samples[:split_idx]
+    val_samples = all_samples[split_idx:]
+
+    print(f"\n📊 데이터 분할:")
+    print(f"   - Train: {len(train_samples)}개")
+    print(f"   - Val: {len(val_samples)}개")
+
+    # 변환 함수
+    def process_samples(samples, img_dir, label_dir, split_name):
+        print(f"\n🔄 {split_name} 데이터 변환 중...")
+
+        for idx, sample in enumerate(samples, 1):
+            filename = sample['filename']
+            img_path = sample['img_path']
+            annotations = sample['annotations']
+
+            # 이미지 복사
+            dest_img_path = img_dir / filename
+            shutil.copy2(img_path, dest_img_path)
+
+            # 이미지 크기 가져오기
+            with Image.open(img_path) as img:
+                img_width, img_height = img.size
+
+            # YOLO 라벨 생성
+            label_filename = Path(filename).stem + ".txt"
+            label_path = label_dir / label_filename
+
+            with open(label_path, 'w') as f:
+                for ann in annotations:
+                    bbox = ann['bbox']
+
+                    # YOLO format으로 변환
+                    x_center, y_center, width, height = convert_bbox_to_yolo(
+                        bbox, img_width, img_height
+                    )
+
+                    # YOLO 형식: class_id x_center y_center width height
+                    # class_id=0 (shrimp)
+                    f.write(f"0 {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}\n")
+
+            if idx % 10 == 0 or idx == len(samples):
+                print(f"   진행: {idx}/{len(samples)}")
+
+    # Train/Val 데이터 처리
+    process_samples(train_samples, train_img_dir, train_label_dir, "Train")
+    process_samples(val_samples, val_img_dir, val_label_dir, "Val")
+
+    # data.yaml 생성
+    yaml_path = Path(output_base_dir) / "data.yaml"
+    yaml_content = f"""# Shrimp Detection Dataset
+path: {output_base_dir}  # dataset root dir
+train: images/train  # train images (relative to 'path')
+val: images/val  # val images (relative to 'path')
+
+# Classes
+nc: 1  # number of classes
+names: ['shrimp']  # class names
+"""
+
+    with open(yaml_path, 'w', encoding='utf-8') as f:
+        f.write(yaml_content)
+
+    print(f"\n✅ data.yaml 생성 완료: {yaml_path}")
+
+    # 요약 출력
+    print("\n" + "=" * 60)
+    print("✅ 변환 완료!")
+    print("=" * 60)
+    print(f"\n📁 출력 디렉토리: {output_base_dir}")
+    print(f"\n📊 데이터셋 구조:")
+    print(f"   - Train: {len(train_samples)} images")
+    print(f"   - Val: {len(val_samples)} images")
+    print(f"   - Total: {len(all_samples)} images")
+
+    # 샘플 확인
+    print(f"\n📝 샘플 라벨 확인 (Train 첫 번째):")
+    first_label = next(train_label_dir.glob("*.txt"))
+    with open(first_label, 'r') as f:
+        content = f.read()
+        print(f"   {first_label.name}:")
+        for line in content.strip().split('\n'):
+            print(f"      {line}")
+
+    print(f"\n🎯 다음 단계: YOLOv8 학습 실행")
+    print(f"   python train_yolo.py")
+
+if __name__ == "__main__":
+    main()

debug_roboflow_api.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+"""
+Roboflow API 응답 디버깅
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+from inference_sdk import InferenceHTTPClient
+import json
+
+# Roboflow 클라이언트
+client = InferenceHTTPClient(
+    api_url="https://serverless.roboflow.com",
+    api_key="azcIL8KDJVJMYrsERzI7"
+)
+
+# 테스트 이미지
+test_image = "data/yolo_dataset/images/train/250818_01.jpg"
+
+print("="*60)
+print("🔍 Roboflow API 응답 디버깅")
+print("="*60)
+print(f"\n📸 이미지: {test_image}")
+print(f"🔗 Workflow: vidraft/find-shrimp-6")
+
+# API 호출
+result = client.run_workflow(
+    workspace_name="vidraft",
+    workflow_id="find-shrimp-6",
+    images={"image": test_image},
+    use_cache=False  # 캐시 비활성화
+)
+
+print(f"\n📦 전체 응답 구조:")
+print(json.dumps(result, indent=2, ensure_ascii=False))
+
+print(f"\n{'='*60}")
+print("✅ 디버깅 완료")

ground_truth.json

@@ -1211,5 +1211,115 @@
       ],
       "folder": "251007"
     }
+  ],
+  "251007_03.jpg": [
+    {
+      "bbox": [
+        241.99429035186768,
+        293.28845500946045,
+        350.4645299911499,
+        806.7023754119873
+      ],
+      "folder": "251007"
+    }
+  ],
+  "251007_04.jpg": [
+    {
+      "bbox": [
+        466.5386486053467,
+        241.44012212753296,
+        999.3045139312744,
+        330.7358407974243
+      ],
+      "folder": "251007"
+    }
+  ],
+  "251007_05.jpg": [
+    {
+      "bbox": [
+        509.04098987579346,
+        300.90571880340576,
+        922.2488784790039,
+        369.85572814941406
+      ],
+      "folder": "251007"
+    }
+  ],
+  "251007_06.jpg": [
+    {
+      "bbox": [
+        551.3954639434814,
+        234.11472082138062,
+        945.5917358398438,
+        325.4259395599365
+      ],
+      "folder": "251007"
+    }
+  ],
+  "251007_07.jpg": [
+    {
+      "bbox": [
+        518.1720066070557,
+        258.2105827331543,
+        1216.37056350708,
+        378.3600950241089
+      ],
+      "folder": "251007"
+    }
+  ],
+  "251007_08.jpg": [
+    {
+      "bbox": [
+        542.6454305648804,
+        152.6955008506775,
+        1012.4309158325195,
+        244.41664218902588
+      ],
+      "folder": "251007"
+    }
+  ],
+  "251007_09.jpg": [
+    {
+      "bbox": [
+        408.89760971069336,
+        284.97180938720703,
+        968.8659000396729,
+        380.16117095947266
+      ],
+      "folder": "251007"
+    }
+  ],
+  "251007_10.jpg": [
+    {
+      "bbox": [
+        453.19141387939453,
+        234.03351068496704,
+        1054.6015739440918,
+        364.84920501708984
+      ],
+      "folder": "251007"
+    }
+  ],
+  "251002_01.jpg": [
+    {
+      "bbox": [
+        580.7671642303467,
+        355.0561571121216,
+        697.6516151428223,
+        914.4206619262695
+      ],
+      "folder": "251002"
+    }
+  ],
+  "251002_02.jpg": [
+    {
+      "bbox": [
+        387.40245819091797,
+        441.32769107818604,
+        501.0829973220825,
+        1040.6700134277344
+      ],
+      "folder": "251002"
+    }
   ]
 }

optimize_yolov8_confidence.py

@@ -0,0 +1,217 @@
+"""
+YOLOv8m Confidence Threshold 최적화
+Ground Truth 기반으로 최적 confidence 값 탐색
+"""
+from ultralytics import YOLO
+from PIL import Image
+import json
+import os
+import glob
+import numpy as np
+
+# 학습된 모델 로드
+MODEL_PATH = "runs/train/yolov8m_shrimp2/weights/best.pt"
+model = YOLO(MODEL_PATH)
+
+print(f"✅ YOLOv8m 모델 로드 완료: {MODEL_PATH}")
+
+# Ground Truth 로드
+GT_FILE = "ground_truth.json"
+with open(GT_FILE, 'r', encoding='utf-8') as f:
+    ground_truth = json.load(f)
+
+print(f"✅ Ground Truth 로드: {GT_FILE}")
+
+# GT 통계
+total_gt = sum(len(gts) for gts in ground_truth.values() if gts)
+gt_images = [k for k, v in ground_truth.items() if v]
+print(f"   - GT가 있는 이미지: {len(gt_images)}장")
+print(f"   - 총 GT 객체: {total_gt}개")
+print("-" * 60)
+
+def calculate_iou(box1, box2):
+    """IoU 계산"""
+    x1_min, y1_min, x1_max, y1_max = box1
+    x2_min, y2_min, x2_max, y2_max = box2
+
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+    box1_area = (x1_max - x1_min) * (y1_max - y1_min)
+    box2_area = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = box1_area + box2_area - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+
+def evaluate_confidence_threshold(conf_threshold, iou_threshold=0.5):
+    """특정 confidence threshold에서 성능 평가"""
+    tp = 0  # True Positive
+    fp = 0  # False Positive
+    fn = 0  # False Negative
+
+    matched_gt_count = 0
+    total_gt_count = 0
+
+    # GT가 있는 이미지만 테스트
+    for img_name in gt_images:
+        # 이미지 경로 찾기
+        img_path = None
+        for split in ['train', 'val']:
+            search_path = f"data/yolo_dataset/images/{split}/{img_name}"
+            if os.path.exists(search_path):
+                img_path = search_path
+                break
+
+        if not img_path:
+            # 파일명에서 -1 제거해서 다시 시도
+            base_name = img_name.replace('-1.jpg', '.jpg')
+            for split in ['train', 'val']:
+                search_path = f"data/yolo_dataset/images/{split}/{base_name}"
+                if os.path.exists(search_path):
+                    img_path = search_path
+                    break
+
+        if not img_path or not os.path.exists(img_path):
+            continue
+
+        # 이미지 로드
+        image = Image.open(img_path)
+
+        # YOLOv8 검출
+        results = model.predict(
+            source=image,
+            conf=conf_threshold,
+            iou=0.7,
+            device=0,
+            verbose=False
+        )
+
+        # 결과 파싱
+        result = results[0]
+        boxes = result.boxes
+
+        predictions = []
+        if boxes is not None and len(boxes) > 0:
+            for box in boxes:
+                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+                confidence = box.conf[0].cpu().item()
+                predictions.append({
+                    'bbox': [float(x1), float(y1), float(x2), float(y2)],
+                    'confidence': confidence
+                })
+
+        # Ground Truth
+        gt_boxes = ground_truth[img_name]
+        total_gt_count += len(gt_boxes)
+
+        # GT와 매칭
+        matched_gt = set()
+        matched_pred = set()
+
+        for pred_idx, pred in enumerate(predictions):
+            best_iou = 0
+            best_gt_idx = -1
+
+            for gt_idx, gt in enumerate(gt_boxes):
+                if gt_idx in matched_gt:
+                    continue
+
+                iou = calculate_iou(pred['bbox'], gt['bbox'])
+                if iou > best_iou:
+                    best_iou = iou
+                    best_gt_idx = gt_idx
+
+            if best_iou >= iou_threshold:
+                tp += 1
+                matched_gt.add(best_gt_idx)
+                matched_pred.add(pred_idx)
+            else:
+                fp += 1
+
+        # 매칭되지 않은 GT = False Negative
+        fn += len(gt_boxes) - len(matched_gt)
+        matched_gt_count += len(matched_gt)
+
+    # 성능 지표 계산
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
+    f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+    return {
+        'tp': tp,
+        'fp': fp,
+        'fn': fn,
+        'precision': precision,
+        'recall': recall,
+        'f1': f1,
+        'matched_gt': matched_gt_count,
+        'total_gt': total_gt_count,
+        'gt_match_rate': matched_gt_count / total_gt_count if total_gt_count > 0 else 0
+    }
+
+# Confidence threshold sweep
+print("\n🔍 Confidence Threshold 최적화 시작...\n")
+
+confidence_thresholds = [0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8]
+results = []
+
+for conf in confidence_thresholds:
+    metrics = evaluate_confidence_threshold(conf)
+    results.append({
+        'confidence': conf,
+        **metrics
+    })
+
+    print(f"Conf {conf:.2f}: P={metrics['precision']:.1%} R={metrics['recall']:.1%} F1={metrics['f1']:.1%} | "
+          f"GT매칭={metrics['matched_gt']}/{metrics['total_gt']} ({metrics['gt_match_rate']:.1%})")
+
+# 최적값 찾기
+best_f1 = max(results, key=lambda x: x['f1'])
+best_recall = max(results, key=lambda x: x['recall'])
+best_precision = max(results, key=lambda x: x['precision'])
+best_gt_match = max(results, key=lambda x: x['gt_match_rate'])
+
+print("\n" + "=" * 60)
+print("📊 최적화 결과:")
+print("=" * 60)
+
+print(f"\n1️⃣ 최고 F1 Score: {best_f1['f1']:.1%} (Confidence={best_f1['confidence']:.2f})")
+print(f"   - Precision: {best_f1['precision']:.1%}")
+print(f"   - Recall: {best_f1['recall']:.1%}")
+print(f"   - GT 매칭: {best_f1['matched_gt']}/{best_f1['total_gt']} ({best_f1['gt_match_rate']:.1%})")
+
+print(f"\n2️⃣ 최고 Recall: {best_recall['recall']:.1%} (Confidence={best_recall['confidence']:.2f})")
+print(f"   - F1 Score: {best_recall['f1']:.1%}")
+print(f"   - Precision: {best_recall['precision']:.1%}")
+
+print(f"\n3️⃣ 최고 Precision: {best_precision['precision']:.1%} (Confidence={best_precision['confidence']:.2f})")
+print(f"   - F1 Score: {best_precision['f1']:.1%}")
+print(f"   - Recall: {best_precision['recall']:.1%}")
+
+print(f"\n4️⃣ 최고 GT 매칭률: {best_gt_match['gt_match_rate']:.1%} (Confidence={best_gt_match['confidence']:.2f})")
+print(f"   - F1 Score: {best_gt_match['f1']:.1%}")
+print(f"   - 매칭: {best_gt_match['matched_gt']}/{best_gt_match['total_gt']}")
+
+print("\n💡 권장 설정:")
+print(f"   - 균형잡힌 성능: confidence={best_f1['confidence']:.2f} (F1={best_f1['f1']:.1%})")
+print(f"   - 높은 재현율: confidence={best_recall['confidence']:.2f} (Recall={best_recall['recall']:.1%})")
+
+# 결과 저장
+output_file = "yolov8m_confidence_optimization.json"
+with open(output_file, 'w', encoding='utf-8') as f:
+    json.dump({
+        'best_f1': best_f1,
+        'best_recall': best_recall,
+        'best_precision': best_precision,
+        'best_gt_match': best_gt_match,
+        'all_results': results
+    }, f, indent=2, ensure_ascii=False)
+
+print(f"\n💾 결과 저장: {output_file}")
+print("=" * 60)

optimize_yolov8_confidence_val_only.py

@@ -0,0 +1,204 @@
+"""
+YOLOv8m Confidence Threshold 최적화 (Validation Set만 사용)
+과적합 방지를 위해 Val set 10장만으로 평가
+"""
+from ultralytics import YOLO
+from PIL import Image
+import json
+import os
+
+# 학습된 모델 로드
+MODEL_PATH = "runs/train/yolov8m_shrimp2/weights/best.pt"
+model = YOLO(MODEL_PATH)
+
+print(f"✅ YOLOv8m 모델 로드 완료: {MODEL_PATH}")
+
+# Ground Truth 로드
+GT_FILE = "ground_truth.json"
+with open(GT_FILE, 'r', encoding='utf-8') as f:
+    ground_truth = json.load(f)
+
+# Val set 이미지만 필터링
+val_images = set(os.listdir('data/yolo_dataset/images/val'))
+gt_val_only = {}
+
+for img_name, gts in ground_truth.items():
+    if not gts:
+        continue
+    base_name = img_name.replace('-1.jpg', '.jpg')
+    if img_name in val_images or base_name in val_images:
+        gt_val_only[img_name] = gts
+
+print(f"✅ Ground Truth (Val set만): {len(gt_val_only)}장")
+total_gt = sum(len(gts) for gts in gt_val_only.values())
+print(f"   - 총 GT 객체: {total_gt}개")
+print("-" * 60)
+
+def calculate_iou(box1, box2):
+    """IoU 계산"""
+    x1_min, y1_min, x1_max, y1_max = box1
+    x2_min, y2_min, x2_max, y2_max = box2
+
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+    box1_area = (x1_max - x1_min) * (y1_max - y1_min)
+    box2_area = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = box1_area + box2_area - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+
+def evaluate_confidence_threshold(conf_threshold, iou_threshold=0.5):
+    """특정 confidence threshold에서 성능 평가 (Val set만)"""
+    tp = 0
+    fp = 0
+    fn = 0
+
+    matched_gt_count = 0
+    total_gt_count = 0
+
+    for img_name, gt_boxes in gt_val_only.items():
+        # 이미지 경로
+        img_path = f"data/yolo_dataset/images/val/{img_name}"
+        base_name = img_name.replace('-1.jpg', '.jpg')
+        if not os.path.exists(img_path):
+            img_path = f"data/yolo_dataset/images/val/{base_name}"
+
+        if not os.path.exists(img_path):
+            continue
+
+        # 이미지 로드
+        image = Image.open(img_path)
+
+        # YOLOv8 검출
+        results = model.predict(
+            source=image,
+            conf=conf_threshold,
+            iou=0.7,
+            device=0,
+            verbose=False
+        )
+
+        result = results[0]
+        boxes = result.boxes
+
+        predictions = []
+        if boxes is not None and len(boxes) > 0:
+            for box in boxes:
+                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+                confidence = box.conf[0].cpu().item()
+                predictions.append({
+                    'bbox': [float(x1), float(y1), float(x2), float(y2)],
+                    'confidence': confidence
+                })
+
+        total_gt_count += len(gt_boxes)
+
+        # GT와 매칭
+        matched_gt = set()
+        matched_pred = set()
+
+        for pred_idx, pred in enumerate(predictions):
+            best_iou = 0
+            best_gt_idx = -1
+
+            for gt_idx, gt in enumerate(gt_boxes):
+                if gt_idx in matched_gt:
+                    continue
+
+                iou = calculate_iou(pred['bbox'], gt['bbox'])
+                if iou > best_iou:
+                    best_iou = iou
+                    best_gt_idx = gt_idx
+
+            if best_iou >= iou_threshold:
+                tp += 1
+                matched_gt.add(best_gt_idx)
+                matched_pred.add(pred_idx)
+            else:
+                fp += 1
+
+        fn += len(gt_boxes) - len(matched_gt)
+        matched_gt_count += len(matched_gt)
+
+    # 성능 지표 계산
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
+    f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+    return {
+        'tp': tp,
+        'fp': fp,
+        'fn': fn,
+        'precision': precision,
+        'recall': recall,
+        'f1': f1,
+        'matched_gt': matched_gt_count,
+        'total_gt': total_gt_count,
+        'gt_match_rate': matched_gt_count / total_gt_count if total_gt_count > 0 else 0
+    }
+
+# Confidence threshold sweep
+print("\n🔍 Confidence Threshold 최적화 (Val set만)...\n")
+
+confidence_thresholds = [0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9]
+results = []
+
+for conf in confidence_thresholds:
+    metrics = evaluate_confidence_threshold(conf)
+    results.append({
+        'confidence': conf,
+        **metrics
+    })
+
+    print(f"Conf {conf:.2f}: P={metrics['precision']:.1%} R={metrics['recall']:.1%} F1={metrics['f1']:.1%} | "
+          f"GT매칭={metrics['matched_gt']}/{metrics['total_gt']} ({metrics['gt_match_rate']:.1%})")
+
+# 최적값 찾기
+best_f1 = max(results, key=lambda x: x['f1'])
+best_recall = max(results, key=lambda x: x['recall'])
+best_precision = max(results, key=lambda x: x['precision'])
+
+print("\n" + "=" * 60)
+print("📊 최적화 결과 (Val set만, 과적합 없음):")
+print("=" * 60)
+
+print(f"\n1️⃣ 최고 F1 Score: {best_f1['f1']:.1%} (Confidence={best_f1['confidence']:.2f})")
+print(f"   - Precision: {best_f1['precision']:.1%}")
+print(f"   - Recall: {best_f1['recall']:.1%}")
+print(f"   - GT 매칭: {best_f1['matched_gt']}/{best_f1['total_gt']} ({best_f1['gt_match_rate']:.1%})")
+
+print(f"\n2️⃣ 최고 Recall: {best_recall['recall']:.1%} (Confidence={best_recall['confidence']:.2f})")
+print(f"   - F1 Score: {best_recall['f1']:.1%}")
+print(f"   - Precision: {best_recall['precision']:.1%}")
+
+print(f"\n3️⃣ 최고 Precision: {best_precision['precision']:.1%} (Confidence={best_precision['confidence']:.2f})")
+print(f"   - F1 Score: {best_precision['f1']:.1%}")
+print(f"   - Recall: {best_precision['recall']:.1%}")
+
+print("\n💡 권장 설정 (Val set 기준, 일반화 성능):")
+print(f"   - 최적 confidence: {best_f1['confidence']:.2f}")
+print(f"   - F1 Score: {best_f1['f1']:.1%}")
+print(f"   - Precision: {best_f1['precision']:.1%}, Recall: {best_f1['recall']:.1%}")
+
+# 결과 저장
+output_file = "yolov8m_confidence_optimization_val_only.json"
+with open(output_file, 'w', encoding='utf-8') as f:
+    json.dump({
+        'dataset': 'validation_set_only',
+        'num_images': len(gt_val_only),
+        'total_gt': total_gt,
+        'best_f1': best_f1,
+        'best_recall': best_recall,
+        'best_precision': best_precision,
+        'all_results': results
+    }, f, indent=2, ensure_ascii=False)
+
+print(f"\n💾 결과 저장: {output_file}")
+print("=" * 60)

quick_test_roboflow.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+"""
+Roboflow 모델 빠른 테스트
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import requests
+import base64
+from PIL import Image
+from io import BytesIO
+import json
+
+# 테스트 이미지
+test_image = "data/yolo_dataset/images/train/250818_04.jpg"
+
+print("="*60)
+print("🦐 Roboflow 모델 빠른 테스트")
+print("="*60)
+print(f"📸 이미지: {test_image}\n")
+
+# 이미지 로드 및 리사이즈
+image = Image.open(test_image)
+print(f"원본 크기: {image.size}")
+
+image.thumbnail((640, 640), Image.Resampling.LANCZOS)
+print(f"리사이즈: {image.size}")
+
+# Base64 인코딩
+buffered = BytesIO()
+image.save(buffered, format="JPEG", quality=80)
+img_base64 = base64.b64encode(buffered.getvalue()).decode()
+
+# API 호출
+print(f"\n🔄 API 호출 중...\n")
+response = requests.post(
+    'https://serverless.roboflow.com/vidraft/workflows/find-shrimp-6',
+    headers={'Content-Type': 'application/json'},
+    json={
+        'api_key': 'azcIL8KDJVJMYrsERzI7',
+        'inputs': {
+            'image': {'type': 'base64', 'value': img_base64}
+        }
+    },
+    timeout=30
+)
+
+if response.status_code != 200:
+    print(f"❌ 오류: {response.status_code}")
+    print(response.text)
+    exit(1)
+
+result = response.json()
+
+# predictions 추출
+predictions = []
+if 'outputs' in result and len(result['outputs']) > 0:
+    output = result['outputs'][0]
+    if 'predictions' in output:
+        pred_data = output['predictions']
+        if isinstance(pred_data, dict) and 'predictions' in pred_data:
+            predictions = pred_data['predictions']
+
+print(f"{'='*60}")
+print(f"📊 검출 결과")
+print(f"{'='*60}\n")
+
+print(f"총 검출 수: {len(predictions)}개\n")
+
+# 상세 결과
+for i, pred in enumerate(predictions, 1):
+    cls = pred.get('class', 'unknown')
+    conf = pred.get('confidence', 0)
+    x = pred.get('x', 0)
+    y = pred.get('y', 0)
+    w = pred.get('width', 0)
+    h = pred.get('height', 0)
+
+    print(f"{i}. 클래스: {cls}")
+    print(f"   신뢰도: {conf:.1%}")
+    print(f"   위치: ({x:.0f}, {y:.0f})")
+    print(f"   크기: {w:.0f} x {h:.0f}")
+    print()
+
+# shrimp만 필터링
+shrimp_count = sum(1 for p in predictions if p.get('class') == 'shrimp')
+print(f"{'='*60}")
+print(f"✅ shrimp 클래스: {shrimp_count}개")
+print(f"{'='*60}")

quick_test_save_result.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+"""
+Roboflow 모델 빠른 테스트 + 결과 이미지 저장
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import requests
+import base64
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import json
+
+# 테스트 이미지
+test_image = "data/yolo_dataset/images/train/250818_04.jpg"
+
+print("="*60)
+print("🦐 Roboflow 모델 테스트 + 결과 저장")
+print("="*60)
+print(f"📸 이미지: {test_image}\n")
+
+# 원본 이미지 로드
+image_original = Image.open(test_image)
+original_size = image_original.size
+print(f"원본 크기: {original_size}")
+
+# 리사이즈 (API 전송용)
+image_resized = image_original.copy()
+image_resized.thumbnail((640, 640), Image.Resampling.LANCZOS)
+print(f"리사이즈: {image_resized.size}")
+
+# Base64 인코딩
+buffered = BytesIO()
+image_resized.save(buffered, format="JPEG", quality=80)
+img_base64 = base64.b64encode(buffered.getvalue()).decode()
+
+# API 호출
+print(f"\n🔄 API 호출 중...\n")
+response = requests.post(
+    'https://serverless.roboflow.com/vidraft/workflows/find-shrimp-6',
+    headers={'Content-Type': 'application/json'},
+    json={
+        'api_key': 'azcIL8KDJVJMYrsERzI7',
+        'inputs': {
+            'image': {'type': 'base64', 'value': img_base64}
+        }
+    },
+    timeout=30
+)
+
+if response.status_code != 200:
+    print(f"❌ 오류: {response.status_code}")
+    exit(1)
+
+result = response.json()
+
+# predictions 추출
+predictions = []
+if 'outputs' in result and len(result['outputs']) > 0:
+    output = result['outputs'][0]
+    if 'predictions' in output:
+        pred_data = output['predictions']
+        if isinstance(pred_data, dict) and 'predictions' in pred_data:
+            predictions = pred_data['predictions']
+
+print(f"📊 검출 수: {len(predictions)}개\n")
+
+# 원본 이미지에 박스 그리기
+draw = ImageDraw.Draw(image_original)
+
+# 스케일 계산 (리사이즈된 좌표 → 원본 좌표)
+scale_x = original_size[0] / image_resized.size[0]
+scale_y = original_size[1] / image_resized.size[1]
+
+shrimp_count = 0
+
+for i, pred in enumerate(predictions, 1):
+    cls = pred.get('class', 'unknown')
+    conf = pred.get('confidence', 0)
+    x = pred.get('x', 0) * scale_x
+    y = pred.get('y', 0) * scale_y
+    w = pred.get('width', 0) * scale_x
+    h = pred.get('height', 0) * scale_y
+
+    print(f"{i}. 클래스: {cls}, 신뢰도: {conf:.1%}")
+
+    # shrimp만 그리기
+    if cls == 'shrimp':
+        shrimp_count += 1
+
+        # 박스 좌표
+        x1 = x - w / 2
+        y1 = y - h / 2
+        x2 = x + w / 2
+        y2 = y + h / 2
+
+        # 신뢰도별 색상
+        if conf >= 0.5:
+            color = 'lime'
+        elif conf >= 0.3:
+            color = 'yellow'
+        else:
+            color = 'orange'
+
+        # 박스 그리기
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=8)
+
+        # 텍스트
+        text = f"#{shrimp_count} {conf:.1%}"
+        try:
+            font = ImageFont.truetype("arial.ttf", 50)
+        except:
+            font = ImageFont.load_default()
+
+        # 텍스트 배경
+        text_bbox = draw.textbbox((x1, y1-60), text, font=font)
+        draw.rectangle(text_bbox, fill=color)
+        draw.text((x1, y1-60), text, fill='black', font=font)
+
+# 결과 저장
+output_path = "quick_test_result.jpg"
+image_original.save(output_path, quality=95)
+
+print(f"\n{'='*60}")
+print(f"✅ shrimp 검출: {shrimp_count}개")
+print(f"💾 결과 저장: {output_path}")
+print(f"{'='*60}")

test_10_images.py

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+"""
+Roboflow 모델 10개 이미지 테스트
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import requests
+import base64
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import json
+import glob
+import os
+from datetime import datetime
+
+def test_image(image_path):
+    """단일 이미지 테스트"""
+    # 원본 이미지 로드
+    image_original = Image.open(image_path)
+    original_size = image_original.size
+
+    # 리사이즈 (API 전송용)
+    image_resized = image_original.copy()
+    image_resized.thumbnail((640, 640), Image.Resampling.LANCZOS)
+
+    # Base64 인코딩
+    buffered = BytesIO()
+    image_resized.save(buffered, format="JPEG", quality=80)
+    img_base64 = base64.b64encode(buffered.getvalue()).decode()
+
+    # API 호출
+    response = requests.post(
+        'https://serverless.roboflow.com/vidraft/workflows/find-shrimp-6',
+        headers={'Content-Type': 'application/json'},
+        json={
+            'api_key': 'azcIL8KDJVJMYrsERzI7',
+            'inputs': {
+                'image': {'type': 'base64', 'value': img_base64}
+            }
+        },
+        timeout=30
+    )
+
+    if response.status_code != 200:
+        return None
+
+    result = response.json()
+
+    # predictions 추출
+    predictions = []
+    if 'outputs' in result and len(result['outputs']) > 0:
+        output = result['outputs'][0]
+        if 'predictions' in output:
+            pred_data = output['predictions']
+            if isinstance(pred_data, dict) and 'predictions' in pred_data:
+                predictions = pred_data['predictions']
+
+    # 스케일 계산
+    scale_x = original_size[0] / image_resized.size[0]
+    scale_y = original_size[1] / image_resized.size[1]
+
+    # shrimp만 필터링
+    shrimp_predictions = [p for p in predictions if p.get('class') == 'shrimp']
+
+    return {
+        'original': image_original,
+        'predictions': shrimp_predictions,
+        'scale_x': scale_x,
+        'scale_y': scale_y
+    }
+
+def draw_result(image, predictions, scale_x, scale_y):
+    """결과 그리기"""
+    draw = ImageDraw.Draw(image)
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 50)
+    except:
+        font = ImageFont.load_default()
+
+    for i, pred in enumerate(predictions, 1):
+        conf = pred.get('confidence', 0)
+        x = pred.get('x', 0) * scale_x
+        y = pred.get('y', 0) * scale_y
+        w = pred.get('width', 0) * scale_x
+        h = pred.get('height', 0) * scale_y
+
+        # 박스 좌표
+        x1 = x - w / 2
+        y1 = y - h / 2
+        x2 = x + w / 2
+        y2 = y + h / 2
+
+        # 신뢰도별 색상
+        if conf >= 0.5:
+            color = 'lime'
+        elif conf >= 0.3:
+            color = 'yellow'
+        else:
+            color = 'orange'
+
+        # 박스 그리기
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=8)
+
+        # 텍스트
+        text = f"#{i} {conf:.1%}"
+        text_bbox = draw.textbbox((x1, y1-60), text, font=font)
+        draw.rectangle(text_bbox, fill=color)
+        draw.text((x1, y1-60), text, fill='black', font=font)
+
+    return image
+
+def main():
+    print("="*60)
+    print("🦐 Roboflow 모델 10개 이미지 테스트")
+    print("="*60)
+
+    # 테스트 이미지 선택
+    image_dir = "data/yolo_dataset/images/train"
+    all_images = sorted(glob.glob(os.path.join(image_dir, "*.jpg")))
+
+    # roboflow_result가 아닌 원본 이미지만 선택
+    test_images = [img for img in all_images if 'roboflow_result' not in img][:10]
+
+    if len(test_images) < 10:
+        print(f"⚠️  이미지 부족: {len(test_images)}개만 발견")
+        test_images = test_images[:len(test_images)]
+
+    print(f"\n📁 이미지 경로: {image_dir}")
+    print(f"📊 테스트 이미지 수: {len(test_images)}개\n")
+
+    # 출력 디렉토리 생성
+    output_dir = "test_results_10"
+    os.makedirs(output_dir, exist_ok=True)
+
+    results_summary = []
+
+    for idx, img_path in enumerate(test_images, 1):
+        img_name = os.path.basename(img_path)
+        print(f"[{idx}/{len(test_images)}] {img_name} 처리 중...", end=" ")
+
+        try:
+            # 테스트
+            result = test_image(img_path)
+
+            if result is None:
+                print("❌ API 오류")
+                continue
+
+            predictions = result['predictions']
+            shrimp_count = len(predictions)
+
+            # 결과 그리기
+            image_with_boxes = draw_result(
+                result['original'],
+                predictions,
+                result['scale_x'],
+                result['scale_y']
+            )
+
+            # 저장
+            output_filename = img_name.replace('.jpg', '_roboflow_result.jpg')
+            output_path = os.path.join(output_dir, output_filename)
+            image_with_boxes.save(output_path, quality=95)
+
+            print(f"✅ shrimp {shrimp_count}개")
+
+            results_summary.append({
+                'image': img_name,
+                'shrimp_count': shrimp_count,
+                'output': output_path,
+                'confidences': [p.get('confidence', 0) for p in predictions]
+            })
+
+        except Exception as e:
+            print(f"❌ 오류: {str(e)}")
+
+    # 요약
+    print(f"\n{'='*60}")
+    print("📊 테스트 요약")
+    print(f"{'='*60}\n")
+
+    total_shrimp = sum(r['shrimp_count'] for r in results_summary)
+    avg_shrimp = total_shrimp / len(results_summary) if results_summary else 0
+
+    print(f"총 처리 이미지: {len(results_summary)}개")
+    print(f"총 shrimp 검출: {total_shrimp}개")
+    print(f"평균: {avg_shrimp:.1f}개/이미지\n")
+
+    print("이미지별 결과:")
+    for r in results_summary:
+        avg_conf = sum(r['confidences']) / len(r['confidences']) if r['confidences'] else 0
+        print(f"  {r['image']}: {r['shrimp_count']}개 (평균 신뢰도: {avg_conf:.1%})")
+
+    print(f"\n✅ 완료! 결과는 {output_dir}/ 폴더에 저장되었습니다.")
+
+    # JSON 저장
+    json_path = os.path.join(output_dir, f"test_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(results_summary, f, indent=2, ensure_ascii=False)
+    print(f"📄 JSON 저장: {json_path}")
+
+if __name__ == "__main__":
+    main()

test_curl_roboflow.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+"""
+간단한 Roboflow API 테스트 (requests 사용)
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import requests
+import base64
+from PIL import Image
+from io import BytesIO
+import json
+
+# 테스트 이미지
+test_image = "data/yolo_dataset/images/train/250818_01.jpg"
+
+print("="*60)
+print("🔍 Roboflow API 테스트 (requests)")
+print("="*60)
+
+# 이미지를 base64로 인코딩
+image = Image.open(test_image)
+print(f"📸 이미지: {test_image}")
+print(f"🖼️  크기: {image.size}")
+
+# 리사이즈
+image.thumbnail((640, 640), Image.Resampling.LANCZOS)
+print(f"📐 리사이즈: {image.size}")
+
+buffered = BytesIO()
+image.save(buffered, format="JPEG", quality=80)
+img_base64 = base64.b64encode(buffered.getvalue()).decode()
+
+print(f"📦 Base64 크기: {len(img_base64)} bytes")
+
+# API 요청
+print(f"\n🔄 API 호출 중...")
+
+try:
+    response = requests.post(
+        'https://serverless.roboflow.com/vidraft/workflows/find-shrimp-6',
+        headers={'Content-Type': 'application/json'},
+        json={
+            'api_key': 'azcIL8KDJVJMYrsERzI7',
+            'inputs': {
+                'image': {'type': 'base64', 'value': img_base64}
+            }
+        },
+        timeout=30
+    )
+
+    print(f"📡 응답 코드: {response.status_code}")
+
+    if response.status_code == 200:
+        result = response.json()
+        print(f"\n📦 응답 구조:")
+        print(json.dumps(result, indent=2, ensure_ascii=False)[:2000])
+
+        # predictions 추출 시도
+        if 'outputs' in result:
+            print(f"\n✅ outputs 발견: {len(result['outputs'])}개")
+            if len(result['outputs']) > 0:
+                output = result['outputs'][0]
+                print(f"📦 output[0] keys: {output.keys()}")
+                if 'predictions' in output:
+                    pred_data = output['predictions']
+                    print(f"📦 predictions type: {type(pred_data)}")
+                    if isinstance(pred_data, dict):
+                        print(f"📦 predictions keys: {pred_data.keys()}")
+                        if 'predictions' in pred_data:
+                            preds = pred_data['predictions']
+                            print(f"✅ 최종 predictions: {len(preds)}개")
+    else:
+        print(f"❌ 오류: {response.text}")
+
+except Exception as e:
+    print(f"❌ 예외 발생: {str(e)}")
+    import traceback
+    traceback.print_exc()
+
+print(f"\n{'='*60}")
+print("✅ 테스트 완료")

test_parameter_sweep.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+"""
+파라미터 그리드 서치
+최적의 confidence threshold와 filter threshold 조합 찾기
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import os
+import json
+import numpy as np
+from datetime import datetime
+import matplotlib.pyplot as plt
+import seaborn as sns
+from test_quantitative_evaluation import (
+    load_ground_truth,
+    load_rtdetr_model,
+    detect_with_rtdetr,
+    apply_universal_filter,
+    evaluate_detection
+)
+from PIL import Image
+
+def run_parameter_sweep(
+    test_image_dir,
+    ground_truth_path,
+    confidence_values,
+    filter_values,
+    iou_threshold=0.5
+):
+    """파라미터 그리드 서치 실행"""
+    print("\n" + "="*70)
+    print("🔍 파라미터 그리드 서치 시작")
+    print("="*70)
+
+    # Ground truth 로드
+    ground_truths = load_ground_truth(ground_truth_path)
+    if not ground_truths:
+        return
+
+    # 모델 로드 (한 번만)
+    processor, model = load_rtdetr_model()
+
+    # 결과 저장
+    results_grid = {}
+    best_f1 = 0
+    best_config = None
+
+    print(f"\n📊 테스트 범위:")
+    print(f"   Confidence: {confidence_values}")
+    print(f"   Filter Threshold: {filter_values}")
+    print(f"   총 {len(confidence_values) * len(filter_values)}개 조합 테스트\n")
+
+    total_tests = len(confidence_values) * len(filter_values)
+    current_test = 0
+
+    # 그리드 서치
+    for conf in confidence_values:
+        results_grid[conf] = {}
+
+        for filt in filter_values:
+            current_test += 1
+            print(f"\n[{current_test}/{total_tests}] 테스트 중: Conf={conf}, Filter={filt}")
+
+            metrics_list = []
+
+            for filename, gt_list in ground_truths.items():
+                # 이미지 경로 구성
+                if gt_list and 'folder' in gt_list[0]:
+                    folder = gt_list[0]['folder']
+                    img_path = os.path.join(test_image_dir, folder, filename)
+                else:
+                    img_path = os.path.join(test_image_dir, filename)
+
+                if not os.path.exists(img_path):
+                    continue
+
+                # 검출
+                image = Image.open(img_path).convert('RGB')
+                all_detections = detect_with_rtdetr(image, processor, model, conf)
+                filtered_detections = apply_universal_filter(all_detections, image, filt)
+
+                # 평가
+                metrics = evaluate_detection(filtered_detections, gt_list, iou_threshold)
+                metrics_list.append(metrics)
+
+            # 평균 계산
+            if metrics_list:
+                avg_precision = np.mean([m['precision'] for m in metrics_list])
+                avg_recall = np.mean([m['recall'] for m in metrics_list])
+                avg_f1 = np.mean([m['f1'] for m in metrics_list])
+
+                results_grid[conf][filt] = {
+                    'precision': avg_precision,
+                    'recall': avg_recall,
+                    'f1': avg_f1
+                }
+
+                print(f"   → P={avg_precision:.2%}, R={avg_recall:.2%}, F1={avg_f1:.2%}")
+
+                # 최고 성능 업데이트
+                if avg_f1 > best_f1:
+                    best_f1 = avg_f1
+                    best_config = {
+                        'confidence': conf,
+                        'filter_threshold': filt,
+                        'metrics': {
+                            'precision': avg_precision,
+                            'recall': avg_recall,
+                            'f1': avg_f1
+                        }
+                    }
+
+    # 결과 저장
+    output_dir = f"test_results/parameter_sweep_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    os.makedirs(output_dir, exist_ok=True)
+
+    # JSON 저장
+    summary = {
+        'test_range': {
+            'confidence': confidence_values,
+            'filter_threshold': filter_values,
+            'iou_threshold': iou_threshold
+        },
+        'best_config': best_config,
+        'all_results': results_grid
+    }
+
+    json_path = os.path.join(output_dir, 'sweep_results.json')
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(summary, f, ensure_ascii=False, indent=2)
+
+    print("\n" + "="*70)
+    print("🏆 최고 성능 설정")
+    print("="*70)
+    print(f"Confidence Threshold: {best_config['confidence']}")
+    print(f"Filter Threshold: {best_config['filter_threshold']}")
+    print(f"Precision: {best_config['metrics']['precision']:.2%}")
+    print(f"Recall: {best_config['metrics']['recall']:.2%}")
+    print(f"F1 Score: {best_config['metrics']['f1']:.2%}")
+    print("="*70)
+
+    # 히트맵 생성
+    generate_heatmaps(results_grid, confidence_values, filter_values, output_dir)
+
+    print(f"\n📄 결과 저장: {json_path}")
+    print(f"📊 히트맵 저장: {output_dir}")
+
+    return best_config, results_grid
+
+
+def generate_heatmaps(results_grid, conf_values, filt_values, output_dir):
+    """성능 히트��� 생성"""
+    metrics = ['precision', 'recall', 'f1']
+    metric_names = {
+        'precision': 'Precision (정밀도)',
+        'recall': 'Recall (재현율)',
+        'f1': 'F1 Score'
+    }
+
+    for metric in metrics:
+        # 데이터 행렬 생성
+        data = np.zeros((len(conf_values), len(filt_values)))
+
+        for i, conf in enumerate(conf_values):
+            for j, filt in enumerate(filt_values):
+                if conf in results_grid and filt in results_grid[conf]:
+                    data[i, j] = results_grid[conf][filt][metric]
+
+        # 히트맵 그리기
+        plt.figure(figsize=(12, 8))
+        sns.heatmap(
+            data,
+            annot=True,
+            fmt='.2%',
+            cmap='RdYlGn',
+            xticklabels=filt_values,
+            yticklabels=conf_values,
+            vmin=0,
+            vmax=1,
+            cbar_kws={'label': metric_names[metric]}
+        )
+        plt.xlabel('Filter Threshold', fontsize=12)
+        plt.ylabel('Confidence Threshold', fontsize=12)
+        plt.title(f'{metric_names[metric]} Heatmap', fontsize=14, fontweight='bold')
+        plt.tight_layout()
+
+        output_path = os.path.join(output_dir, f'heatmap_{metric}.png')
+        plt.savefig(output_path, dpi=150)
+        plt.close()
+        print(f"  📊 {metric_names[metric]} 히트맵 저장: {output_path}")
+
+
+if __name__ == "__main__":
+    # 테스트 범위 설정
+    TEST_DIR = r"data\흰다리새우 실측 데이터_익투스에이아이(주)"
+    GT_PATH = "ground_truth.json"
+
+    # 파라미터 범위
+    CONFIDENCE_VALUES = [0.3, 0.35, 0.4, 0.45, 0.5]
+    FILTER_VALUES = [30, 40, 50, 60, 70]
+
+    if not os.path.exists(GT_PATH):
+        print("⚠️  ground_truth.json 파일이 필요합니다.")
+    else:
+        best_config, all_results = run_parameter_sweep(
+            test_image_dir=TEST_DIR,
+            ground_truth_path=GT_PATH,
+            confidence_values=CONFIDENCE_VALUES,
+            filter_values=FILTER_VALUES,
+            iou_threshold=0.5
+        )
+
+        print("\n💡 다음 단계:")
+        print(f"   1. test_visual_validation.py 의 파라미터를 업데이트:")
+        print(f"      - confidence_threshold = {best_config['confidence']}")
+        print(f"      - filter_threshold = {best_config['filter_threshold']}")
+        print(f"   2. 업데이트 후 재평가 실행:")
+        print(f"      python test_quantitative_evaluation.py")

test_roboflow_model.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+"""
+Roboflow 모델 (find-shrimp-6) 테스트
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+from inference_sdk import InferenceHTTPClient
+from PIL import Image, ImageDraw, ImageFont
+import os
+import glob
+import time
+
+# Roboflow 클라이언트 초기화
+client = InferenceHTTPClient(
+    api_url="https://serverless.roboflow.com",
+    api_key="azcIL8KDJVJMYrsERzI7"
+)
+
+def test_roboflow_detection(image_path):
+    """단일 이미지 테스트"""
+    print(f"\n{'='*60}")
+    print(f"📸 테스트 이미지: {os.path.basename(image_path)}")
+    print(f"{'='*60}")
+
+    # 이미지 크기 확인
+    image = Image.open(image_path)
+    print(f"🖼️  원본 크기: {image.size}")
+
+    # Roboflow API 호출
+    start_time = time.time()
+
+    result = client.run_workflow(
+        workspace_name="vidraft",
+        workflow_id="find-shrimp-6",
+        images={"image": image_path},
+        use_cache=True
+    )
+
+    elapsed = time.time() - start_time
+    print(f"⏱️  추론 시간: {elapsed:.2f}초")
+
+    # 결과 파싱
+    predictions = []
+
+    if isinstance(result, dict) and 'outputs' in result and len(result['outputs']) > 0:
+        output = result['outputs'][0]
+        if isinstance(output, dict) and 'predictions' in output:
+            pred_data = output['predictions']
+            if isinstance(pred_data, dict) and 'predictions' in pred_data:
+                predictions = pred_data['predictions']
+            elif isinstance(pred_data, list):
+                predictions = pred_data
+
+    print(f"📦 검출된 객체 수: {len(predictions)}개")
+
+    # 신뢰도별 통계
+    if predictions:
+        confidences = [pred.get('confidence', 0) for pred in predictions]
+        print(f"📊 신뢰도 통계:")
+        print(f"   - 최고: {max(confidences):.1%}")
+        print(f"   - 최저: {min(confidences):.1%}")
+        print(f"   - 평균: {sum(confidences)/len(confidences):.1%}")
+
+        # 신뢰도별 개수
+        high_conf = sum(1 for c in confidences if c >= 0.5)
+        mid_conf = sum(1 for c in confidences if 0.2 <= c < 0.5)
+        low_conf = sum(1 for c in confidences if c < 0.2)
+
+        print(f"\n   - 고신뢰도 (≥50%): {high_conf}개")
+        print(f"   - 중신뢰도 (20-50%): {mid_conf}개")
+        print(f"   - 저신뢰도 (<20%): {low_conf}개")
+
+        # 상위 5개 출력
+        print(f"\n🔍 상위 5개 검출 결과:")
+        sorted_preds = sorted(predictions, key=lambda x: x.get('confidence', 0), reverse=True)
+        for i, pred in enumerate(sorted_preds[:5], 1):
+            conf = pred.get('confidence', 0)
+            x = pred.get('x', 0)
+            y = pred.get('y', 0)
+            w = pred.get('width', 0)
+            h = pred.get('height', 0)
+            print(f"   {i}. 신뢰도: {conf:.1%}, 위치: ({x:.0f}, {y:.0f}), 크기: {w:.0f}x{h:.0f}")
+    else:
+        print("⚠️  검출된 객체가 없습니다!")
+
+    # 시각화
+    output_path = image_path.replace('.jpg', '_roboflow_result.jpg')
+    visualize_result(image_path, predictions, output_path)
+    print(f"💾 결과 저장: {output_path}")
+
+    return predictions
+
+def visualize_result(image_path, predictions, output_path):
+    """결과 시각화"""
+    image = Image.open(image_path)
+    draw = ImageDraw.Draw(image)
+
+    for pred in predictions:
+        conf = pred.get('confidence', 0)
+        x = pred.get('x', 0)
+        y = pred.get('y', 0)
+        w = pred.get('width', 0)
+        h = pred.get('height', 0)
+
+        # 박스 좌표
+        x1 = x - w / 2
+        y1 = y - h / 2
+        x2 = x + w / 2
+        y2 = y + h / 2
+
+        # 신뢰도에 따른 색상
+        if conf >= 0.5:
+            color = 'green'
+        elif conf >= 0.2:
+            color = 'yellow'
+        else:
+            color = 'red'
+
+        # 박스 그리기
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+
+        # 신뢰도 텍스트
+        text = f"{conf:.0%}"
+        draw.text((x1, y1-15), text, fill=color)
+
+    image.save(output_path, quality=95)
+
+def main():
+    print("="*60)
+    print("🦐 Roboflow 모델 (find-shrimp-6) 테스트")
+    print("="*60)
+
+    # 테스트 이미지 선택 (YOLO 데이터셋에서 5개)
+    image_dir = "data/yolo_dataset/images/train"
+    test_images = sorted(glob.glob(os.path.join(image_dir, "*.jpg")))[:5]
+
+    if not test_images:
+        print("❌ 테스트 이미지를 찾을 수 없습니다!")
+        return
+
+    print(f"\n📁 테스트 이미지 경로: {image_dir}")
+    print(f"📊 테스트 이미지 수: {len(test_images)}개\n")
+
+    all_results = []
+
+    for img_path in test_images:
+        try:
+            predictions = test_roboflow_detection(img_path)
+            all_results.append({
+                'image': os.path.basename(img_path),
+                'count': len(predictions),
+                'predictions': predictions
+            })
+        except Exception as e:
+            print(f"❌ 오류 발생: {str(e)}")
+            import traceback
+            traceback.print_exc()
+
+    # 전체 요약
+    print(f"\n{'='*60}")
+    print("📊 전체 테스트 요약")
+    print(f"{'='*60}")
+
+    total_detections = sum(r['count'] for r in all_results)
+    print(f"\n총 검출 수: {total_detections}개")
+    print(f"이미지당 평균: {total_detections/len(all_results):.1f}개")
+
+    print(f"\n이미지별 검출 수:")
+    for r in all_results:
+        print(f"   - {r['image']}: {r['count']}개")
+
+    print(f"\n✅ 테스트 완료!")
+    print(f"📁 결과 이미지: {image_dir}/*_roboflow_result.jpg")
+
+if __name__ == "__main__":
+    main()

test_roboflow_save_results.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""
+Roboflow 모델 테스트 및 결과 이미지 저장
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import requests
+import base64
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import json
+import os
+import glob
+
+def test_and_save_result(image_path, output_dir="test_results"):
+    """이미지 테스트 후 결과 저장"""
+
+    # 출력 디렉토리 생성
+    os.makedirs(output_dir, exist_ok=True)
+
+    print(f"\n{'='*60}")
+    print(f"📸 테스트: {os.path.basename(image_path)}")
+    print(f"{'='*60}")
+
+    # 이미지 로드
+    image = Image.open(image_path)
+    original_size = image.size
+    print(f"🖼️  원본 크기: {original_size}")
+
+    # 리사이즈
+    max_size = 640
+    if image.width > max_size or image.height > max_size:
+        image_resized = image.copy()
+        image_resized.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
+        print(f"📐 리사이즈: {image_resized.size}")
+    else:
+        image_resized = image
+
+    # Base64 인코딩
+    buffered = BytesIO()
+    image_resized.save(buffered, format="JPEG", quality=80)
+    img_base64 = base64.b64encode(buffered.getvalue()).decode()
+    print(f"📦 Base64 크기: {len(img_base64)} bytes")
+
+    # API 호출
+    print(f"🔄 Roboflow API 호출 중...")
+    response = requests.post(
+        'https://serverless.roboflow.com/vidraft/workflows/find-shrimp-6',
+        headers={'Content-Type': 'application/json'},
+        json={
+            'api_key': 'azcIL8KDJVJMYrsERzI7',
+            'inputs': {
+                'image': {'type': 'base64', 'value': img_base64}
+            }
+        },
+        timeout=30
+    )
+
+    if response.status_code != 200:
+        print(f"❌ API 오류: {response.status_code}")
+        return None
+
+    result = response.json()
+
+    # predictions 추출
+    predictions = []
+    if 'outputs' in result and len(result['outputs']) > 0:
+        output = result['outputs'][0]
+        if 'predictions' in output:
+            pred_data = output['predictions']
+            if isinstance(pred_data, dict) and 'predictions' in pred_data:
+                predictions = pred_data['predictions']
+
+    print(f"📦 검출 수: {len(predictions)}개")
+
+    # 원본 이미지에 박스 그리기
+    draw = ImageDraw.Draw(image)
+
+    # 리사이즈 비율 계산 (원본 크기로 복원)
+    scale_x = original_size[0] / image_resized.size[0]
+    scale_y = original_size[1] / image_resized.size[1]
+
+    for i, pred in enumerate(predictions, 1):
+        conf = pred.get('confidence', 0)
+        x = pred.get('x', 0) * scale_x
+        y = pred.get('y', 0) * scale_y
+        w = pred.get('width', 0) * scale_x
+        h = pred.get('height', 0) * scale_y
+
+        # 박스 좌표
+        x1 = x - w / 2
+        y1 = y - h / 2
+        x2 = x + w / 2
+        y2 = y + h / 2
+
+        # 신뢰도별 색상
+        if conf >= 0.5:
+            color = 'lime'
+            thickness = 5
+        elif conf >= 0.3:
+            color = 'yellow'
+            thickness = 4
+        else:
+            color = 'red'
+            thickness = 3
+
+        # 박스 그리기
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=thickness)
+
+        # 신뢰도 텍스트
+        text = f"#{i} {conf:.1%}"
+
+        # 텍스트 배경
+        try:
+            font = ImageFont.truetype("arial.ttf", 40)
+        except:
+            font = ImageFont.load_default()
+
+        # 텍스트 위치
+        text_bbox = draw.textbbox((x1, y1-50), text, font=font)
+        draw.rectangle(text_bbox, fill=color)
+        draw.text((x1, y1-50), text, fill='black', font=font)
+
+        print(f"  {i}. 신뢰도: {conf:.1%}, 위치: ({x:.0f}, {y:.0f}), 크기: {w:.0f}x{h:.0f}")
+
+    # 결과 저장
+    output_filename = os.path.basename(image_path).replace('.jpg', '_result.jpg')
+    output_path = os.path.join(output_dir, output_filename)
+    image.save(output_path, quality=95)
+    print(f"💾 저장: {output_path}")
+
+    return {
+        'image': os.path.basename(image_path),
+        'detections': len(predictions),
+        'output': output_path
+    }
+
+def main():
+    print("="*60)
+    print("🦐 Roboflow 모델 테스트 및 결과 저장")
+    print("="*60)
+
+    # YOLO 데이터셋에서 5개 이미지 선택
+    image_dir = "data/yolo_dataset/images/train"
+    test_images = sorted(glob.glob(os.path.join(image_dir, "*.jpg")))[:5]
+
+    if not test_images:
+        print("❌ 테스트 이미지를 찾을 수 없습니다!")
+        return
+
+    print(f"\n📁 이미지 경로: {image_dir}")
+    print(f"📊 테스트 수: {len(test_images)}개\n")
+
+    results = []
+
+    for img_path in test_images:
+        try:
+            result = test_and_save_result(img_path)
+            if result:
+                results.append(result)
+        except Exception as e:
+            print(f"❌ 오류: {str(e)}")
+            import traceback
+            traceback.print_exc()
+
+    # 요약
+    print(f"\n{'='*60}")
+    print("📊 테스트 요약")
+    print(f"{'='*60}")
+
+    total_detections = sum(r['detections'] for r in results)
+    print(f"\n총 검출 수: {total_detections}개")
+    print(f"평균: {total_detections/len(results):.1f}개/이미지")
+
+    print(f"\n이미지별 결과:")
+    for r in results:
+        print(f"  - {r['image']}: {r['detections']}개 → {r['output']}")
+
+    print(f"\n✅ 완료! 결과는 test_results/ 폴더에 저장되었습니다.")
+
+if __name__ == "__main__":
+    main()

test_yolo_with_filter.py

@@ -0,0 +1,336 @@
+# -*- coding: utf-8 -*-
+"""
+YOLOv8 + Universal Filter 결합
+즉시 개선: YOLOv8의 높은 Recall + Filter의 높은 Precision
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+from ultralytics import YOLO
+import json
+import os
+from PIL import Image
+import numpy as np
+from pathlib import Path
+from test_visual_validation import apply_universal_filter
+
+def calculate_iou(box1, box2):
+    """IoU 계산"""
+    x1_1, y1_1, x2_1, y2_1 = box1
+    x1_2, y1_2, x2_2, y2_2 = box2
+
+    x1_i = max(x1_1, x1_2)
+    y1_i = max(y1_1, y1_2)
+    x2_i = min(x2_1, x2_2)
+    y2_i = min(y2_1, y2_2)
+
+    if x2_i < x1_i or y2_i < y1_i:
+        return 0.0
+
+    intersection = (x2_i - x1_i) * (y2_i - y1_i)
+    area1 = (x2_1 - x1_1) * (y2_1 - y1_1)
+    area2 = (x2_2 - x1_2) * (y2_2 - y1_2)
+    union = area1 + area2 - intersection
+
+    return intersection / union if union > 0 else 0.0
+
+def yolo_with_filter_evaluate(model_path, gt_file, data_base_dir,
+                                yolo_conf=0.01, filter_threshold=90, iou_threshold=0.5):
+    """YOLOv8 + Universal Filter 평가"""
+
+    print(f"\n📊 YOLOv8 + Universal Filter 평가")
+    print(f"   - YOLOv8 Confidence: {yolo_conf}")
+    print(f"   - Filter Threshold: {filter_threshold}")
+    print(f"   - IoU Threshold: {iou_threshold}")
+
+    # 모델 로드
+    model = YOLO(model_path)
+    print(f"✅ YOLOv8 모델 로드 완료")
+
+    # GT 로드
+    with open(gt_file, 'r', encoding='utf-8') as f:
+        gt_data = json.load(f)
+
+    # 통계
+    total_gt = 0
+    total_yolo_pred = 0
+    total_filtered_pred = 0
+
+    true_positives = 0
+    false_positives = 0
+    false_negatives = 0
+
+    yolo_only_tp = 0
+    yolo_only_fp = 0
+
+    results_detail = []
+
+    # 각 이미지 평가
+    for filename, gt_boxes in gt_data.items():
+        if not gt_boxes:
+            continue
+
+        folder = gt_boxes[0].get('folder', '')
+        if not folder:
+            continue
+
+        img_path = os.path.join(data_base_dir, folder, filename)
+        if not os.path.exists(img_path):
+            continue
+
+        # PIL 이미지 로드
+        image = Image.open(img_path)
+
+        # YOLOv8 추론
+        results = model(img_path, conf=yolo_conf, verbose=False)
+
+        # 예측 박스 추출
+        yolo_detections = []
+        if results and len(results) > 0:
+            result = results[0]
+            if result.boxes is not None and len(result.boxes) > 0:
+                boxes = result.boxes.xyxy.cpu().numpy()
+                confs = result.boxes.conf.cpu().numpy()
+
+                for box, conf in zip(boxes, confs):
+                    yolo_detections.append({
+                        'bbox': box.tolist(),
+                        'confidence': float(conf)
+                    })
+
+        # Universal Filter 적용
+        filtered_detections = apply_universal_filter(yolo_detections, image, threshold=filter_threshold)
+
+        # GT 박스
+        gt_boxes_only = [{'bbox': ann['bbox']} for ann in gt_boxes]
+
+        # YOLOv8 only 매칭 (비교용)
+        yolo_matched_gt = set()
+        yolo_matched_pred = set()
+
+        for i, pred in enumerate(yolo_detections):
+            best_iou = 0
+            best_gt_idx = -1
+            for j, gt in enumerate(gt_boxes_only):
+                if j in yolo_matched_gt:
+                    continue
+                iou = calculate_iou(pred['bbox'], gt['bbox'])
+                if iou > best_iou:
+                    best_iou = iou
+                    best_gt_idx = j
+
+            if best_iou >= iou_threshold:
+                yolo_matched_pred.add(i)
+                yolo_matched_gt.add(best_gt_idx)
+
+        yolo_tp = len(yolo_matched_gt)
+        yolo_fp = len(yolo_detections) - len(yolo_matched_pred)
+
+        # Filtered 매칭
+        matched_gt = set()
+        matched_pred = set()
+
+        for i, pred in enumerate(filtered_detections):
+            best_iou = 0
+            best_gt_idx = -1
+
+            for j, gt in enumerate(gt_boxes_only):
+                if j in matched_gt:
+                    continue
+                iou = calculate_iou(pred['bbox'], gt['bbox'])
+                if iou > best_iou:
+                    best_iou = iou
+                    best_gt_idx = j
+
+            if best_iou >= iou_threshold:
+                matched_pred.add(i)
+                matched_gt.add(best_gt_idx)
+
+        tp = len(matched_gt)
+        fp = len(filtered_detections) - len(matched_pred)
+        fn = len(gt_boxes_only) - len(matched_gt)
+
+        true_positives += tp
+        false_positives += fp
+        false_negatives += fn
+        total_gt += len(gt_boxes_only)
+        total_yolo_pred += len(yolo_detections)
+        total_filtered_pred += len(filtered_detections)
+
+        yolo_only_tp += yolo_tp
+        yolo_only_fp += yolo_fp
+
+        results_detail.append({
+            'filename': filename,
+            'gt_count': len(gt_boxes_only),
+            'yolo_count': len(yolo_detections),
+            'filtered_count': len(filtered_detections),
+            'tp': tp,
+            'fp': fp,
+            'fn': fn
+        })
+
+    # 성능 계산
+    precision = true_positives / (true_positives + false_positives) if (true_positives + false_positives) > 0 else 0
+    recall = true_positives / (true_positives + false_negatives) if (true_positives + false_negatives) > 0 else 0
+    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
+
+    # YOLOv8 only 성능
+    yolo_precision = yolo_only_tp / (yolo_only_tp + yolo_only_fp) if (yolo_only_tp + yolo_only_fp) > 0 else 0
+    yolo_recall = yolo_only_tp / total_gt if total_gt > 0 else 0
+    yolo_f1 = 2 * yolo_precision * yolo_recall / (yolo_precision + yolo_recall) if (yolo_precision + yolo_recall) > 0 else 0
+
+    return {
+        'yolo_with_filter': {
+            'precision': precision,
+            'recall': recall,
+            'f1': f1,
+            'tp': true_positives,
+            'fp': false_positives,
+            'fn': false_negatives,
+            'total_pred': total_filtered_pred
+        },
+        'yolo_only': {
+            'precision': yolo_precision,
+            'recall': yolo_recall,
+            'f1': yolo_f1,
+            'tp': yolo_only_tp,
+            'fp': yolo_only_fp,
+            'total_pred': total_yolo_pred
+        },
+        'total_gt': total_gt
+    }
+
+def main():
+    print("=" * 60)
+    print("🚀 YOLOv8 + Universal Filter 즉시 개선")
+    print("=" * 60)
+
+    # 경로 설정
+    yolo_model = "runs/train/shrimp_yolov8n/weights/best.pt"
+    gt_file = "ground_truth.json"
+    data_base_dir = "data/흰다리새우 실측 데이터_익투스에이아이(주)"
+
+    if not os.path.exists(yolo_model):
+        print(f"\n❌ 모델 파일 없음: {yolo_model}")
+        return
+
+    print(f"\n📁 YOLOv8 모델: {yolo_model}")
+    print(f"📁 GT: {gt_file}")
+
+    # 여러 조합 테스트
+    test_configs = [
+        {'yolo_conf': 0.01, 'filter_threshold': 70},
+        {'yolo_conf': 0.01, 'filter_threshold': 80},
+        {'yolo_conf': 0.01, 'filter_threshold': 90},
+        {'yolo_conf': 0.001, 'filter_threshold': 90},
+        {'yolo_conf': 0.005, 'filter_threshold': 90},
+    ]
+
+    print(f"\n🔍 최적 조합 탐색 중...")
+
+    best_f1 = 0
+    best_config = None
+    best_result = None
+    all_results = []
+
+    for config in test_configs:
+        result = yolo_with_filter_evaluate(
+            yolo_model, gt_file, data_base_dir,
+            yolo_conf=config['yolo_conf'],
+            filter_threshold=config['filter_threshold']
+        )
+
+        result['config'] = config
+        all_results.append(result)
+
+        filtered = result['yolo_with_filter']
+        print(f"\n   YOLOv8(conf={config['yolo_conf']}) + Filter({config['filter_threshold']})")
+        print(f"      P={filtered['precision']:.1%}, R={filtered['recall']:.1%}, F1={filtered['f1']:.1%}")
+        print(f"      Pred: {result['yolo_only']['total_pred']} → {filtered['total_pred']} (Filter 제거: {result['yolo_only']['total_pred'] - filtered['total_pred']}개)")
+
+        if filtered['f1'] > best_f1:
+            best_f1 = filtered['f1']
+            best_config = config
+            best_result = result
+
+    # 최적 결과 출력
+    print("\n" + "=" * 60)
+    print("✅ 평가 완료!")
+    print("=" * 60)
+
+    print(f"\n🏆 최적 조합:")
+    print(f"   - YOLOv8 Confidence: {best_config['yolo_conf']}")
+    print(f"   - Filter Threshold: {best_config['filter_threshold']}")
+
+    filtered = best_result['yolo_with_filter']
+    yolo = best_result['yolo_only']
+
+    print(f"\n📊 YOLOv8 + Universal Filter 성능:")
+    print(f"   - Precision: {filtered['precision']:.1%}")
+    print(f"   - Recall: {filtered['recall']:.1%}")
+    print(f"   - F1 Score: {filtered['f1']:.1%}")
+    print(f"\n   - True Positives: {filtered['tp']}")
+    print(f"   - False Positives: {filtered['fp']}")
+    print(f"   - False Negatives: {filtered['fn']}")
+    print(f"   - Total Predictions: {filtered['total_pred']}")
+
+    print(f"\n📊 YOLOv8 Only 비교:")
+    print(f"   - Precision: {yolo['precision']:.1%}")
+    print(f"   - Recall: {yolo['recall']:.1%}")
+    print(f"   - F1 Score: {yolo['f1']:.1%}")
+    print(f"   - Total Predictions: {yolo['total_pred']}")
+
+    print(f"\n🎯 Filter 효과:")
+    print(f"   - FP 제거: {yolo['fp']} → {filtered['fp']} ({yolo['fp'] - filtered['fp']}개 제거)")
+    print(f"   - Precision 향상: {yolo['precision']:.1%} → {filtered['precision']:.1%} ({(filtered['precision'] - yolo['precision'])*100:+.1f}%p)")
+    print(f"   - F1 향상: {yolo['f1']:.1%} → {filtered['f1']:.1%} ({(filtered['f1'] - yolo['f1'])*100:+.1f}%p)")
+
+    # 전체 시스템 비교
+    print(f"\n📊 전체 시스템 비교:")
+    print(f"\n   RT-DETR + Filter (기존):")
+    print(f"   - Precision: 44.2%")
+    print(f"   - Recall: 94.0%")
+    print(f"   - F1 Score: 56.1%")
+
+    print(f"\n   YOLOv8 + Filter (새로운):")
+    print(f"   - Precision: {filtered['precision']:.1%}")
+    print(f"   - Recall: {filtered['recall']:.1%}")
+    print(f"   - F1 Score: {filtered['f1']:.1%}")
+
+    # F1 비교
+    baseline_f1 = 0.561
+    improvement = (filtered['f1'] - baseline_f1) / baseline_f1 * 100
+
+    if improvement > 0:
+        print(f"\n   ✅ F1 개선율: {improvement:+.1f}% (YOLOv8+Filter가 더 좋음)")
+    else:
+        print(f"\n   ⚠️  F1 차이: {improvement:+.1f}% (RT-DETR+Filter가 더 좋음)")
+
+    # 결과 저장
+    output_file = "yolo_with_filter_results.json"
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump({
+            'best_config': best_config,
+            'best_result': best_result,
+            'all_results': all_results,
+            'baseline': {
+                'name': 'RT-DETR + Filter',
+                'precision': 0.442,
+                'recall': 0.940,
+                'f1': 0.561
+            }
+        }, f, indent=2, ensure_ascii=False)
+
+    print(f"\n💾 결과 저장: {output_file}")
+
+    print(f"\n💡 권장 사항:")
+    if filtered['f1'] >= baseline_f1:
+        print(f"   ✅ YOLOv8 + Universal Filter 사용 권장")
+        print(f"   - 설정: YOLOv8 conf={best_config['yolo_conf']}, Filter={best_config['filter_threshold']}")
+    else:
+        print(f"   ⚠️  RT-DETR + Universal Filter 계속 사용 권장")
+        print(f"   - YOLOv8+Filter도 준수한 성능이지만 기존이 약간 더 좋음")
+
+if __name__ == "__main__":
+    main()

test_yolov8_val_results.py

@@ -0,0 +1,234 @@
+"""
+YOLOv8m Val Set 결과 이미지 저장
+Confidence = 0.85 사용
+"""
+from ultralytics import YOLO
+from PIL import Image, ImageDraw, ImageFont
+import json
+import os
+
+# 학습된 모델 로드
+MODEL_PATH = "runs/train/yolov8m_shrimp2/weights/best.pt"
+model = YOLO(MODEL_PATH)
+
+# 최적 confidence
+CONFIDENCE = 0.85
+
+print(f"✅ YOLOv8m 모델 로드: {MODEL_PATH}")
+print(f"🎯 Confidence Threshold: {CONFIDENCE}")
+
+# Ground Truth 로드
+with open('ground_truth.json', 'r', encoding='utf-8') as f:
+    ground_truth = json.load(f)
+
+# Val set 이미지만 필터링
+val_images_dir = set(os.listdir('data/yolo_dataset/images/val'))
+gt_val_only = {}
+
+for img_name, gts in ground_truth.items():
+    if not gts:
+        continue
+    base_name = img_name.replace('-1.jpg', '.jpg')
+    if img_name in val_images_dir or base_name in val_images_dir:
+        gt_val_only[img_name] = gts
+
+print(f"📁 Val set GT 이미지: {len(gt_val_only)}장")
+
+# 출력 디렉토리
+output_dir = "test_results_yolov8m_val"
+os.makedirs(output_dir, exist_ok=True)
+
+# 폰트 설정
+try:
+    font = ImageFont.truetype("malgun.ttf", 24)
+    font_small = ImageFont.truetype("malgun.ttf", 18)
+    font_tiny = ImageFont.truetype("malgun.ttf", 14)
+except:
+    font = ImageFont.load_default()
+    font_small = ImageFont.load_default()
+    font_tiny = ImageFont.load_default()
+
+def calculate_iou(box1, box2):
+    """IoU 계산"""
+    x1_min, y1_min, x1_max, y1_max = box1
+    x2_min, y2_min, x2_max, y2_max = box2
+
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+    box1_area = (x1_max - x1_min) * (y1_max - y1_min)
+    box2_area = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = box1_area + box2_area - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+
+# 통계
+total_gt = 0
+total_tp = 0
+total_fp = 0
+total_fn = 0
+
+print("-" * 60)
+
+# 각 이미지 처리
+for idx, (img_name, gt_boxes) in enumerate(sorted(gt_val_only.items()), 1):
+    print(f"\n[{idx}/{len(gt_val_only)}] {img_name}")
+
+    # 이미지 경로
+    img_path = f"data/yolo_dataset/images/val/{img_name}"
+    base_name = img_name.replace('-1.jpg', '.jpg')
+    if not os.path.exists(img_path):
+        img_path = f"data/yolo_dataset/images/val/{base_name}"
+
+    if not os.path.exists(img_path):
+        print(f"  ⚠️ 이미지를 찾을 수 없음: {img_path}")
+        continue
+
+    # 이미지 로드
+    image = Image.open(img_path)
+    print(f"  📐 크기: {image.size}")
+
+    # YOLOv8 검출
+    results = model.predict(
+        source=image,
+        conf=CONFIDENCE,
+        iou=0.7,
+        device=0,
+        verbose=False
+    )
+
+    result = results[0]
+    boxes = result.boxes
+
+    predictions = []
+    if boxes is not None and len(boxes) > 0:
+        for box in boxes:
+            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+            confidence = box.conf[0].cpu().item()
+            predictions.append({
+                'bbox': [float(x1), float(y1), float(x2), float(y2)],
+                'confidence': confidence
+            })
+
+    print(f"  🦐 검출: {len(predictions)}개 (GT: {len(gt_boxes)}개)")
+
+    # GT와 매칭
+    matched_gt = set()
+    matched_pred = set()
+    tp = 0
+    fp = 0
+
+    for pred_idx, pred in enumerate(predictions):
+        best_iou = 0
+        best_gt_idx = -1
+
+        for gt_idx, gt in enumerate(gt_boxes):
+            if gt_idx in matched_gt:
+                continue
+
+            iou = calculate_iou(pred['bbox'], gt['bbox'])
+            if iou > best_iou:
+                best_iou = iou
+                best_gt_idx = gt_idx
+
+        if best_iou >= 0.5:
+            tp += 1
+            matched_gt.add(best_gt_idx)
+            matched_pred.add(pred_idx)
+        else:
+            fp += 1
+
+    fn = len(gt_boxes) - len(matched_gt)
+
+    total_gt += len(gt_boxes)
+    total_tp += tp
+    total_fp += fp
+    total_fn += fn
+
+    print(f"  📊 TP={tp}, FP={fp}, FN={fn}")
+
+    # 결과 이미지 그리기
+    result_image = image.copy()
+    draw = ImageDraw.Draw(result_image)
+
+    # Ground Truth (파란색, 점선 효과)
+    for gt_idx, gt in enumerate(gt_boxes):
+        x1, y1, x2, y2 = gt['bbox']
+
+        # 파란색 박스 (얇게)
+        for offset in range(0, 4, 2):
+            draw.rectangle([x1+offset, y1+offset, x2-offset, y2-offset], outline="blue", width=2)
+
+        # GT 라벨
+        label = f"GT#{gt_idx+1}"
+        bbox_label = draw.textbbox((x1, y1 - 30), label, font=font_tiny)
+        draw.rectangle(bbox_label, fill="blue")
+        draw.text((x1, y1 - 30), label, fill="white", font=font_tiny)
+
+        # 매칭 여부 표시
+        if gt_idx not in matched_gt:
+            # FN (놓침)
+            draw.text((x1 + 10, y1 + 10), "MISSED", fill="red", font=font_small)
+
+    # Predictions
+    for pred_idx, pred in enumerate(predictions):
+        x1, y1, x2, y2 = pred['bbox']
+        conf = pred['confidence']
+
+        if pred_idx in matched_pred:
+            # TP (올바른 검출) - 녹색
+            color = "lime"
+            label = f"✓ TP #{pred_idx+1} | {conf:.0%}"
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=10)
+        else:
+            # FP (잘못된 검출) - 빨간색
+            color = "red"
+            label = f"✗ FP #{pred_idx+1} | {conf:.0%}"
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=8)
+
+        # 라벨
+        bbox_label = draw.textbbox((x1, y2 + 5), label, font=font_tiny)
+        draw.rectangle(bbox_label, fill=color)
+        draw.text((x1, y2 + 5), label, fill="black" if color == "lime" else "white", font=font_tiny)
+
+    # 통계 텍스트 (상단)
+    stats_text = f"GT:{len(gt_boxes)} | Pred:{len(predictions)} | TP:{tp} FP:{fp} FN:{fn}"
+    draw.rectangle([10, 10, 800, 50], fill="black")
+    draw.text((15, 15), stats_text, fill="white", font=font_small)
+
+    # 이미지 정보 (하단)
+    info_text = f"Confidence: {CONFIDENCE} | {img_name}"
+    img_width, img_height = image.size
+    draw.rectangle([10, img_height - 50, 800, img_height - 10], fill="black")
+    draw.text((15, img_height - 45), info_text, fill="yellow", font=font_tiny)
+
+    # 저장
+    output_path = os.path.join(output_dir, f"result_{base_name}")
+    result_image.save(output_path, quality=95)
+    print(f"  ✅ 저장: {output_path}")
+
+# 최종 통계
+print("\n" + "=" * 60)
+print("📊 전체 결과 (Val Set 10장):")
+print("=" * 60)
+print(f"총 GT: {total_gt}개")
+print(f"TP: {total_tp}개 (올바른 검출)")
+print(f"FP: {total_fp}개 (잘못된 검출)")
+print(f"FN: {total_fn}개 (놓친 GT)")
+
+precision = total_tp / (total_tp + total_fp) if (total_tp + total_fp) > 0 else 0
+recall = total_tp / (total_tp + total_fn) if (total_tp + total_fn) > 0 else 0
+f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+print(f"\nPrecision: {precision:.1%}")
+print(f"Recall: {recall:.1%}")
+print(f"F1 Score: {f1:.1%}")
+
+print(f"\n📁 결과 저장: {output_dir}/")
+print("=" * 60)

test_yolov8m_trained.py

@@ -0,0 +1,112 @@
+"""
+YOLOv8m 학습 모델 테스트 스크립트
+학습된 모델로 테스트 이미지 검출 및 결과 저장
+"""
+from ultralytics import YOLO
+from PIL import Image, ImageDraw, ImageFont
+import os
+import glob
+
+# 학습된 모델 로드
+MODEL_PATH = "runs/train/yolov8m_shrimp2/weights/best.pt"
+model = YOLO(MODEL_PATH)
+
+print(f"✅ YOLOv8m 모델 로드 완료: {MODEL_PATH}")
+
+# 테스트 이미지 경로
+test_images_dir = "data/yolo_dataset/images/val"
+output_dir = "test_results_yolov8m"
+
+# 출력 디렉토리 생성
+os.makedirs(output_dir, exist_ok=True)
+
+# 테스트 이미지 찾기
+test_images = sorted(glob.glob(os.path.join(test_images_dir, "*.jpg")))
+
+if not test_images:
+    print(f"❌ 테스트 이미지를 찾을 수 없습니다: {test_images_dir}")
+    exit(1)
+
+print(f"📁 테스트 이미지: {len(test_images)}장")
+print(f"📂 결과 저장 경로: {output_dir}/")
+print("-" * 60)
+
+# 폰트 설정
+try:
+    font = ImageFont.truetype("malgun.ttf", 20)
+    font_small = ImageFont.truetype("malgun.ttf", 14)
+except:
+    font = ImageFont.load_default()
+    font_small = ImageFont.load_default()
+
+# 각 이미지 테스트
+total_detections = 0
+for idx, img_path in enumerate(test_images, 1):
+    img_name = os.path.basename(img_path)
+    print(f"\n[{idx}/{len(test_images)}] {img_name}")
+
+    # 이미지 로드
+    image = Image.open(img_path)
+    print(f"  📐 이미지 크기: {image.size}")
+
+    # YOLOv8 검출 (confidence threshold=0.065)
+    results = model.predict(
+        source=image,
+        conf=0.065,
+        iou=0.7,
+        device=0,  # GPU 사용
+        verbose=False
+    )
+
+    # 결과 파싱
+    result = results[0]
+    boxes = result.boxes
+
+    detections = []
+    if boxes is not None and len(boxes) > 0:
+        for box in boxes:
+            # 바운딩 박스 좌표
+            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+            confidence = box.conf[0].cpu().item()
+            cls = int(box.cls[0].cpu().item())
+
+            detections.append({
+                'bbox': [float(x1), float(y1), float(x2), float(y2)],
+                'confidence': confidence,
+                'class': cls
+            })
+
+    print(f"  🦐 검출: {len(detections)}개")
+    total_detections += len(detections)
+
+    # 결과 이미지 그리기
+    result_image = image.copy()
+    draw = ImageDraw.Draw(result_image)
+
+    for i, det in enumerate(detections, 1):
+        x1, y1, x2, y2 = det['bbox']
+        conf = det['confidence']
+
+        # 바운딩 박스 (녹색, 굵게)
+        draw.rectangle([x1, y1, x2, y2], outline="lime", width=8)
+
+        # 라벨
+        label = f"#{i} | {conf:.2%}"
+        bbox = draw.textbbox((x1, y1 - 25), label, font=font_small)
+        draw.rectangle(bbox, fill="lime")
+        draw.text((x1, y1 - 25), label, fill="black", font=font_small)
+
+        print(f"    #{i}: conf={conf:.2%}, bbox=[{x1:.0f},{y1:.0f},{x2:.0f},{y2:.0f}]")
+
+    # 결과 저장
+    output_path = os.path.join(output_dir, f"result_{img_name}")
+    result_image.save(output_path)
+    print(f"  ✅ 저장: {output_path}")
+
+print("\n" + "=" * 60)
+print(f"📊 전체 결과:")
+print(f"  - 테스트 이미지: {len(test_images)}장")
+print(f"  - 총 검출: {total_detections}개")
+print(f"  - 평균: {total_detections / len(test_images):.1f}개/이미지")
+print(f"  - 결과 저장: {output_dir}/")
+print("=" * 60)

test_yolov8m_unseen.py

@@ -0,0 +1,144 @@
+"""
+YOLOv8m Unseen Test Set 평가
+251010, 251017 폴더의 완전히 새로운 이미지 20개로 테스트
+"""
+from ultralytics import YOLO
+from PIL import Image, ImageDraw, ImageFont
+import os
+import glob
+
+# 학습된 모델 로드
+MODEL_PATH = "runs/train/yolov8m_shrimp2/weights/best.pt"
+model = YOLO(MODEL_PATH)
+
+# 최적 confidence
+CONFIDENCE = 0.85
+
+print(f"✅ YOLOv8m 모델 로드: {MODEL_PATH}")
+print(f"🎯 Confidence Threshold: {CONFIDENCE}")
+
+# Unseen test 이미지 경로
+test_folders = [
+    "data/흰다리새우 실측 데이터_익투스에이아이(주)/251010",
+    "data/흰다리새우 실측 데이터_익투스에이아이(주)/251017"
+]
+
+test_images = []
+for folder in test_folders:
+    # -1.jpg 제외, 원본 이미지만
+    images = sorted(glob.glob(os.path.join(folder, "*_[0-9][0-9].jpg")))
+    test_images.extend(images)
+
+print(f"📁 Unseen test 이미지: {len(test_images)}장")
+print("-" * 60)
+
+# 출력 디렉토리
+output_dir = "test_results_unseen"
+os.makedirs(output_dir, exist_ok=True)
+
+# 폰트 설정
+try:
+    font = ImageFont.truetype("malgun.ttf", 24)
+    font_small = ImageFont.truetype("malgun.ttf", 18)
+    font_tiny = ImageFont.truetype("malgun.ttf", 14)
+except:
+    font = ImageFont.load_default()
+    font_small = ImageFont.load_default()
+    font_tiny = ImageFont.load_default()
+
+# 통계
+total_detections = 0
+images_with_detections = 0
+images_without_detections = 0
+
+print("\n🔍 Unseen Test 검출 시작...\n")
+
+# 각 이미지 처리
+for idx, img_path in enumerate(test_images, 1):
+    img_name = os.path.basename(img_path)
+    folder_name = os.path.basename(os.path.dirname(img_path))
+
+    print(f"[{idx}/{len(test_images)}] {folder_name}/{img_name}")
+
+    # 이미지 로드
+    image = Image.open(img_path)
+    print(f"  📐 크기: {image.size}")
+
+    # YOLOv8 검출
+    results = model.predict(
+        source=image,
+        conf=CONFIDENCE,
+        iou=0.7,
+        device=0,
+        verbose=False
+    )
+
+    result = results[0]
+    boxes = result.boxes
+
+    predictions = []
+    if boxes is not None and len(boxes) > 0:
+        for box in boxes:
+            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+            confidence = box.conf[0].cpu().item()
+            predictions.append({
+                'bbox': [float(x1), float(y1), float(x2), float(y2)],
+                'confidence': confidence
+            })
+
+    num_detections = len(predictions)
+    total_detections += num_detections
+
+    if num_detections > 0:
+        images_with_detections += 1
+        print(f"  🦐 검출: {num_detections}개")
+    else:
+        images_without_detections += 1
+        print(f"  ⚪ 검출 없음")
+
+    # 결과 이미지 그리기
+    result_image = image.copy()
+    draw = ImageDraw.Draw(result_image)
+
+    # Predictions (녹색 박스)
+    for pred_idx, pred in enumerate(predictions, 1):
+        x1, y1, x2, y2 = pred['bbox']
+        conf = pred['confidence']
+
+        # 녹색 박스
+        draw.rectangle([x1, y1, x2, y2], outline="lime", width=10)
+
+        # 라벨
+        label = f"#{pred_idx} | {conf:.0%}"
+        bbox_label = draw.textbbox((x1, y2 + 5), label, font=font_small)
+        draw.rectangle(bbox_label, fill="lime")
+        draw.text((x1, y2 + 5), label, fill="black", font=font_small)
+
+    # 통계 텍스트 (상단)
+    stats_text = f"Detections: {num_detections} | Confidence: {CONFIDENCE}"
+    draw.rectangle([10, 10, 800, 50], fill="black")
+    draw.text((15, 15), stats_text, fill="white", font=font_small)
+
+    # 이미지 정보 (하단)
+    info_text = f"{folder_name}/{img_name}"
+    img_width, img_height = image.size
+    draw.rectangle([10, img_height - 50, 800, img_height - 10], fill="black")
+    draw.text((15, img_height - 45), info_text, fill="yellow", font=font_tiny)
+
+    # 저장
+    output_path = os.path.join(output_dir, f"result_{folder_name}_{img_name}")
+    result_image.save(output_path, quality=95)
+    print(f"  ✅ 저장: {output_path}")
+
+# 최종 통계
+print("\n" + "=" * 60)
+print("📊 Unseen Test Set 결과:")
+print("=" * 60)
+print(f"총 이미지: {len(test_images)}장")
+print(f"총 검출: {total_detections}개")
+print(f"평균 검출: {total_detections / len(test_images):.1f}개/이미지")
+print(f"\n검출 있음: {images_with_detections}장 ({images_with_detections/len(test_images)*100:.1f}%)")
+print(f"검출 없음: {images_without_detections}장 ({images_without_detections/len(test_images)*100:.1f}%)")
+
+print(f"\n📁 결과 저장: {output_dir}/")
+print("=" * 60)

test_yolov8m_with_filter.py

@@ -0,0 +1,367 @@
+"""
+YOLOv8m + Universal Filter 테스트
+전체 데이터셋으로 테스트 및 필터링 성능 개선
+"""
+from ultralytics import YOLO
+from PIL import Image, ImageDraw, ImageFont
+import os
+import glob
+import numpy as np
+import json
+
+# OpenCV for filter functions
+import cv2
+
+def calculate_morphological_features(bbox, img_size):
+    """형태학적 특징 계산"""
+    x1, y1, x2, y2 = bbox
+    width = x2 - x1
+    height = y2 - y1
+    area = width * height
+
+    aspect_ratio = height / width if width > 0 else 0
+
+    # Compactness (0~1, 1에 가까울수록 정사각형)
+    perimeter = 2 * (width + height)
+    compactness = (4 * np.pi * area) / (perimeter ** 2) if perimeter > 0 else 0
+
+    # 이미지 내 비율
+    img_area = img_size[0] * img_size[1]
+    area_ratio = area / img_area if img_area > 0 else 0
+
+    return {
+        'width': width,
+        'height': height,
+        'area': area,
+        'aspect_ratio': aspect_ratio,
+        'compactness': compactness,
+        'area_ratio': area_ratio
+    }
+
+def calculate_visual_features(image_pil, bbox):
+    """시각적 특징 계산"""
+    image_cv = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
+    x1, y1, x2, y2 = [int(v) for v in bbox]
+
+    roi = image_cv[y1:y2, x1:x2]
+    if roi.size == 0:
+        return {'hue': 100, 'saturation': 255, 'color_std': 255}
+
+    hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
+
+    return {
+        'hue': np.mean(hsv[:, :, 0]),
+        'saturation': np.mean(hsv[:, :, 1]),
+        'color_std': np.std(hsv[:, :, 0])
+    }
+
+def calculate_iou_simple(bbox1, bbox2):
+    """간단한 IoU 계산"""
+    x1_min, y1_min, x1_max, y1_max = bbox1
+    x2_min, y2_min, x2_max, y2_max = bbox2
+
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+
+    bbox1_area = (x1_max - x1_min) * (y1_max - y1_min)
+    bbox2_area = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = bbox1_area + bbox2_area - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+
+def apply_universal_filter(detections, image, threshold=90):
+    """범용 새우 필터 적용"""
+    img_size = image.size
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        morph = calculate_morphological_features(bbox, img_size)
+        visual = calculate_visual_features(image, bbox)
+
+        score = 0
+        reasons = []
+
+        # Aspect ratio (4:1 ~ 9:1)
+        if 4.0 <= morph['aspect_ratio'] <= 9.0:
+            score += 25
+            reasons.append(f"✓ 종횡비 {morph['aspect_ratio']:.1f}")
+        elif 3.0 <= morph['aspect_ratio'] < 4.0 or 9.0 < morph['aspect_ratio'] <= 10.0:
+            score += 12
+            reasons.append(f"△ 종횡비 {morph['aspect_ratio']:.1f}")
+        else:
+            score -= 5
+            reasons.append(f"✗ 종횡비 {morph['aspect_ratio']:.1f}")
+
+        # Compactness (세장도)
+        if morph['compactness'] < 0.40:
+            score += 30
+            reasons.append(f"✓ 세장도 {morph['compactness']:.2f}")
+        elif 0.40 <= morph['compactness'] < 0.50:
+            score += 15
+            reasons.append(f"△ 세장도 {morph['compactness']:.2f}")
+        else:
+            score -= 20
+            reasons.append(f"✗ 세장도 {morph['compactness']:.2f}")
+
+        # Area
+        abs_area = morph['width'] * morph['height']
+        if 50000 <= abs_area <= 500000:
+            score += 35
+            reasons.append(f"✓ 면적 {abs_area/1000:.0f}K")
+        elif 500000 < abs_area <= 800000:
+            score -= 10
+            reasons.append(f"△ 면적 {abs_area/1000:.0f}K")
+        elif abs_area > 800000:
+            score -= 30
+            reasons.append(f"✗ 면적 {abs_area/1000:.0f}K (너무큼)")
+        else:
+            score -= 10
+            reasons.append(f"✗ 면적 {abs_area/1000:.0f}K (너무작음)")
+
+        # Hue (색상)
+        hue = visual['hue']
+        if hue < 40 or hue > 130:
+            score += 10
+            reasons.append(f"✓ 색상 {hue:.0f}")
+        elif 90 <= hue <= 130:
+            score -= 5
+            reasons.append(f"✗ 색상 {hue:.0f} (배경)")
+        else:
+            reasons.append(f"△ 색상 {hue:.0f}")
+
+        # Saturation (채도)
+        if visual['saturation'] < 85:
+            score += 20
+            reasons.append(f"✓ 채도 {visual['saturation']:.0f}")
+        elif 85 <= visual['saturation'] < 120:
+            score += 5
+            reasons.append(f"△ 채도 {visual['saturation']:.0f}")
+        else:
+            score -= 15
+            reasons.append(f"✗ 채도 {visual['saturation']:.0f} (높음)")
+
+        # Color consistency
+        if visual['color_std'] < 50:
+            score += 15
+            reasons.append(f"✓ 색상일관성 {visual['color_std']:.1f}")
+        elif 50 <= visual['color_std'] < 80:
+            score += 5
+            reasons.append(f"△ 색상일관성 {visual['color_std']:.1f}")
+        else:
+            score -= 10
+            reasons.append(f"✗ 색상일관성 {visual['color_std']:.1f}")
+
+        # YOLOv8 confidence
+        score += det['confidence'] * 15
+
+        det['filter_score'] = score
+        det['filter_reasons'] = reasons
+        det['morph_features'] = morph
+        det['visual_features'] = visual
+
+        if score >= threshold:
+            filtered.append(det)
+
+    # 점수 순으로 정렬
+    filtered.sort(key=lambda x: x['filter_score'], reverse=True)
+
+    # NMS (Non-Maximum Suppression)
+    filtered_nms = []
+    for det in filtered:
+        is_duplicate = False
+        for kept_det in filtered_nms:
+            iou = calculate_iou_simple(det['bbox'], kept_det['bbox'])
+            if iou > 0.5:
+                is_duplicate = True
+                break
+
+        if not is_duplicate:
+            filtered_nms.append(det)
+
+    return filtered_nms
+
+# 학습된 모델 로드
+MODEL_PATH = "runs/train/yolov8m_shrimp2/weights/best.pt"
+model = YOLO(MODEL_PATH)
+
+print(f"✅ YOLOv8m 모델 로드 완료: {MODEL_PATH}")
+
+# 전체 데이터셋 테스트 (train + val)
+test_images = []
+for split in ['train', 'val']:
+    split_dir = f"data/yolo_dataset/images/{split}"
+    if os.path.exists(split_dir):
+        test_images.extend(sorted(glob.glob(os.path.join(split_dir, "*.jpg"))))
+
+output_dir = "test_results_yolov8m_filtered"
+os.makedirs(output_dir, exist_ok=True)
+
+print(f"📁 테스트 이미지: {len(test_images)}장")
+print(f"📂 결과 저장 경로: {output_dir}/")
+print("-" * 60)
+
+# 폰트 설정
+try:
+    font = ImageFont.truetype("malgun.ttf", 20)
+    font_small = ImageFont.truetype("malgun.ttf", 14)
+    font_tiny = ImageFont.truetype("malgun.ttf", 12)
+except:
+    font = ImageFont.load_default()
+    font_small = ImageFont.load_default()
+    font_tiny = ImageFont.load_default()
+
+# 통계 변수
+stats_no_filter = {'total': 0, 'per_image': []}
+stats_filtered = {'total': 0, 'per_image': []}
+filter_thresholds = [50, 60, 70, 80, 90]  # 다양한 임계값 테스트
+stats_by_threshold = {th: {'total': 0, 'per_image': []} for th in filter_thresholds}
+
+# 각 이미지 테스트
+for idx, img_path in enumerate(test_images, 1):
+    img_name = os.path.basename(img_path)
+
+    if idx % 10 == 0 or idx == 1:
+        print(f"\n[{idx}/{len(test_images)}] {img_name}")
+
+    # 이미지 로드
+    image = Image.open(img_path)
+
+    # YOLOv8 검출 (confidence threshold=0.065)
+    results = model.predict(
+        source=image,
+        conf=0.065,
+        iou=0.7,
+        device=0,
+        verbose=False
+    )
+
+    # 결과 파싱
+    result = results[0]
+    boxes = result.boxes
+
+    detections_raw = []
+    if boxes is not None and len(boxes) > 0:
+        for box in boxes:
+            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+            confidence = box.conf[0].cpu().item()
+
+            detections_raw.append({
+                'bbox': [float(x1), float(y1), float(x2), float(y2)],
+                'confidence': confidence
+            })
+
+    stats_no_filter['total'] += len(detections_raw)
+    stats_no_filter['per_image'].append(len(detections_raw))
+
+    # Universal Filter 적용
+    detections_scored = apply_universal_filter(detections_raw, image, threshold=0)
+
+    # 다양한 임계값으로 필터링 테스트
+    for threshold in filter_thresholds:
+        filtered = [det for det in detections_scored if det['filter_score'] >= threshold]
+        stats_by_threshold[threshold]['total'] += len(filtered)
+        stats_by_threshold[threshold]['per_image'].append(len(filtered))
+
+    # 기본 임계값 90 사용
+    detections_filtered = [det for det in detections_scored if det['filter_score'] >= 90]
+    stats_filtered['total'] += len(detections_filtered)
+    stats_filtered['per_image'].append(len(detections_filtered))
+
+    # 처음 10개 이미지만 결과 저장
+    if idx <= 10:
+        # 결과 이미지 그리기
+        result_image = image.copy()
+        draw = ImageDraw.Draw(result_image)
+
+        # 필터링된 검출 (녹색)
+        for i, det in enumerate(detections_filtered, 1):
+            x1, y1, x2, y2 = det['bbox']
+            score = det['filter_score']
+            conf = det['confidence']
+
+            draw.rectangle([x1, y1, x2, y2], outline="lime", width=8)
+            label = f"#{i} | F:{score:.0f} C:{conf:.0%}"
+            bbox_label = draw.textbbox((x1, y1 - 25), label, font=font_tiny)
+            draw.rectangle(bbox_label, fill="lime")
+            draw.text((x1, y1 - 25), label, fill="black", font=font_tiny)
+
+        # 제거된 검출 (빨간색, 반투명)
+        for det in detections_raw:
+            if det not in [d for d in detections_filtered]:
+                x1, y1, x2, y2 = det['bbox']
+                # 필터 점수 찾기
+                scored_det = next((d for d in detections_scored if d['bbox'] == det['bbox']), None)
+                if scored_det:
+                    score = scored_det['filter_score']
+                    draw.rectangle([x1, y1, x2, y2], outline="red", width=4)
+                    label = f"X:{score:.0f}"
+                    bbox_label = draw.textbbox((x1, y1 - 20), label, font=font_tiny)
+                    draw.rectangle(bbox_label, fill="red")
+                    draw.text((x1, y1 - 20), label, fill="white", font=font_tiny)
+
+        # 통계 텍스트 추가
+        info_text = f"Raw: {len(detections_raw)} | Filtered (90): {len(detections_filtered)}"
+        draw.text((10, 10), info_text, fill="yellow", font=font)
+
+        # 결과 저장
+        output_path = os.path.join(output_dir, f"result_{img_name}")
+        result_image.save(output_path)
+
+        if idx % 10 == 0 or idx == 1:
+            print(f"  Raw: {len(detections_raw)}, Filtered: {len(detections_filtered)}")
+            print(f"  ✅ 저장: {output_path}")
+
+# 최종 통계 출력
+print("\n" + "=" * 60)
+print("📊 전체 결과 (필터링 전후 비교):")
+print("=" * 60)
+print(f"\n1️⃣ 필터링 전 (Raw YOLOv8):")
+print(f"   - 총 검출: {stats_no_filter['total']}개")
+print(f"   - 평균: {stats_no_filter['total'] / len(test_images):.1f}개/이미지")
+
+print(f"\n2️⃣ 필터링 후 성능 비교:")
+for threshold in filter_thresholds:
+    total = stats_by_threshold[threshold]['total']
+    avg = total / len(test_images)
+    reduction = (1 - total / stats_no_filter['total']) * 100 if stats_no_filter['total'] > 0 else 0
+    print(f"   Threshold {threshold}: {total}개 (평균 {avg:.1f}/이미지, -{reduction:.1f}% 감소)")
+
+print(f"\n3️⃣ 권장 설정 (Threshold 90):")
+print(f"   - 총 검출: {stats_filtered['total']}개")
+print(f"   - 평균: {stats_filtered['total'] / len(test_images):.1f}개/이미지")
+reduction = (1 - stats_filtered['total'] / stats_no_filter['total']) * 100 if stats_no_filter['total'] > 0 else 0
+print(f"   - False Positive 감소: {reduction:.1f}%")
+
+print(f"\n📁 결과 이미지 저장: {output_dir}/ (처음 10장)")
+print("=" * 60)
+
+# 통계를 JSON으로 저장
+stats_summary = {
+    'total_images': len(test_images),
+    'no_filter': {
+        'total': stats_no_filter['total'],
+        'average': stats_no_filter['total'] / len(test_images)
+    },
+    'by_threshold': {}
+}
+
+for threshold in filter_thresholds:
+    total = stats_by_threshold[threshold]['total']
+    stats_summary['by_threshold'][threshold] = {
+        'total': total,
+        'average': total / len(test_images),
+        'reduction_pct': (1 - total / stats_no_filter['total']) * 100 if stats_no_filter['total'] > 0 else 0
+    }
+
+with open(os.path.join(output_dir, 'filter_statistics.json'), 'w', encoding='utf-8') as f:
+    json.dump(stats_summary, f, indent=2, ensure_ascii=False)
+
+print(f"\n💾 통계 저장: {output_dir}/filter_statistics.json")

validate_ground_truth.py

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+"""
+Ground Truth 검증 스크립트
+라벨링 데이터의 품질과 일관성을 확인
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import json
+import os
+from pathlib import Path
+
+def validate_ground_truth(gt_file="ground_truth.json"):
+    """Ground Truth 데이터 검증"""
+
+    print("=" * 60)
+    print("🔍 Ground Truth 검증")
+    print("=" * 60)
+
+    # 파일 존재 확인
+    if not os.path.exists(gt_file):
+        print(f"❌ 파일이 존재하지 않습니다: {gt_file}")
+        return
+
+    # JSON 로드
+    with open(gt_file, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    # 기본 통계
+    total_images = len(data)
+    labeled_images = sum(1 for v in data.values() if len(v) > 0)
+    empty_images = sum(1 for v in data.values() if len(v) == 0)
+    total_boxes = sum(len(v) for v in data.values())
+
+    print(f"\n📊 기본 통계")
+    print(f"{'─' * 60}")
+    print(f"총 이미지:        {total_images}개")
+    print(f"라벨링된 이미지:  {labeled_images}개 ({labeled_images/total_images*100:.1f}%)")
+    print(f"빈 이미지:        {empty_images}개 ({empty_images/total_images*100:.1f}%)")
+    print(f"총 바운딩 박스:   {total_boxes}개")
+    if labeled_images > 0:
+        print(f"이미지당 평균:    {total_boxes/labeled_images:.2f}개")
+
+    # 폴더별 통계
+    folders = {}
+    for filename, boxes in data.items():
+        if boxes:
+            folder = boxes[0].get('folder', 'unknown')
+            if folder not in folders:
+                folders[folder] = {'images': 0, 'boxes': 0}
+            folders[folder]['images'] += 1
+            folders[folder]['boxes'] += len(boxes)
+
+    if folders:
+        print(f"\n📁 폴더별 통계")
+        print(f"{'─' * 60}")
+        for folder, stats in sorted(folders.items()):
+            print(f"{folder}: {stats['images']}장, {stats['boxes']}박스 (평균 {stats['boxes']/stats['images']:.1f}개/이미지)")
+
+    # 신뢰도 분석
+    confidences = []
+    for boxes in data.values():
+        for box in boxes:
+            if 'confidence' in box:
+                confidences.append(box['confidence'])
+
+    if confidences:
+        print(f"\n🎯 신뢰도 분석")
+        print(f"{'─' * 60}")
+        print(f"평균 신뢰도:      {sum(confidences)/len(confidences):.3f}")
+        print(f"최소 신뢰도:      {min(confidences):.3f}")
+        print(f"최대 신뢰도:      {max(confidences):.3f}")
+
+        # 신뢰도 분포
+        low = sum(1 for c in confidences if c < 0.2)
+        mid = sum(1 for c in confidences if 0.2 <= c < 0.4)
+        high = sum(1 for c in confidences if c >= 0.4)
+        print(f"\n신뢰도 분포:")
+        print(f"  < 0.2:          {low}개 ({low/len(confidences)*100:.1f}%)")
+        print(f"  0.2 ~ 0.4:      {mid}개 ({mid/len(confidences)*100:.1f}%)")
+        print(f"  >= 0.4:         {high}개 ({high/len(confidences)*100:.1f}%)")
+
+    # 박스 크기 분석
+    print(f"\n📐 박스 크기 분석")
+    print(f"{'─' * 60}")
+
+    box_areas = []
+    box_widths = []
+    box_heights = []
+    aspect_ratios = []
+
+    for boxes in data.values():
+        for box in boxes:
+            bbox = box['bbox']
+            x1, y1, x2, y2 = bbox
+            width = x2 - x1
+            height = y2 - y1
+            area = width * height
+
+            box_areas.append(area)
+            box_widths.append(width)
+            box_heights.append(height)
+            if height > 0:
+                aspect_ratios.append(width / height)
+
+    if box_areas:
+        print(f"평균 면적:        {sum(box_areas)/len(box_areas):.0f} px²")
+        print(f"평균 너비:        {sum(box_widths)/len(box_widths):.0f} px")
+        print(f"평균 높이:        {sum(box_heights)/len(box_heights):.0f} px")
+        print(f"평균 종횡비:      {sum(aspect_ratios)/len(aspect_ratios):.2f}")
+        print(f"  (새우는 보통 3:1 ~ 10:1)")
+
+    # 상세 데이터 (처음 5개)
+    print(f"\n📋 상세 데이터 (처음 5개)")
+    print(f"{'─' * 60}")
+
+    count = 0
+    for filename, boxes in data.items():
+        if count >= 5:
+            break
+
+        print(f"\n{filename}")
+        if not boxes:
+            print("  - 박스 없음 (빈 이미지 또는 건너뛰기)")
+        else:
+            for idx, box in enumerate(boxes, 1):
+                bbox = box['bbox']
+                x1, y1, x2, y2 = bbox
+                width = x2 - x1
+                height = y2 - y1
+                conf = box.get('confidence', 0)
+                print(f"  #{idx}: bbox=[{x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f}], "
+                      f"크기={width:.0f}x{height:.0f}, 신뢰도={conf:.3f}")
+        count += 1
+
+    # 검증 결과
+    print(f"\n{'=' * 60}")
+    print(f"✅ 검증 결과")
+    print(f"{'=' * 60}")
+
+    issues = []
+
+    # 1. 데이터가 너무 적은지 확인
+    if total_images < 10:
+        issues.append(f"⚠️  이미지 수가 적습니다 ({total_images}개). 최소 50개 권장")
+
+    # 2. 라벨링 비율 확인
+    if labeled_images / total_images < 0.5:
+        issues.append(f"⚠️  라벨링 비율이 낮습니다 ({labeled_images/total_images*100:.1f}%). 50% 이상 권장")
+
+    # 3. 평균 박스 수 확인
+    if labeled_images > 0 and total_boxes / labeled_images < 0.5:
+        issues.append(f"⚠️  이미지당 평균 박스 수가 적습니다 ({total_boxes/labeled_images:.2f}개)")
+
+    # 4. 신뢰도 확인
+    if confidences and sum(confidences)/len(confidences) < 0.2:
+        issues.append(f"⚠️  평균 신뢰도가 낮습니다 ({sum(confidences)/len(confidences):.3f}). 검출 품질 확인 필요")
+
+    if issues:
+        print("\n문제점:")
+        for issue in issues:
+            print(f"  {issue}")
+    else:
+        print("\n✅ 모든 검증 통과!")
+
+    # 다음 단계 제안
+    print(f"\n{'=' * 60}")
+    print(f"📝 다음 단계")
+    print(f"{'=' * 60}")
+
+    if total_images < 50:
+        print(f"\n1. 더 많은 이미지 라벨링")
+        print(f"   - 현재: {total_images}장")
+        print(f"   - 목표: 50장 이상 (Phase 1)")
+        print(f"   - 권장: 100~200장 (Phase 2~3)")
+
+    if labeled_images > 10:
+        print(f"\n2. 정량적 평가 실행")
+        print(f"   ```bash")
+        print(f"   python test_quantitative_evaluation.py")
+        print(f"   ```")
+
+    print(f"\n3. 계속 라벨링")
+    print(f"   - 브라우저에서 http://localhost:7862 접속")
+    print(f"   - 더 많은 폴더 작업")
+
+    print(f"\n{'=' * 60}\n")
+
+if __name__ == "__main__":
+    validate_ground_truth()

visualize_yolo_dataset.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+"""
+YOLO 데이터셋 바운딩 박스 시각화
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import os
+from PIL import Image, ImageDraw, ImageFont
+from pathlib import Path
+import random
+
+def visualize_yolo_annotation(img_path, label_path, output_path):
+    """YOLO 형식 라벨을 이미지에 그리기"""
+
+    # 이미지 로드
+    img = Image.open(img_path)
+    draw = ImageDraw.Draw(img)
+    img_width, img_height = img.size
+
+    # 폰트 설정
+    try:
+        font = ImageFont.truetype("arial.ttf", 30)
+        font_small = ImageFont.truetype("arial.ttf", 20)
+    except:
+        font = ImageFont.load_default()
+        font_small = ImageFont.load_default()
+
+    # 라벨 파일 읽기
+    if not os.path.exists(label_path):
+        print(f"⚠️  라벨 파일 없음: {label_path}")
+        return False
+
+    with open(label_path, 'r') as f:
+        lines = f.readlines()
+
+    print(f"\n📄 {os.path.basename(img_path)}")
+    print(f"   이미지 크기: {img_width} x {img_height}")
+    print(f"   박스 개수: {len(lines)}")
+
+    # 각 박스 그리기
+    for idx, line in enumerate(lines, 1):
+        parts = line.strip().split()
+        if len(parts) != 5:
+            continue
+
+        class_id = int(parts[0])
+        x_center_norm = float(parts[1])
+        y_center_norm = float(parts[2])
+        width_norm = float(parts[3])
+        height_norm = float(parts[4])
+
+        # 정규화된 좌표를 픽셀 좌표로 변환
+        x_center = x_center_norm * img_width
+        y_center = y_center_norm * img_height
+        width = width_norm * img_width
+        height = height_norm * img_height
+
+        # 바운딩 박스 좌표 계산
+        x1 = x_center - width / 2
+        y1 = y_center - height / 2
+        x2 = x_center + width / 2
+        y2 = y_center + height / 2
+
+        # 박스 그리기 (녹색, 두껍게)
+        draw.rectangle([x1, y1, x2, y2], outline="lime", width=8)
+
+        # 라벨 (검은 배경에 흰 글씨)
+        label = f"Shrimp #{idx}"
+        bbox = draw.textbbox((x1, y1 - 40), label, font=font)
+        draw.rectangle([bbox[0]-5, bbox[1]-5, bbox[2]+5, bbox[3]+5], fill="lime")
+        draw.text((x1, y1 - 40), label, fill="black", font=font)
+
+        # 좌표 정보 (작게)
+        info = f"YOLO: {x_center_norm:.3f} {y_center_norm:.3f} {width_norm:.3f} {height_norm:.3f}"
+        draw.text((x1, y2 + 10), info, fill="lime", font=font_small)
+
+        print(f"   #{idx}: center=({x_center:.0f}, {y_center:.0f}), size=({width:.0f}x{height:.0f})")
+
+    # 저장
+    img.save(output_path, quality=95)
+    print(f"   ✅ 저장: {output_path}")
+
+    return True
+
+def main():
+    print("=" * 60)
+    print("📊 YOLO 데이터셋 바운딩 박스 시각화")
+    print("=" * 60)
+
+    # 경로 설정
+    dataset_dir = Path("data/yolo_dataset")
+    train_img_dir = dataset_dir / "images" / "train"
+    train_label_dir = dataset_dir / "labels" / "train"
+    output_dir = Path("data/yolo_visualization")
+    output_dir.mkdir(exist_ok=True)
+
+    # Train 이미지 리스트
+    img_files = list(train_img_dir.glob("*.jpg"))
+
+    if not img_files:
+        print("❌ Train 이미지 없음!")
+        return
+
+    print(f"\n📁 Train 이미지: {len(img_files)}개")
+
+    # 랜덤 3개 샘플
+    random.seed(42)
+    samples = random.sample(img_files, min(3, len(img_files)))
+
+    print(f"\n🎲 랜덤 샘플 3개 시각화:")
+
+    for img_path in samples:
+        # 대응하는 라벨 파일
+        label_filename = img_path.stem + ".txt"
+        label_path = train_label_dir / label_filename
+
+        # 출력 파일
+        output_path = output_dir / f"{img_path.stem}_visualized.jpg"
+
+        # 시각화
+        visualize_yolo_annotation(img_path, label_path, output_path)
+
+    print("\n" + "=" * 60)
+    print("✅ 시각화 완료!")
+    print("=" * 60)
+    print(f"\n📁 출력 디렉토리: {output_dir}")
+    print(f"\n생성된 파일:")
+    for file in sorted(output_dir.glob("*_visualized.jpg")):
+        print(f"   - {file.name}")
+
+    print(f"\n💡 이미지를 열어서 바운딩 박스가 올바른지 확인하세요!")
+
+if __name__ == "__main__":
+    main()