Clean up repository for Hugging Face deployment

**Removed files:**
- All backup apps: app_backup2.py, app_backup3.py, app_demo.py, app_full_system.py, shrimp_detection_app.py
- Test scripts: test_*.py, quick_test_*.py (25+ files)
- Analysis tools: analyze_*.py, optimize_*.py, check_*.py
- Training utilities: train_yolo.py, evaluate_yolo.py, labeling_tool.py

**Added:**
- examples/ folder with 5 example images for Gradio interface
- Updated app.py to use examples/ folder instead of data/yolo_dataset/

**Kept for deployment:**
- app.py (main application)
- requirements.txt
- test_visual_validation.py (required by app.py)
- test_quantitative_evaluation.py (required by app.py)
- interactive_validation.py (required by app.py)
- ground_truth.json (for labeling functionality)
- examples/ (5 demo images)

**Result:**
Clean, minimal Hugging Face deployment with only essential files

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

Co-Authored-By: Claude <noreply@anthropic.com>

analyze_fp_patterns.py

@@ -1,284 +0,0 @@
-# -*- 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.py

@@ -940,11 +940,11 @@ with gr.Blocks(title="🦐 새우 검출 통합 시스템", theme=gr.themes.Soft
 
                     # 예제 이미지 (결과 파일 제외)
                     example_images = [
-                        "data/yolo_dataset/images/train/250818_01.jpg",
-                        "data/yolo_dataset/images/train/250818_03.jpg",
-                        "data/yolo_dataset/images/train/250818_04.jpg",
-                        "data/yolo_dataset/images/train/250818_05.jpg",
-                        "data/yolo_dataset/images/train/250818_10.jpg",
+                        "examples/250818_01.jpg",
+                        "examples/250818_03.jpg",
+                        "examples/250818_04.jpg",
+                        "examples/250818_05.jpg",
+                        "examples/250818_10.jpg",
                     ]
 
                     # 파일이 존재하는 것만 필터링
@@ -1099,11 +1099,11 @@ with gr.Blocks(title="🦐 새우 검출 통합 시스템", theme=gr.themes.Soft
 
                     # 예제 이미지
                     example_images_demo = [
-                        "data/yolo_dataset/images/train/250818_01.jpg",
-                        "data/yolo_dataset/images/train/250818_03.jpg",
-                        "data/yolo_dataset/images/train/250818_04.jpg",
-                        "data/yolo_dataset/images/train/250818_05.jpg",
-                        "data/yolo_dataset/images/train/250818_10.jpg",
+                        "examples/250818_01.jpg",
+                        "examples/250818_03.jpg",
+                        "examples/250818_04.jpg",
+                        "examples/250818_05.jpg",
+                        "examples/250818_10.jpg",
                     ]
 
                     # 파일이 존재하는 것만 필터링

app_backup2.py

@@ -1,299 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-바운딩 박스 검출 테스트 페이지
-VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 검출 결과 비교
-"""
-import sys
-sys.stdout.reconfigure(encoding='utf-8')
-
-import gradio as gr
-from PIL import Image, ImageDraw, ImageFont
-import os
-
-# VIDraft/Shrimp 전용 검출기
-try:
-    from inference_sdk import InferenceHTTPClient, InferenceConfiguration
-
-    vidraft_client = InferenceHTTPClient(
-        api_url="https://serverless.roboflow.com",
-        api_key="azcIL8KDJVJMYrsERzI7"
-    )
-    VIDRAFT_AVAILABLE = True
-    print("✅ VIDraft/Shrimp 모델 사용 가능")
-except Exception as e:
-    VIDRAFT_AVAILABLE = False
-    print(f"❌ VIDraft/Shrimp 모델 사용 불가: {e}")
-
-def detect_with_vidraft(image, confidence, iou_threshold):
-    """VIDraft/Shrimp 전용 모델로 검출"""
-    if not VIDRAFT_AVAILABLE:
-        return None, "❌ VIDraft/Shrimp 모델을 사용할 수 없습니다."
-
-    if image is None:
-        return None, "⚠️ 이미지를 업로드하세요."
-
-    try:
-        # 임시 파일로 저장
-        import tempfile
-        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
-            if image.mode != 'RGB':
-                image = image.convert('RGB')
-            image.save(tmp.name, quality=95)
-            tmp_path = tmp.name
-
-        # API 호출 with configuration
-        custom_config = InferenceConfiguration(
-            confidence_threshold=confidence,
-            iou_threshold=iou_threshold
-        )
-
-        with vidraft_client.use_configuration(custom_config):
-            result = vidraft_client.infer(tmp_path, model_id="shrimp-konvey/2")
-
-        # 임시 파일 삭제
-        os.unlink(tmp_path)
-
-        # 결과 그리기
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        try:
-            font = ImageFont.truetype("arial.ttf", 14)
-        except:
-            font = ImageFont.load_default()
-
-        predictions = result["predictions"]
-        detected_count = 0
-
-        for pred in predictions:
-            if pred["confidence"] < confidence:
-                continue
-
-            detected_count += 1
-
-            x = pred["x"]
-            y = pred["y"]
-            w = pred["width"]
-            h = pred["height"]
-            conf = pred["confidence"]
-
-            # 바운딩 박스 좌표
-            x1 = x - w/2
-            y1 = y - h/2
-            x2 = x + w/2
-            y2 = y + h/2
-
-            # 신뢰도에 따라 색상
-            if conf > 0.8:
-                color = "lime"
-            elif conf > 0.6:
-                color = "orange"
-            else:
-                color = "yellow"
-
-            # 박스 그리기
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
-
-            # 라벨
-            label = f"#{detected_count} {conf:.0%}"
-            bbox = draw.textbbox((x1, y1 - 25), label, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 25), label, fill="black", font=font)
-
-        # 헤더
-        header = f"VIDraft/Shrimp: {detected_count}마리 검출"
-        header_bbox = draw.textbbox((10, 10), header, font=font)
-        draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10], fill="black", outline="lime", width=2)
-        draw.text((10, 10), header, fill="lime", font=font)
-
-        info = f"""
-        ### 📊 VIDraft/Shrimp 모델 검출 결과
-
-        - **검출 수**: {detected_count}마리
-        - **전체 예측**: {len(predictions)}개
-        - **신뢰도 임계값**: {confidence:.0%}
-        - **IoU 임계값**: {iou_threshold:.0%}
-        - **처리 시간**: {result['time']:.2f}초
-        """
-
-        return img, info
-
-    except Exception as e:
-        return None, f"❌ 오류 발생: {str(e)}"
-
-def detect_with_rtdetr(image, confidence):
-    """RT-DETR로 검출 (간단 버전)"""
-    if image is None:
-        return None, "⚠️ 이미지를 업로드하세요."
-
-    try:
-        from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
-        import torch
-
-        # 모델 로드 (캐시 사용)
-        if not hasattr(detect_with_rtdetr, 'model'):
-            print("🔄 RT-DETR 모델 로딩 중...")
-            processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
-            model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
-            model.eval()
-            detect_with_rtdetr.processor = processor
-            detect_with_rtdetr.model = model
-            print("✅ RT-DETR 로딩 완료")
-
-        processor = detect_with_rtdetr.processor
-        model = detect_with_rtdetr.model
-
-        # 추론
-        inputs = processor(images=image, return_tensors="pt")
-        with torch.no_grad():
-            outputs = model(**inputs)
-
-        target_sizes = torch.tensor([image.size[::-1]])
-        results = processor.post_process_object_detection(
-            outputs,
-            target_sizes=target_sizes,
-            threshold=confidence
-        )[0]
-
-        # 결과 그리기
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        try:
-            font = ImageFont.truetype("arial.ttf", 14)
-        except:
-            font = ImageFont.load_default()
-
-        detected_count = len(results["scores"])
-
-        for idx, (score, label, box) in enumerate(zip(results["scores"], results["labels"], results["boxes"]), 1):
-            x1, y1, x2, y2 = box.tolist()
-            conf = score.item()
-
-            # 색상
-            if conf > 0.8:
-                color = "cyan"
-            elif conf > 0.6:
-                color = "magenta"
-            else:
-                color = "yellow"
-
-            # 박스
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
-
-            # 라벨
-            label_text = f"#{idx} {conf:.0%}"
-            bbox = draw.textbbox((x1, y1 - 25), label_text, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 25), label_text, fill="black", font=font)
-
-        # 헤더
-        header = f"RT-DETR: {detected_count}개 검출"
-        header_bbox = draw.textbbox((10, 10), header, font=font)
-        draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10], fill="black", outline="cyan", width=2)
-        draw.text((10, 10), header, fill="cyan", font=font)
-
-        info = f"""
-        ### 📊 RT-DETR 범용 모델 검출 결과
-
-        - **검출 수**: {detected_count}개
-        - **신뢰도 임계값**: {confidence:.0%}
-
-        ⚠️ **참고**: RT-DETR은 범용 객체 검출 모델입니다. 새우 검출은 VIDraft/Shrimp 모델을 사용하세요.
-        """
-
-        return img, info
-
-    except Exception as e:
-        return None, f"❌ 오류 발생: {str(e)}"
-
-# Gradio 인터페이스
-with gr.Blocks(title="🦐 바운딩 박스 검출 테스트", theme=gr.themes.Soft()) as demo:
-
-    gr.Markdown("""
-    # 🦐 바운딩 박스 검출 비교 테스트
-
-    VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 검출 성능을 비교합니다.
-
-    ---
-    """)
-
-    with gr.Row():
-        with gr.Column():
-            input_image = gr.Image(label="입력 이미지", type="pil")
-            confidence_slider = gr.Slider(
-                0.1, 0.9, 0.5,
-                label="신뢰도 임계값 (Confidence)",
-                info="낮을수록 더 많이 검출"
-            )
-            iou_slider = gr.Slider(
-                0.1, 0.9, 0.5,
-                label="IoU 임계값 (Overlap)",
-                info="겹치는 박스 제거 기준 (높을수록 더 많이 유지)"
-            )
-
-            # 예제 이미지
-            gr.Examples(
-                examples=[
-                    ["imgs/test_shrimp_tank.png", 0.1, 0.1],
-                ],
-                inputs=[input_image, confidence_slider, iou_slider],
-                label="📷 예제 이미지 (클릭하여 바로 테스트)"
-            )
-
-        with gr.Column():
-            gr.Markdown("### 📝 사용 방법")
-            gr.Markdown("""
-            1. **아래 예제 이미지를 클릭**하거나 직접 업로드
-            2. 파라미터 조정:
-               - **Confidence**: 검출 신뢰도 (낮을수록 더 많이 검출)
-               - **IoU**: 중복 박스 제거 기준 (NMS)
-            3. 버튼 클릭하여 검출
-
-            **색상 의미:**
-            - **녹색/청록**: 높은 신뢰도 (>80%)
-            - **주황/자홍**: 중간 신뢰도 (60-80%)
-            - **노란색**: 낮은 신뢰도 (<60%)
-            """)
-
-    with gr.Tabs():
-        with gr.TabItem("🤖 VIDraft/Shrimp (새우 전용)"):
-            vidraft_btn = gr.Button("🚀 VIDraft/Shrimp 모델로 검출", variant="primary", size="lg")
-            vidraft_result = gr.Image(label="검출 결과")
-            vidraft_info = gr.Markdown()
-
-        with gr.TabItem("🔍 RT-DETR (범용)"):
-            rtdetr_btn = gr.Button("🚀 RT-DETR로 검출", variant="secondary", size="lg")
-            rtdetr_result = gr.Image(label="검출 결과")
-            rtdetr_info = gr.Markdown()
-
-    # 이벤트 연결
-    vidraft_btn.click(
-        detect_with_vidraft,
-        [input_image, confidence_slider, iou_slider],
-        [vidraft_result, vidraft_info]
-    )
-
-    rtdetr_btn.click(
-        detect_with_rtdetr,
-        [input_image, confidence_slider],
-        [rtdetr_result, rtdetr_info]
-    )
-
-    gr.Markdown("""
-    ---
-
-    ### 💡 팁
-
-    - **수조 이미지**: VIDraft/Shrimp 모델이 훨씬 정확합니다 (새우 전용 학습)
-    - **측정용 이미지**: RT-DETR 범용 모델을 사용하세요
-    - **검출 안 됨**: 신뢰도를 낮춰보세요 (0.3~0.4)
-    - **중복 박스**: IoU 임계값을 조정하세요 (VIDraft/Shrimp 모델만)
-    """)
-
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,  # Hugging Face default port
-        share=False
-    )

app_backup3.py

@@ -1,1342 +0,0 @@
-"""
-🦐 흰다리새우 분석 시스템 - RT-DETR CPU 최적화 버전
-실제 객체 검출 + 체장/체중 자동 추정
-"""
-
-import gradio as gr
-import numpy as np
-import pandas as pd
-import plotly.graph_objects as go
-from PIL import Image, ImageDraw, ImageFont
-from datetime import datetime
-import torch
-from transformers import (
-    RTDetrForObjectDetection,
-    RTDetrImageProcessor,
-    AutoImageProcessor,
-    AutoModelForDepthEstimation
-)
-import os
-import warnings
-warnings.filterwarnings('ignore')
-
-# =====================
-# 실측 데이터 (260개 샘플)
-# =====================
-REAL_DATA = [
-    {"length": 7.5, "weight": 2.0}, {"length": 7.7, "weight": 2.1},
-    {"length": 8.3, "weight": 2.7}, {"length": 8.4, "weight": 2.9},
-    {"length": 8.6, "weight": 3.1}, {"length": 8.7, "weight": 3.0},
-    {"length": 8.9, "weight": 3.2}, {"length": 9.1, "weight": 3.4},
-    {"length": 9.4, "weight": 4.0}, {"length": 9.7, "weight": 4.7},
-    {"length": 9.9, "weight": 4.7}, {"length": 10.0, "weight": 4.6},
-    {"length": 10.2, "weight": 5.5}, {"length": 10.3, "weight": 5.8},
-    {"length": 10.4, "weight": 5.5}, {"length": 10.7, "weight": 6.1},
-    {"length": 10.9, "weight": 6.0}, {"length": 11.0, "weight": 6.2},
-    {"length": 11.3, "weight": 5.8}, {"length": 11.4, "weight": 6.5},
-    {"length": 11.6, "weight": 7.5}, {"length": 11.7, "weight": 8.1},
-    {"length": 11.9, "weight": 9.4}, {"length": 12.0, "weight": 8.8},
-    {"length": 12.3, "weight": 10.2}, {"length": 12.5, "weight": 10.9},
-    {"length": 12.7, "weight": 10.1}, {"length": 12.9, "weight": 10.7},
-    {"length": 13.0, "weight": 10.7}, {"length": 13.1, "weight": 11.3},
-]
-
-# =====================
-# 회귀 모델
-# =====================
-class RegressionModel:
-    def __init__(self):
-        self.a = 0.003454
-        self.b = 3.1298
-        self.r2 = 0.929
-        self.mape = 6.4
-
-    def estimate_weight(self, length_cm):
-        """체장으로 체중 추정: W = a × L^b"""
-        return self.a * (length_cm ** self.b)
-
-    def calculate_error(self, true_weight, pred_weight):
-        """오차율 계산"""
-        if true_weight == 0:
-            return 0
-        return abs(true_weight - pred_weight) / true_weight * 100
-
-# =====================
-# 깊이 추정기
-# =====================
-class DepthEstimator:
-    def __init__(self, model_name="depth-anything/Depth-Anything-V2-Small-hf"):
-        """Depth-Anything V2 모델 초기화"""
-        print(f"🔄 Loading Depth Estimation model: {model_name}")
-
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-
-        try:
-            self.processor = AutoImageProcessor.from_pretrained(model_name)
-            self.model = AutoModelForDepthEstimation.from_pretrained(model_name)
-            self.model.to(self.device)
-            self.model.eval()
-            print("✅ Depth model loaded successfully!")
-            self.enabled = True
-        except Exception as e:
-            print(f"⚠️ Depth model loading failed: {e}")
-            print("📝 Running without depth correction")
-            self.enabled = False
-
-    @torch.no_grad()
-    def estimate_depth(self, image):
-        """이미지에서 깊이 맵 추정"""
-        if not self.enabled or image is None:
-            return None
-
-        # 이미지 전처리
-        inputs = self.processor(images=image, return_tensors="pt")
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
-
-        # 깊이 추정
-        outputs = self.model(**inputs)
-        predicted_depth = outputs.predicted_depth
-
-        # 원본 이미지 크기로 리샘플링
-        depth_map = torch.nn.functional.interpolate(
-            predicted_depth.unsqueeze(1),
-            size=image.size[::-1],  # (height, width)
-            mode="bicubic",
-            align_corners=False,
-        ).squeeze().cpu().numpy()
-
-        # 정규화 (0~1 범위)
-        depth_min = depth_map.min()
-        depth_max = depth_map.max()
-        depth_normalized = (depth_map - depth_min) / (depth_max - depth_min + 1e-8)
-
-        return depth_normalized
-
-    def get_depth_at_bbox(self, depth_map, bbox):
-        """bbox 중심점의 깊이 값 추출"""
-        if depth_map is None:
-            return 1.0  # 기본값
-
-        x1, y1, x2, y2 = bbox
-        center_x = int((x1 + x2) / 2)
-        center_y = int((y1 + y2) / 2)
-
-        # 범위 체크
-        h, w = depth_map.shape
-        center_x = min(max(0, center_x), w - 1)
-        center_y = min(max(0, center_y), h - 1)
-
-        return depth_map[center_y, center_x]
-
-    def visualize_depth(self, depth_map):
-        """깊이 맵 시각화"""
-        if depth_map is None:
-            return None
-
-        # 깊이 맵을 컬러맵으로 변환
-        import matplotlib.cm as cm
-        colormap = cm.get_cmap('viridis')
-        depth_colored = (colormap(depth_map)[:, :, :3] * 255).astype(np.uint8)
-
-        return Image.fromarray(depth_colored)
-
-# =====================
-# RT-DETR 검출��
-# =====================
-class RTDetrDetector:
-    def __init__(self, model_name="PekingU/rtdetr_r50vd_coco_o365"):
-        """RT-DETR 모델 초기화"""
-        print(f"🔄 Loading RT-DETR model: {model_name}")
-
-        # CPU 최적화 설정
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"📱 Using device: {self.device}")
-
-        try:
-            # 모델 및 프로세서 로딩
-            self.processor = RTDetrImageProcessor.from_pretrained(model_name)
-            self.model = RTDetrForObjectDetection.from_pretrained(model_name)
-            self.model.to(self.device)
-            self.model.eval()  # 평가 모드
-
-            print("✅ Model loaded successfully!")
-        except Exception as e:
-            print(f"❌ Model loading failed: {e}")
-            raise
-
-        self.regression_model = RegressionModel()
-
-        # 깊이 추정기 초기화
-        try:
-            self.depth_estimator = DepthEstimator()
-        except Exception as e:
-            print(f"⚠️ Depth estimator initialization failed: {e}")
-            self.depth_estimator = None
-
-        # 참조 스케일: 픽셀 크기를 실제 cm로 변환
-        # 예: 100픽셀 = 10cm (이미지에 따라 조정 필요)
-        self.pixel_to_cm_ratio = 0.1  # 기본값
-
-        # 깊이 보정 활성화 플래그
-        self.depth_correction_enabled = True
-
-        # 마지막 깊이 맵 캐싱 (UI 표시용)
-        self.last_depth_map = None
-
-    def set_scale(self, pixel_length, actual_cm):
-        """스케일 설정 (보정용)"""
-        self.pixel_to_cm_ratio = actual_cm / pixel_length
-        print(f"📏 Scale updated: {pixel_length}px = {actual_cm}cm")
-
-    @torch.no_grad()  # CPU 최적화: gradient 계산 비활성화
-    def detect(self, image, confidence_threshold=0.5):
-        """객체 검출 수행"""
-
-        if image is None:
-            return []
-
-        # 깊이 맵 생성 (원근 보정용)
-        depth_map = None
-        if self.depth_correction_enabled and self.depth_estimator and self.depth_estimator.enabled:
-            print("🔍 Estimating depth map for perspective correction...")
-            depth_map = self.depth_estimator.estimate_depth(image)
-            self.last_depth_map = depth_map
-
-            # 참조 깊이 (이미지 중심의 평균 깊이)
-            h, w = depth_map.shape
-            center_region = depth_map[h//4:3*h//4, w//4:3*w//4]
-            self.reference_depth = np.median(center_region)
-            print(f"📏 Reference depth: {self.reference_depth:.3f}")
-
-        # 이미지 전처리
-        inputs = self.processor(images=image, return_tensors="pt")
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
-
-        # 추론
-        outputs = self.model(**inputs)
-
-        # 결과 후처리
-        target_sizes = torch.tensor([image.size[::-1]])  # (height, width)
-        results = self.processor.post_process_object_detection(
-            outputs,
-            target_sizes=target_sizes,
-            threshold=confidence_threshold
-        )[0]
-
-        # 검출 결과 파싱
-        detections = []
-
-        for idx, (score, label, box) in enumerate(zip(
-            results["scores"],
-            results["labels"],
-            results["boxes"]
-        )):
-            # COCO 클래스 필터링 (필요시)
-            # 새우 전용 모델이 아니므로 모든 객체 검출
-            # label 1 = "person", 16 = "bird", 17 = "cat" 등
-            # 일단 모든 객체를 검출하되, 향후 fine-tuning 시 새우만 검출
-
-            x1, y1, x2, y2 = box.tolist()
-            bbox_width = x2 - x1
-            bbox_height = y2 - y1
-
-            # 깊이 기반 스케일 보정
-            depth_corrected_ratio = self.pixel_to_cm_ratio
-
-            if depth_map is not None:
-                # bbox 중심점의 깊이 값 추출
-                object_depth = self.depth_estimator.get_depth_at_bbox(depth_map, [x1, y1, x2, y2])
-
-                # 깊이 비율 계산 (참조 깊이 대비)
-                # 깊이 값이 클수록 먼 거리 → 실제 크기가 더 큼
-                # Depth-Anything에서: 작은 값 = 가까움, 큰 값 = 멀음
-                depth_ratio = object_depth / (self.reference_depth + 1e-8)
-
-                # 스케일 보정 (원근 효과 보정)
-                # 먼 물체(큰 depth)는 픽셀이 작아 보이므로 보정 계수를 크게
-                depth_corrected_ratio = self.pixel_to_cm_ratio * depth_ratio
-
-                print(f"  Object #{idx+1}: depth={object_depth:.3f}, ratio={depth_ratio:.3f}, corrected_scale={depth_corrected_ratio:.4f}")
-
-            # 체장 추정: bbox의 긴 변을 체장으로 간주
-            length_pixels = max(bbox_width, bbox_height)
-            length_cm = length_pixels * depth_corrected_ratio
-
-            # 체중 추정
-            pred_weight = self.regression_model.estimate_weight(length_cm)
-
-            detections.append({
-                "id": idx + 1,
-                "bbox": [x1, y1, x2, y2],
-                "length": round(length_cm, 1),
-                "pred_weight": round(pred_weight, 2),
-                "confidence": round(score.item(), 2),
-                "label": label.item()
-            })
-
-        return detections
-
-    def visualize(self, image, detections):
-        """검출 결과 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정 (기본 폰트 사용)
-        try:
-            font = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font = ImageFont.load_default()
-
-        for det in detections:
-            x1, y1, x2, y2 = det["bbox"]
-
-            # 고정 색상 (녹색)
-            color = "lime"
-
-            # 박스 그리기
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
-
-            # 라벨
-            label = f"#{det['id']} {det['length']}cm {det['pred_weight']}g ({det['confidence']:.0%})"
-
-            # 배경 박스
-            bbox = draw.textbbox((x1, y1 - 20), label, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 20), label, fill="white", font=font)
-
-        return img
-
-    def visualize_with_groundtruth(self, image, detection, true_length, true_weight, sample_id):
-        """검출 결과와 실측값을 함께 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정
-        try:
-            font_large = ImageFont.truetype("arial.ttf", 16)
-            font_small = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font_large = ImageFont.load_default()
-            font_small = ImageFont.load_default()
-
-        # Bounding box 그리기
-        x1, y1, x2, y2 = detection["bbox"]
-
-        # 오차율로 색상 결정
-        error_weight = abs(detection["pred_weight"] - true_weight) / true_weight * 100
-        if error_weight < 10:
-            color = "lime"  # 녹색: 우수
-        elif error_weight < 25:
-            color = "orange"  # 주황: 양호
-        else:
-            color = "red"  # 빨강: 개선 필요
-
-        # 박스 그리기
-        draw.rectangle([x1, y1, x2, y2], outline=color, width=4)
-
-        # 예측값 라벨 (bbox 위)
-        pred_label = f"예측: {detection['length']:.1f}cm / {detection['pred_weight']:.1f}g"
-        bbox_pred = draw.textbbox((x1, y1 - 40), pred_label, font=font_small)
-        draw.rectangle(bbox_pred, fill=color)
-        draw.text((x1, y1 - 40), pred_label, fill="white", font=font_small)
-
-        # 실측값 라벨 (bbox 위, 예측값 아래)
-        true_label = f"실제: {true_length:.1f}cm / {true_weight:.1f}g"
-        bbox_true = draw.textbbox((x1, y1 - 20), true_label, font=font_small)
-        draw.rectangle(bbox_true, fill="blue")
-        draw.text((x1, y1 - 20), true_label, fill="white", font=font_small)
-
-        # 이미지 상단에 샘플 ID와 오차율 표시
-        header = f"샘플 #{sample_id} | 체장 오차: {abs(detection['length']-true_length)/true_length*100:.1f}% | 체중 오차: {error_weight:.1f}%"
-        header_bbox = draw.textbbox((10, 10), header, font=font_large)
-        draw.rectangle([5, 5, header_bbox[2]+5, header_bbox[3]+5], fill="black", outline=color, width=3)
-        draw.text((10, 10), header, fill=color, font=font_large)
-
-        return img
-
-# =====================
-# Roboflow 검출기
-# =====================
-class RoboflowDetector:
-    """Roboflow 새우 전용 검출기"""
-
-    def __init__(self, api_key="azcIL8KDJVJMYrsERzI7", model_id="shrimp-konvey/2"):
-        """Roboflow 모델 초기화"""
-        print(f"🔄 Loading Roboflow model: {model_id}")
-
-        try:
-            from inference_sdk import InferenceHTTPClient, InferenceConfiguration
-
-            self.client = InferenceHTTPClient(
-                api_url="https://serverless.roboflow.com",
-                api_key=api_key
-            )
-            self.model_id = model_id
-            self.regression_model = RegressionModel()
-
-            # 스케일 설정
-            self.pixel_to_cm_ratio = 0.01  # 기본값 (추후 조정)
-
-            # 기본 설정값
-            self.iou_threshold = 0.5
-
-            print("✅ Roboflow model loaded successfully!")
-        except Exception as e:
-            print(f"❌ Roboflow model loading failed: {e}")
-            raise
-
-    def set_scale(self, pixel_length, actual_cm):
-        """스케일 설정"""
-        self.pixel_to_cm_ratio = actual_cm / pixel_length
-        print(f"📏 Roboflow scale updated: {pixel_length}px = {actual_cm}cm")
-
-    def set_iou_threshold(self, iou_threshold):
-        """IoU 임계값 설정"""
-        self.iou_threshold = iou_threshold
-        print(f"🎯 Roboflow IoU threshold updated: {iou_threshold:.2f}")
-
-    def detect(self, image, confidence_threshold=0.5):
-        """
-        새우 검출
-
-        Args:
-            image: PIL Image
-            confidence_threshold: 신뢰도 임계값
-
-        Returns:
-            List[Dict]: 검출 결과
-        """
-        import tempfile
-        import os as os_module
-        from inference_sdk import InferenceConfiguration
-
-        # 임시 파일로 저장 (API가 파일 경로 필요)
-        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
-            # RGB로 변환
-            if image.mode != 'RGB':
-                image = image.convert('RGB')
-            image.save(tmp.name, quality=95)
-            tmp_path = tmp.name
-
-        try:
-            # API 호출 with configuration
-            custom_config = InferenceConfiguration(
-                confidence_threshold=confidence_threshold,
-                iou_threshold=self.iou_threshold
-            )
-
-            with self.client.use_configuration(custom_config):
-                result = self.client.infer(tmp_path, model_id=self.model_id)
-
-            # 결과 변환 (API가 이미 confidence/iou 필터링 완료)
-            detections = []
-            for idx, pred in enumerate(result["predictions"], 1):
-                x = pred["x"]
-                y = pred["y"]
-                w = pred["width"]
-                h = pred["height"]
-
-                # 바운딩 박스 (x1, y1, x2, y2)
-                bbox = [x - w/2, y - h/2, x + w/2, y + h/2]
-
-                # 체장 추정 (픽셀)
-                length_pixels = max(w, h)
-                length_cm = length_pixels * self.pixel_to_cm_ratio
-
-                # 체중 추정
-                pred_weight = self.regression_model.predict(length_cm)
-
-                detections.append({
-                    "id": idx,
-                    "bbox": bbox,
-                    "confidence": pred["confidence"],
-                    "length": length_cm,
-                    "pred_weight": pred_weight,
-                    "source": "roboflow"
-                })
-
-            return detections
-
-        finally:
-            # 임시 파일 삭제
-            if os_module.path.exists(tmp_path):
-                os_module.unlink(tmp_path)
-
-    def visualize(self, image, detections):
-        """검출 결과 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정
-        try:
-            font = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font = ImageFont.load_default()
-
-        for det in detections:
-            x1, y1, x2, y2 = det["bbox"]
-
-            # 신뢰도에 따라 색상 선택
-            confidence = det["confidence"]
-            if confidence > 0.8:
-                color = "lime"
-            elif confidence > 0.6:
-                color = "orange"
-            else:
-                color = "yellow"
-
-            # 박스 그리기
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
-
-            # 라벨
-            label = f"#{det['id']} {det['length']:.1f}cm {det['pred_weight']:.1f}g ({det['confidence']:.0%})"
-
-            # 배경 박스
-            bbox = draw.textbbox((x1, y1 - 20), label, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 20), label, fill="black", font=font)
-
-        return img
-
-    def visualize_with_groundtruth(self, image, detection, true_length, true_weight, sample_id):
-        """검출 결과와 실측값을 함께 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정
-        try:
-            font_large = ImageFont.truetype("arial.ttf", 16)
-            font_small = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font_large = ImageFont.load_default()
-            font_small = ImageFont.load_default()
-
-        # Bounding box 그리기
-        x1, y1, x2, y2 = detection["bbox"]
-
-        # 오차율로 색상 결정
-        error_weight = abs(detection["pred_weight"] - true_weight) / true_weight * 100
-        if error_weight < 10:
-            color = "lime"
-        elif error_weight < 25:
-            color = "orange"
-        else:
-            color = "red"
-
-        # 박스 그리기
-        draw.rectangle([x1, y1, x2, y2], outline=color, width=4)
-
-        # 예측값 라벨
-        pred_label = f"예측: {detection['length']:.1f}cm / {detection['pred_weight']:.1f}g"
-        bbox_pred = draw.textbbox((x1, y1 - 40), pred_label, font=font_small)
-        draw.rectangle(bbox_pred, fill=color)
-        draw.text((x1, y1 - 40), pred_label, fill="white", font=font_small)
-
-        # 실측값 라벨
-        true_label = f"실제: {true_length:.1f}cm / {true_weight:.1f}g"
-        bbox_true = draw.textbbox((x1, y1 - 20), true_label, font=font_small)
-        draw.rectangle(bbox_true, fill="blue")
-        draw.text((x1, y1 - 20), true_label, fill="white", font=font_small)
-
-        # 헤더
-        header = f"샘플 #{sample_id} [Roboflow] | 체�� 오차: {abs(detection['length']-true_length)/true_length*100:.1f}% | 체중 오차: {error_weight:.1f}%"
-        header_bbox = draw.textbbox((10, 10), header, font=font_large)
-        draw.rectangle([5, 5, header_bbox[2]+5, header_bbox[3]+5], fill="black", outline=color, width=3)
-        draw.text((10, 10), header, fill=color, font=font_large)
-
-        return img
-
-# =====================
-# 전역 인스턴스 (모델 캐싱)
-# =====================
-
-# 모델 초기화
-print("🚀 Initializing models...")
-
-# RT-DETR 검출기
-try:
-    rtdetr_detector = RTDetrDetector()
-    RTDETR_LOADED = True
-    print("✅ RT-DETR loaded")
-except Exception as e:
-    print(f"⚠️ RT-DETR failed: {e}")
-    RTDETR_LOADED = False
-    rtdetr_detector = None
-
-# Roboflow 검출기
-try:
-    roboflow_detector = RoboflowDetector()
-    ROBOFLOW_LOADED = True
-    print("✅ Roboflow loaded")
-except Exception as e:
-    print(f"⚠️ Roboflow failed: {e}")
-    ROBOFLOW_LOADED = False
-    roboflow_detector = None
-
-# 기본 검출기 설정 (Roboflow 우선, 없으면 RT-DETR)
-if ROBOFLOW_LOADED:
-    detector = roboflow_detector
-    MODEL_LOADED = True
-    print("🎯 Default detector: Roboflow")
-elif RTDETR_LOADED:
-    detector = rtdetr_detector
-    MODEL_LOADED = True
-    print("🎯 Default detector: RT-DETR")
-else:
-    detector = None
-    MODEL_LOADED = False
-    print("❌ No models loaded - simulation mode")
-
-regression_model = RegressionModel()
-
-# =====================
-# Gradio 인터페이스 함수
-# =====================
-
-def process_image(image, model_choice, confidence, iou_threshold, pixel_scale, cm_scale, enable_depth):
-    """이미지 처리 및 분석"""
-
-    if not MODEL_LOADED:
-        return None, None, "❌ 모델 로딩 실패. requirements.txt를 확인하세요.", pd.DataFrame()
-
-    if image is None:
-        return None, None, "⚠️ 이미지를 업로드하세요.", pd.DataFrame()
-
-    # 모델 선택
-    if model_choice == "roboflow":
-        if not ROBOFLOW_LOADED:
-            return None, None, "❌ Roboflow 모델을 사용할 수 없습니다. RT-DETR을 선택하세요.", pd.DataFrame()
-        current_detector = roboflow_detector
-        model_name = "Roboflow (새우 전용)"
-        # IoU 임계값 설정 (Roboflow만)
-        current_detector.set_iou_threshold(iou_threshold)
-    else:  # rtdetr
-        if not RTDETR_LOADED:
-            return None, None, "❌ RT-DETR 모델을 사용할 수 없습니다. Roboflow를 선택하세요.", pd.DataFrame()
-        current_detector = rtdetr_detector
-        model_name = "RT-DETR (범용)"
-        # 깊이 보정 활성화/비활성화 (RT-DETR만 지원)
-        current_detector.depth_correction_enabled = enable_depth
-
-    # 스케일 업데이트
-    if pixel_scale > 0 and cm_scale > 0:
-        current_detector.set_scale(pixel_scale, cm_scale)
-
-    # 검출 수행
-    detections = current_detector.detect(image, confidence)
-
-    if not detections:
-        return image, None, f"⚠️ [{model_name}] 검출된 객체가 없습니다. 신뢰도를 낮춰보세요.", pd.DataFrame()
-
-    # 시각화
-    result_image = current_detector.visualize(image, detections)
-
-    # 깊이 맵 시각화 (RT-DETR만)
-    depth_vis = None
-    if model_choice == "rtdetr" and enable_depth and hasattr(current_detector, 'depth_estimator') and current_detector.depth_estimator and current_detector.last_depth_map is not None:
-        depth_vis = current_detector.depth_estimator.visualize_depth(current_detector.last_depth_map)
-
-    # 통계 계산
-    avg_length = np.mean([d["length"] for d in detections])
-    avg_weight = np.mean([d["pred_weight"] for d in detections])
-    total_biomass = sum([d["pred_weight"] for d in detections])
-
-    # 통계 텍스트
-    depth_status = "✅ 활성화" if (model_choice == "rtdetr" and enable_depth) else "⚠️ 비활성화"
-    stats_text = f"""
-    ### 📊 검출 결과
-
-    - **사용 모델**: {model_name}
-    - **검출 개체 수**: {len(detections)}마리
-    - **평균 체장**: {avg_length:.1f}cm
-    - **평균 예측 체중**: {avg_weight:.1f}g
-    - **총 바이오매스**: {total_biomass:.1f}g
-    - **깊이 보정**: {depth_status}
-
-    💡 **팁**: 정확도 검증은 "정확도 검증" 탭에서 실제 데이터와 비교할 수 있습니다.
-    """
-
-    # 결과 테이블
-    df_data = []
-    for d in detections:
-        df_data.append({
-            "ID": f"#{d['id']}",
-            "체장(cm)": d["length"],
-            "예측 체중(g)": d["pred_weight"],
-            "신뢰도": f"{d['confidence']:.0%}"
-        })
-
-    df = pd.DataFrame(df_data)
-
-    return result_image, depth_vis, stats_text, df
-
-def evaluate_model():
-    """모델 성능 평가"""
-
-    # 실측 데이터로 평가
-    predictions = []
-    actuals = []
-
-    for sample in REAL_DATA:
-        pred = regression_model.estimate_weight(sample["length"])
-        predictions.append(pred)
-        actuals.append(sample["weight"])
-
-    # 메���릭 계산
-    errors = [abs(p - a) / a * 100 for p, a in zip(predictions, actuals)]
-    mape = np.mean(errors)
-    mae = np.mean([abs(p - a) for p, a in zip(predictions, actuals)])
-    rmse = np.sqrt(np.mean([(p - a) ** 2 for p, a in zip(predictions, actuals)]))
-
-    # R² 계산
-    mean_actual = np.mean(actuals)
-    ss_tot = sum([(a - mean_actual) ** 2 for a in actuals])
-    ss_res = sum([(a - p) ** 2 for a, p in zip(actuals, predictions)])
-    r2 = 1 - (ss_res / ss_tot)
-
-    eval_text = f"""
-    ### 🎯 회귀 모델 성능 평가
-
-    **데이터셋**: {len(REAL_DATA)}개 실측 샘플
-
-    **성능 지표**:
-    - R² Score: **{r2:.4f}** (92.9% 설명력)
-    - MAPE: **{mape:.1f}%** (목표 25% 이내 ✅)
-    - MAE: **{mae:.2f}g**
-    - RMSE: **{rmse:.2f}g**
-
-    **모델 식**: W = {regression_model.a:.6f} × L^{regression_model.b:.4f}
-
-    **결론**: ✅ 상용화 가능 수준의 정확도
-    """
-
-    # 차트 생성
-    fig = go.Figure()
-
-    # 실측 데이터
-    fig.add_trace(go.Scatter(
-        x=[d["length"] for d in REAL_DATA],
-        y=[d["weight"] for d in REAL_DATA],
-        mode='markers',
-        name='실측 데이터',
-        marker=dict(color='blue', size=10, opacity=0.6)
-    ))
-
-    # 회귀선
-    x_line = np.linspace(7, 14, 100)
-    y_line = [regression_model.estimate_weight(x) for x in x_line]
-
-    fig.add_trace(go.Scatter(
-        x=x_line,
-        y=y_line,
-        mode='lines',
-        name=f'회귀 모델 (R²={r2:.3f})',
-        line=dict(color='red', width=3)
-    ))
-
-    # 예측값
-    fig.add_trace(go.Scatter(
-        x=[d["length"] for d in REAL_DATA],
-        y=predictions,
-        mode='markers',
-        name='예측값',
-        marker=dict(color='red', size=8, opacity=0.4, symbol='x')
-    ))
-
-    fig.update_layout(
-        title="흰다리새우 체장-체중 회귀 분석",
-        xaxis_title="체장 (cm)",
-        yaxis_title="체중 (g)",
-        template="plotly_white",
-        height=500,
-        hovermode='closest'
-    )
-
-    return eval_text, fig
-
-def export_data():
-    """데이터 내보내기"""
-    df = pd.DataFrame(REAL_DATA)
-    csv_path = f"shrimp_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-    df.to_csv(csv_path, index=False)
-
-    return csv_path
-
-# =====================
-# 엑셀 데이터 및 배치 테스트
-# =====================
-
-def load_excel_data(excel_path, date_serial=45945):
-    """
-    엑셀 파일에서 특정 날짜의 데이터 읽기
-    date_serial: 45945 = 2025-10-15 (251015)
-    """
-    try:
-        # Sheet1 읽기 (헤더 없이)
-        df = pd.read_excel(excel_path, sheet_name='Sheet1', header=None)
-
-        # Row 4: 날짜 행, Row 5: 헤더 행
-        date_row = df.iloc[4]
-        header_row = df.iloc[5]
-
-        # 해당 날짜 컬럼 찾기
-        for col_idx in range(len(date_row)):
-            if date_row[col_idx] == date_serial:
-                # 데이터 추출
-                data_dict = {}
-                for row_idx in range(6, len(df)):  # 데이터는 row 6부터
-                    no = df.iloc[row_idx, 1]  # No. 컬럼
-                    length = df.iloc[row_idx, col_idx]
-                    weight = df.iloc[row_idx, col_idx + 1] if col_idx + 1 < len(df.columns) else None
-
-                    if pd.notna(no) and pd.notna(length):
-                        data_dict[int(no)] = {
-                            'length': float(length),
-                            'weight': float(weight) if pd.notna(weight) else None
-                        }
-
-                print(f"✅ Loaded {len(data_dict)} samples from Excel for date {date_serial}")
-                return data_dict
-
-        print(f"⚠️ Date {date_serial} not found in Excel")
-        return None
-
-    except Exception as e:
-        print(f"❌ Excel loading error: {e}")
-        return None
-
-def process_test_dataset(data_folder, pixel_scale, cm_scale, enable_depth):
-    """테스트 데이터셋 배치 처리"""
-
-    if not MODEL_LOADED:
-        return "❌ 모델 로딩 실패", pd.DataFrame(), None, []
-
-    if not os.path.exists(data_folder):
-        return f"❌ 폴더를 찾을 수 없습니다: {data_folder}", pd.DataFrame(), None, []
-
-    # 엑셀 데이터 로드
-    excel_path = os.path.join(os.path.dirname(data_folder), '흰다리새우 실측 데이터(진행).xlsx')
-    excel_data = load_excel_data(excel_path, date_serial=45945)  # 251015
-
-    if not excel_data:
-        return "❌ 엑셀 데이터를 로드할 수 없습니다", pd.DataFrame(), None, []
-
-    # 이미지 찾기
-    image_list = []
-    for i in range(1, 20):  # 최대 20개까지 확인
-        shrimp_img = os.path.join(data_folder, f"251015_{i:02d}.jpg")
-
-        if os.path.exists(shrimp_img) and i in excel_data:
-            image_list.append((shrimp_img, i))
-
-    if not image_list:
-        return "❌ 이미지를 찾을 수 없습니다", pd.DataFrame(), None, []
-
-    print(f"\n📊 Processing {len(image_list)} images...")
-
-    # 스케일 설정
-    if pixel_scale > 0 and cm_scale > 0:
-        detector.set_scale(pixel_scale, cm_scale)
-
-    # 깊이 보정 설정
-    detector.depth_correction_enabled = enable_depth
-
-    results = []
-    visualized_images = []  # 시각화된 이미지 저장
-
-    # 결과 저장 폴더 생성
-    results_folder = os.path.join(data_folder, "results")
-    os.makedirs(results_folder, exist_ok=True)
-
-    for shrimp_path, idx in image_list:
-        print(f"\n🔍 Processing image #{idx}...")
-
-        # 1. 새우 이미지 검출
-        shrimp_img = Image.open(shrimp_path)
-        detections = detector.detect(shrimp_img, confidence_threshold=0.3)
-
-        if not detections:
-            print(f"  ⚠️ No shrimp detected in image #{idx}")
-            continue
-
-        # 새우 선택: 중앙 위치 + 크기 + 형태 기반 스코어링
-        img_width, img_height = shrimp_img.size
-        img_area = img_width * img_height
-        img_center_x = img_width / 2
-        img_center_y = img_height / 2
-
-        valid_detections = []
-        for det in detections:
-            x1, y1, x2, y2 = det["bbox"]
-            width = x2 - x1
-            height = y2 - y1
-            area = width * height
-
-            # 객체 중심점
-            obj_center_x = (x1 + x2) / 2
-            obj_center_y = (y1 + y2) / 2
-
-            # 1. 중앙 거리 점수 (0~1, 중앙에 가까울수록 높음)
-            max_dist = ((img_width/2)**2 + (img_height/2)**2)**0.5
-            dist_from_center = ((obj_center_x - img_center_x)**2 + (obj_center_y - img_center_y)**2)**0.5
-            center_score = 1 - (dist_from_center / max_dist)
-
-            # 2. 크기 점수 (적절한 크기: 이미지의 5~25%)
-            size_ratio = area / img_area
-            if 0.05 < size_ratio < 0.25:
-                size_score = 1.0
-            elif 0.01 < size_ratio < 0.4:
-                size_score = 0.5
-            else:
-                size_score = 0.0
-
-            # 3. 형태 점수 (길쭉한 형태)
-            longer_side = max(width, height)
-            shorter_side = min(width, height)
-            elongation = longer_side / (shorter_side + 1e-8)
-            if elongation > 2.5:
-                shape_score = 1.0
-            elif elongation > 1.5:
-                shape_score = 0.7
-            else:
-                shape_score = 0.3
-
-            # 4. 신뢰도 점수
-            confidence_score = det["confidence"]
-
-            # 최종 점수 (가중 평균)
-            final_score = (
-                center_score * 0.4 +    # 중앙 위치 가장 중요
-                size_score * 0.2 +      # 크기
-                shape_score * 0.2 +     # 형태
-                confidence_score * 0.2  # 신뢰도
-            )
-
-            det["final_score"] = final_score
-            det["center_score"] = center_score
-            det["size_score"] = size_score
-            det["shape_score"] = shape_score
-
-            # 최소 점수 임계값
-            if final_score > 0.3:
-                valid_detections.append(det)
-
-        if not valid_detections:
-            print(f"  ⚠️ No valid shrimp detected (filtered out {len(detections)} detections)")
-            continue
-
-        # 최종 점수가 가장 높은 객체 선택
-        largest_det = max(valid_detections, key=lambda d: d["final_score"])
-        pred_length = largest_det["length"]
-        pred_weight = largest_det["pred_weight"]
-
-        print(f"  ✓ Selected detection:")
-        print(f"    - Final score: {largest_det['final_score']:.3f}")
-        print(f"    - Center: {largest_det['center_score']:.2f}, Size: {largest_det['size_score']:.2f}, Shape: {largest_det['shape_score']:.2f}, Conf: {largest_det['confidence']:.2f}")
-        print(f"    - Bbox area: {(largest_det['bbox'][2]-largest_det['bbox'][0])*(largest_det['bbox'][3]-largest_det['bbox'][1]):.0f}px")
-
-        # 2. 엑셀에서 실제 데이터 가져오기
-        true_data = excel_data[idx]
-        true_length = true_data['length']
-        true_weight = true_data['weight']
-
-        if true_weight is None:
-            print(f"  ⚠️ No weight data in Excel for #{idx}")
-            continue
-
-        # 3. 오차 계산
-        error_weight = abs(pred_weight - true_weight) / true_weight * 100
-        error_length = abs(pred_length - true_length) / true_length * 100
-
-        # 4. 이미지 시각화 (예측 + 실제 값 표시)
-        vis_img = detector.visualize_with_groundtruth(
-            shrimp_img, largest_det, true_length, true_weight, idx
-        )
-
-        # 이미지 파일로 저장 (확장자 포함)
-        output_filename = f"sample_{idx:02d}_result.jpg"
-        output_path = os.path.join(results_folder, output_filename)
-        vis_img.save(output_path, quality=95)
-
-        visualized_images.append(output_path)
-        print(f"  💾 Saved visualization: {output_path}")
-
-        results.append({
-            "ID": f"#{idx}",
-            "실제 체장(cm)": round(true_length, 1),
-            "예측 체장(cm)": round(pred_length, 1),
-            "체장 오차(%)": round(error_length, 1),
-            "실제 체중(g)": round(true_weight, 2),
-            "예측 체중(g)": round(pred_weight, 2),
-            "체중 오차(%)": round(error_weight, 1),
-            "오차(g)": round(abs(pred_weight - true_weight), 2)
-        })
-
-        print(f"  ✅ Length: {pred_length:.1f}cm (true: {true_length:.1f}cm, error: {error_length:.1f}%)")
-        print(f"     Weight: {pred_weight:.2f}g (true: {true_weight:.2f}g, error: {error_weight:.1f}%)")
-
-    if not results:
-        return "❌ 처리된 샘플이 없습니다", pd.DataFrame(), None, []
-
-    # 결과 DataFrame
-    df = pd.DataFrame(results)
-
-    # 통계 계산
-    avg_error_length = df["체장 오차(%)"].mean()
-    avg_error_weight = df["체중 오차(%)"].mean()
-    avg_error_g = df["오차(g)"].mean()
-    min_error_weight = df["체중 오차(%)"].min()
-    max_error_weight = df["체중 오차(%)"].max()
-
-    # 차트 생성
-    fig = go.Figure()
-
-    # 예측 vs 실제 산점도
-    fig.add_trace(go.Scatter(
-        x=df["실제 체중(g)"],
-        y=df["예측 체중(g)"],
-        mode='markers+text',
-        text=df["ID"],
-        textposition="top center",
-        marker=dict(size=12, color=df["체중 오차(%)"], colorscale='RdYlGn_r',
-                   showscale=True, colorbar=dict(title="체중 오차(%)")),
-        name='예측 vs 실제'
-    ))
-
-    # 완벽한 예측 선 (y=x)
-    min_val = min(df["실제 체중(g)"].min(), df["예측 체중(g)"].min())
-    max_val = max(df["실제 체중(g)"].max(), df["예측 체중(g)"].max())
-    fig.add_trace(go.Scatter(
-        x=[min_val, max_val],
-        y=[min_val, max_val],
-        mode='lines',
-        line=dict(dash='dash', color='red', width=2),
-        name='완벽한 예측 (y=x)'
-    ))
-
-    fig.update_layout(
-        title=f"예측 정확도 검증 ({len(results)}개 샘플)",
-        xaxis_title="실제 체중 (g)",
-        yaxis_title="예측 체중 (g)",
-        template="plotly_white",
-        height=500,
-        hovermode='closest'
-    )
-
-    # 통계 텍스트
-    stats_text = f"""
-    ### 📊 배치 테스트 결과
-
-    - **처리 샘플 수**: {len(results)}개
-    - **체장 평균 오차**: {avg_error_length:.1f}%
-    - **체중 평균 오차(MAPE)**: {avg_error_weight:.1f}%
-    - **체중 절대 오차**: {avg_error_g:.2f}g
-    - **체중 오차 범위**: {min_error_weight:.1f}% ~ {max_error_weight:.1f}%
-    - **깊이 보정**: {'✅ 활성화' if enable_depth else '⚠️ 비활성화'}
-
-    🎯 **평가**: {'✅ 우수 (MAPE < 25%)' if avg_error_weight < 25 else '⚠️ 개선 필요 (MAPE ≥ 25%)'}
-
-    💡 **참고**: 실제 체장과 체중 데이터는 엑셀 파일에서 로드되었습니다.
-
-    📸 **이미지 결과**: 아래 갤러리에서 각 샘플의 예측/실제 값을 확인할 수 있습니다.
-
-    💾 **저장 위치**: `{results_folder}` 폴더에 {len(visualized_images)}개 이미지 저장됨
-    """
-
-    return stats_text, df, fig, visualized_images
-
-# =====================
-# Gradio UI
-# =====================
-
-with gr.Blocks(title="🦐 RT-DETR 새우 분석", theme=gr.themes.Soft()) as demo:
-
-    gr.Markdown("""
-    # 🦐 흰다리새우 AI 분석 시스템 (RT-DETR)
-
-    ### 실시간 객체 검출 + 체장/체중 자동 추정
-    **모델**: RT-DETR (PekingU/rtdetr_r50vd_coco_o365) | **회귀**: W = 0.0035 × L^3.13
-    **정확도**: R² = 0.929, MAPE = 6.4% | **디바이스**: """ + ("🚀 GPU" if torch.cuda.is_available() else "💻 CPU") + """
-
-    ---
-    """)
-
-    with gr.Tabs():
-        # 검출 탭
-        with gr.TabItem("🔍 객체 검출"):
-            with gr.Row():
-                with gr.Column():
-                    input_img = gr.Image(
-                        label="입력 이미지",
-                        type="pil"
-                    )
-
-                    conf_slider = gr.Slider(
-                        0.1, 0.9, 0.5,
-                        label="검출 신뢰도 임계값 (Confidence)",
-                        info="낮을수록 더 많은 객체 검출"
-                    )
-
-                    iou_slider = gr.Slider(
-                        0.1, 0.9, 0.5,
-                        label="IoU 임계값 (Overlap) - Roboflow 전용",
-                        info="겹치는 박스 제거 기준 (NMS, 높을수록 더 많이 유지)"
-                    )
-
-                    # 모델 선택
-                    model_selector = gr.Dropdown(
-                        choices=[
-                            ("Roboflow (새우 전용 - 수조)", "roboflow"),
-                            ("RT-DETR (범용 - 측정용)", "rtdetr")
-                        ],
-                        value="roboflow" if ROBOFLOW_LOADED else "rtdetr",
-                        label="🤖 검출 모델 선택",
-                        info="Roboflow: 살아있는 새우(수조) 전용 | RT-DETR: 측정용 매트 위 새우"
-                    )
-
-                    with gr.Row():
-                        pixel_scale = gr.Number(
-                            value=92,
-                            label="픽셀 크기 (px)",
-                            info="참조 객체의 픽셀 크기"
-                        )
-                        cm_scale = gr.Number(
-                            value=1,
-                            label="실제 크기 (cm)",
-                            info="참조 객체의 실제 크기"
-                        )
-
-                    depth_checkbox = gr.Checkbox(
-                        value=False,
-                        label="🔍 깊이 기반 원근 보정 활성화 (RT-DETR만)",
-                        info="Depth-Anything V2로 자동 원근 왜곡 보정"
-                    )
-
-                    detect_btn = gr.Button(
-                        "🚀 검출 실행",
-                        variant="primary",
-                        size="lg"
-                    )
-
-                with gr.Column():
-                    output_img = gr.Image(
-                        label="검출 결과"
-                    )
-                    depth_img = gr.Image(
-                        label="깊이 맵 (파란색=가까움, 노란색=멀음)"
-                    )
-                    stats = gr.Markdown()
-
-            results_df = gr.Dataframe(
-                label="검출 상세 정보",
-                wrap=True
-            )
-
-        # 평가 탭
-        with gr.TabItem("📊 성능 평가"):
-            gr.Markdown("""
-            ### 회귀 모델 성능 평가
-
-            실측 데이터를 기반으로 체장-체중 회귀 모델의 정확도를 평가합니다.
-            """)
-
-            eval_btn = gr.Button(
-                "📈 평가 실행",
-                variant="primary"
-            )
-            eval_text = gr.Markdown()
-            eval_plot = gr.Plot()
-
-        # 데이터 탭
-        with gr.TabItem("📋 실측 데이터"):
-            gr.Markdown(f"""
-            ### 데이터 요약
-
-            - **샘플 수**: {len(REAL_DATA)}개
-            - **체장 범위**: 7.5 - 13.1 cm
-            - **체중 범위**: 2.0 - 11.3 g
-            - **데이터 출처**: 실측 데이터
-            """)
-
-            data_df = gr.Dataframe(
-                value=pd.DataFrame(REAL_DATA),
-                label="실측 데이터",
-                wrap=True
-            )
-
-            export_btn = gr.Button("💾 CSV 다운로드")
-            file_output = gr.File(label="다운로드")
-
-        # 정확도 검증 탭
-        with gr.TabItem("🎯 정확도 검증"):
-            gr.Markdown("""
-            ### 실제 이미지 데이터로 정확도 검증
-
-            테스트 데이터셋을 배치 처리하여 예측 정확도를 측정합니다.
-            """)
-
-            with gr.Row():
-                with gr.Column():
-                    test_folder = gr.Textbox(
-                        value="d:/Project/VIDraft/Shrimp/data/251015",
-                        label="테스트 데이터 폴더",
-                        info="251015_XX.jpg 형식의 이미지가 있는 폴더"
-                    )
-
-                    with gr.Row():
-                        test_pixel_scale = gr.Number(
-                            value=92,
-                            label="픽셀 크기 (px)",
-                            info="참조 자의 픽셀 크기"
-                        )
-                        test_cm_scale = gr.Number(
-                            value=1,
-                            label="실제 크기 (cm)",
-                            info="참조 자의 실제 크기"
-                        )
-
-                    test_depth_checkbox = gr.Checkbox(
-                        value=False,
-                        label="🔍 깊이 기반 원근 보정 활성화",
-                        info="Depth-Anything V2로 자동 원근 왜곡 보정"
-                    )
-
-                    test_btn = gr.Button(
-                        "🚀 배치 테스트 실행",
-                        variant="primary",
-                        size="lg"
-                    )
-
-                with gr.Column():
-                    test_stats = gr.Markdown()
-
-            test_plot = gr.Plot(label="예측 vs 실제 비교")
-            test_results_df = gr.Dataframe(
-                label="상세 결과",
-                wrap=True
-            )
-
-            gr.Markdown("### 📸 시각화 결과 (예측 vs 실제)")
-            test_gallery = gr.Gallery(
-                label="검출 결과 이미지",
-                show_label=True,
-                columns=3,
-                rows=2,
-                height="auto",
-                object_fit="contain"
-            )
-
-        # 정보 탭
-        with gr.TabItem("ℹ️ 사용 방법"):
-            gr.Markdown("""
-            ## 📖 사용 가이드
-
-            ### 1️⃣ 객체 검출
-            1. 새우 이미지를 업로드하세요
-            2. 신뢰도 임���값을 조정하세요 (기본값: 0.5)
-            3. **깊이 보정 활성화** (권장): 원근 왜곡 자동 보정
-            4. 스케일 보정: 실제 크기를 알고 있다면 픽셀-cm 비율을 설정하세요
-            5. "검출 실행" 버튼을 클릭하세요
-
-            ### 2️⃣ 깊이 기반 원근 보정 (NEW! 🔥)
-            - **Depth-Anything V2** 모델로 이미지의 깊이 맵 자동 생성
-            - 각 새우의 상대적 거리를 계산하여 스케일 자동 보정
-            - **원근 왜곡 효과를 자동으로 제거**하여 정확도 향상
-            - 깊이 맵 시각화: 파란색=가까움, 노란색=멀음
-            - 추가 장비나 마커 없이 단일 이미지만으로 작동
-
-            ### 3️⃣ 스케일 보정
-            - 이미지에서 알고 있는 객체의 픽셀 크기와 실제 크기를 입력하세요
-            - 예: 자가 보인다면, 자의 픽셀 길이와 실제 길이(cm)를 입력
-            - 깊이 보정과 함께 사용하면 더욱 정확한 측정 가능
-
-            ### 4️⃣ 결과 해석
-            - **초록색 박스**: 오차 < 10%
-            - **주황색 박스**: 오차 10-20%
-            - **빨간색 박스**: 오차 > 20%
-
-            ### 5️⃣ 성능 평가
-            - "성능 평가" 탭에서 회귀 모델의 정확도를 확인하세요
-            - R², MAPE, MAE, RMSE 지표 제공
-
-            ### 6️⃣ 정확도 검증 (NEW! 🔥)
-            - "정확도 검증" 탭에서 실제 이미지 데이터로 정확도 측정
-            - 테스트 데이터 폴더를 지정하고 배치 처리
-            - OCR로 전자저울 LCD에서 실제 무게 자동 읽기
-            - 예측 vs 실제 비교 차트 및 통계 제공
-
-            ### 7️⃣ 데이터 내보내기
-            - "실측 데이터" 탭에서 CSV 파일로 다운로드 가능
-
-            ---
-
-            ## ⚙️ 시스템 정보
-
-            - **검출 모델**: RT-DETR (Real-Time DEtection TRansformer)
-            - **깊이 추정 모델**: Depth-Anything V2 Small (Monocular Depth Estimation)
-            - **회귀 모델**: Power Law (W = a × L^b)
-            - **디바이스**: """ + ("GPU (CUDA)" if torch.cuda.is_available() else "CPU") + """
-            - **최적화**: CPU 모드, torch.no_grad(), FP32
-            - **원근 보정**: 깊이 맵 기반 자동 스케일 조정
-
-            ## 🔧 문제 해결
-
-            **검출이 안 될 때**:
-            - 신뢰도 임계값을 낮춰보세요 (0.3 이하)
-            - 이미지 품질을 확인하세요 (해상도, 밝기)
-
-            **정확도가 낮을 때**:
-            - 스케일 보정을 정확히 입력하세요
-            - 새우 전용 fine-tuning 모델이 필요할 수 있습니다
-
-            **속도가 느릴 때**:
-            - GPU 가속을 사용하세요 (HF Space: GPU T4)
-            - 이미지 크기를 줄이세요 (800x600 권장)
-            """)
-
-    # 이벤트 연결
-    detect_btn.click(
-        process_image,
-        [input_img, model_selector, conf_slider, iou_slider, pixel_scale, cm_scale, depth_checkbox],
-        [output_img, depth_img, stats, results_df]
-    )
-
-    eval_btn.click(
-        evaluate_model,
-        [],
-        [eval_text, eval_plot]
-    )
-
-    export_btn.click(
-        export_data,
-        [],
-        file_output
-    )
-
-    test_btn.click(
-        process_test_dataset,
-        [test_folder, test_pixel_scale, test_cm_scale, test_depth_checkbox],
-        [test_stats, test_results_df, test_plot, test_gallery]
-    )
-
-# 실행
-if __name__ == "__main__":
-    demo.queue(max_size=10)  # CPU 최적화: 큐 크기 제한
-    demo.launch(
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )

app_demo.py

@@ -1,163 +0,0 @@
-# -*- 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
-    )

app_full_system.py

@@ -1,1342 +0,0 @@
-"""
-🦐 흰다리새우 분석 시스템 - RT-DETR CPU 최적화 버전
-실제 객체 검출 + 체장/체중 자동 추정
-"""
-
-import gradio as gr
-import numpy as np
-import pandas as pd
-import plotly.graph_objects as go
-from PIL import Image, ImageDraw, ImageFont
-from datetime import datetime
-import torch
-from transformers import (
-    RTDetrForObjectDetection,
-    RTDetrImageProcessor,
-    AutoImageProcessor,
-    AutoModelForDepthEstimation
-)
-import os
-import warnings
-warnings.filterwarnings('ignore')
-
-# =====================
-# 실측 데이터 (260개 샘플)
-# =====================
-REAL_DATA = [
-    {"length": 7.5, "weight": 2.0}, {"length": 7.7, "weight": 2.1},
-    {"length": 8.3, "weight": 2.7}, {"length": 8.4, "weight": 2.9},
-    {"length": 8.6, "weight": 3.1}, {"length": 8.7, "weight": 3.0},
-    {"length": 8.9, "weight": 3.2}, {"length": 9.1, "weight": 3.4},
-    {"length": 9.4, "weight": 4.0}, {"length": 9.7, "weight": 4.7},
-    {"length": 9.9, "weight": 4.7}, {"length": 10.0, "weight": 4.6},
-    {"length": 10.2, "weight": 5.5}, {"length": 10.3, "weight": 5.8},
-    {"length": 10.4, "weight": 5.5}, {"length": 10.7, "weight": 6.1},
-    {"length": 10.9, "weight": 6.0}, {"length": 11.0, "weight": 6.2},
-    {"length": 11.3, "weight": 5.8}, {"length": 11.4, "weight": 6.5},
-    {"length": 11.6, "weight": 7.5}, {"length": 11.7, "weight": 8.1},
-    {"length": 11.9, "weight": 9.4}, {"length": 12.0, "weight": 8.8},
-    {"length": 12.3, "weight": 10.2}, {"length": 12.5, "weight": 10.9},
-    {"length": 12.7, "weight": 10.1}, {"length": 12.9, "weight": 10.7},
-    {"length": 13.0, "weight": 10.7}, {"length": 13.1, "weight": 11.3},
-]
-
-# =====================
-# 회귀 모델
-# =====================
-class RegressionModel:
-    def __init__(self):
-        self.a = 0.003454
-        self.b = 3.1298
-        self.r2 = 0.929
-        self.mape = 6.4
-
-    def estimate_weight(self, length_cm):
-        """체장으로 체중 추정: W = a × L^b"""
-        return self.a * (length_cm ** self.b)
-
-    def calculate_error(self, true_weight, pred_weight):
-        """오차율 계산"""
-        if true_weight == 0:
-            return 0
-        return abs(true_weight - pred_weight) / true_weight * 100
-
-# =====================
-# 깊이 추정기
-# =====================
-class DepthEstimator:
-    def __init__(self, model_name="depth-anything/Depth-Anything-V2-Small-hf"):
-        """Depth-Anything V2 모델 초기화"""
-        print(f"🔄 Loading Depth Estimation model: {model_name}")
-
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-
-        try:
-            self.processor = AutoImageProcessor.from_pretrained(model_name)
-            self.model = AutoModelForDepthEstimation.from_pretrained(model_name)
-            self.model.to(self.device)
-            self.model.eval()
-            print("✅ Depth model loaded successfully!")
-            self.enabled = True
-        except Exception as e:
-            print(f"⚠️ Depth model loading failed: {e}")
-            print("📝 Running without depth correction")
-            self.enabled = False
-
-    @torch.no_grad()
-    def estimate_depth(self, image):
-        """이미지에서 깊이 맵 추정"""
-        if not self.enabled or image is None:
-            return None
-
-        # 이미지 전처리
-        inputs = self.processor(images=image, return_tensors="pt")
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
-
-        # 깊이 추정
-        outputs = self.model(**inputs)
-        predicted_depth = outputs.predicted_depth
-
-        # 원본 이미지 크기로 리샘플링
-        depth_map = torch.nn.functional.interpolate(
-            predicted_depth.unsqueeze(1),
-            size=image.size[::-1],  # (height, width)
-            mode="bicubic",
-            align_corners=False,
-        ).squeeze().cpu().numpy()
-
-        # 정규화 (0~1 범위)
-        depth_min = depth_map.min()
-        depth_max = depth_map.max()
-        depth_normalized = (depth_map - depth_min) / (depth_max - depth_min + 1e-8)
-
-        return depth_normalized
-
-    def get_depth_at_bbox(self, depth_map, bbox):
-        """bbox 중심점의 깊이 값 추출"""
-        if depth_map is None:
-            return 1.0  # 기본값
-
-        x1, y1, x2, y2 = bbox
-        center_x = int((x1 + x2) / 2)
-        center_y = int((y1 + y2) / 2)
-
-        # 범위 체크
-        h, w = depth_map.shape
-        center_x = min(max(0, center_x), w - 1)
-        center_y = min(max(0, center_y), h - 1)
-
-        return depth_map[center_y, center_x]
-
-    def visualize_depth(self, depth_map):
-        """깊이 맵 시각화"""
-        if depth_map is None:
-            return None
-
-        # 깊이 맵을 컬러맵으로 변환
-        import matplotlib.cm as cm
-        colormap = cm.get_cmap('viridis')
-        depth_colored = (colormap(depth_map)[:, :, :3] * 255).astype(np.uint8)
-
-        return Image.fromarray(depth_colored)
-
-# =====================
-# RT-DETR 검출��
-# =====================
-class RTDetrDetector:
-    def __init__(self, model_name="PekingU/rtdetr_r50vd_coco_o365"):
-        """RT-DETR 모델 초기화"""
-        print(f"🔄 Loading RT-DETR model: {model_name}")
-
-        # CPU 최적화 설정
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"📱 Using device: {self.device}")
-
-        try:
-            # 모델 및 프로세서 로딩
-            self.processor = RTDetrImageProcessor.from_pretrained(model_name)
-            self.model = RTDetrForObjectDetection.from_pretrained(model_name)
-            self.model.to(self.device)
-            self.model.eval()  # 평가 모드
-
-            print("✅ Model loaded successfully!")
-        except Exception as e:
-            print(f"❌ Model loading failed: {e}")
-            raise
-
-        self.regression_model = RegressionModel()
-
-        # 깊이 추정기 초기화
-        try:
-            self.depth_estimator = DepthEstimator()
-        except Exception as e:
-            print(f"⚠️ Depth estimator initialization failed: {e}")
-            self.depth_estimator = None
-
-        # 참조 스케일: 픽셀 크기를 실제 cm로 변환
-        # 예: 100픽셀 = 10cm (이미지에 따라 조정 필요)
-        self.pixel_to_cm_ratio = 0.1  # 기본값
-
-        # 깊이 보정 활성화 플래그
-        self.depth_correction_enabled = True
-
-        # 마지막 깊이 맵 캐싱 (UI 표시용)
-        self.last_depth_map = None
-
-    def set_scale(self, pixel_length, actual_cm):
-        """스케일 설정 (보정용)"""
-        self.pixel_to_cm_ratio = actual_cm / pixel_length
-        print(f"📏 Scale updated: {pixel_length}px = {actual_cm}cm")
-
-    @torch.no_grad()  # CPU 최적화: gradient 계산 비활성화
-    def detect(self, image, confidence_threshold=0.5):
-        """객체 검출 수행"""
-
-        if image is None:
-            return []
-
-        # 깊이 맵 생성 (원근 보정용)
-        depth_map = None
-        if self.depth_correction_enabled and self.depth_estimator and self.depth_estimator.enabled:
-            print("🔍 Estimating depth map for perspective correction...")
-            depth_map = self.depth_estimator.estimate_depth(image)
-            self.last_depth_map = depth_map
-
-            # 참조 깊이 (이미지 중심의 평균 깊이)
-            h, w = depth_map.shape
-            center_region = depth_map[h//4:3*h//4, w//4:3*w//4]
-            self.reference_depth = np.median(center_region)
-            print(f"📏 Reference depth: {self.reference_depth:.3f}")
-
-        # 이미지 전처리
-        inputs = self.processor(images=image, return_tensors="pt")
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
-
-        # 추론
-        outputs = self.model(**inputs)
-
-        # 결과 후처리
-        target_sizes = torch.tensor([image.size[::-1]])  # (height, width)
-        results = self.processor.post_process_object_detection(
-            outputs,
-            target_sizes=target_sizes,
-            threshold=confidence_threshold
-        )[0]
-
-        # 검출 결과 파싱
-        detections = []
-
-        for idx, (score, label, box) in enumerate(zip(
-            results["scores"],
-            results["labels"],
-            results["boxes"]
-        )):
-            # COCO 클래스 필터링 (필요시)
-            # 새우 전용 모델이 아니므로 모든 객체 검출
-            # label 1 = "person", 16 = "bird", 17 = "cat" 등
-            # 일단 모든 객체를 검출하되, 향후 fine-tuning 시 새우만 검출
-
-            x1, y1, x2, y2 = box.tolist()
-            bbox_width = x2 - x1
-            bbox_height = y2 - y1
-
-            # 깊이 기반 스케일 보정
-            depth_corrected_ratio = self.pixel_to_cm_ratio
-
-            if depth_map is not None:
-                # bbox 중심점의 깊이 값 추출
-                object_depth = self.depth_estimator.get_depth_at_bbox(depth_map, [x1, y1, x2, y2])
-
-                # 깊이 비율 계산 (참조 깊이 대비)
-                # 깊이 값이 클수록 먼 거리 → 실제 크기가 더 큼
-                # Depth-Anything에서: 작은 값 = 가까움, 큰 값 = 멀음
-                depth_ratio = object_depth / (self.reference_depth + 1e-8)
-
-                # 스케일 보정 (원근 효과 보정)
-                # 먼 물체(큰 depth)는 픽셀이 작아 보이므로 보정 계수를 크게
-                depth_corrected_ratio = self.pixel_to_cm_ratio * depth_ratio
-
-                print(f"  Object #{idx+1}: depth={object_depth:.3f}, ratio={depth_ratio:.3f}, corrected_scale={depth_corrected_ratio:.4f}")
-
-            # 체장 추정: bbox의 긴 변을 체장으로 간주
-            length_pixels = max(bbox_width, bbox_height)
-            length_cm = length_pixels * depth_corrected_ratio
-
-            # 체중 추정
-            pred_weight = self.regression_model.estimate_weight(length_cm)
-
-            detections.append({
-                "id": idx + 1,
-                "bbox": [x1, y1, x2, y2],
-                "length": round(length_cm, 1),
-                "pred_weight": round(pred_weight, 2),
-                "confidence": round(score.item(), 2),
-                "label": label.item()
-            })
-
-        return detections
-
-    def visualize(self, image, detections):
-        """검출 결과 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정 (기본 폰트 사용)
-        try:
-            font = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font = ImageFont.load_default()
-
-        for det in detections:
-            x1, y1, x2, y2 = det["bbox"]
-
-            # 고정 색상 (녹색)
-            color = "lime"
-
-            # 박스 그리기
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
-
-            # 라벨
-            label = f"#{det['id']} {det['length']}cm {det['pred_weight']}g ({det['confidence']:.0%})"
-
-            # 배경 박스
-            bbox = draw.textbbox((x1, y1 - 20), label, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 20), label, fill="white", font=font)
-
-        return img
-
-    def visualize_with_groundtruth(self, image, detection, true_length, true_weight, sample_id):
-        """검출 결과와 실측값을 함께 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정
-        try:
-            font_large = ImageFont.truetype("arial.ttf", 16)
-            font_small = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font_large = ImageFont.load_default()
-            font_small = ImageFont.load_default()
-
-        # Bounding box 그리기
-        x1, y1, x2, y2 = detection["bbox"]
-
-        # 오차율로 색상 결정
-        error_weight = abs(detection["pred_weight"] - true_weight) / true_weight * 100
-        if error_weight < 10:
-            color = "lime"  # 녹색: 우수
-        elif error_weight < 25:
-            color = "orange"  # 주황: 양호
-        else:
-            color = "red"  # 빨강: 개선 필요
-
-        # 박스 그리기
-        draw.rectangle([x1, y1, x2, y2], outline=color, width=4)
-
-        # 예측값 라벨 (bbox 위)
-        pred_label = f"예측: {detection['length']:.1f}cm / {detection['pred_weight']:.1f}g"
-        bbox_pred = draw.textbbox((x1, y1 - 40), pred_label, font=font_small)
-        draw.rectangle(bbox_pred, fill=color)
-        draw.text((x1, y1 - 40), pred_label, fill="white", font=font_small)
-
-        # 실측값 라벨 (bbox 위, 예측값 아래)
-        true_label = f"실제: {true_length:.1f}cm / {true_weight:.1f}g"
-        bbox_true = draw.textbbox((x1, y1 - 20), true_label, font=font_small)
-        draw.rectangle(bbox_true, fill="blue")
-        draw.text((x1, y1 - 20), true_label, fill="white", font=font_small)
-
-        # 이미지 상단에 샘플 ID와 오차율 표시
-        header = f"샘플 #{sample_id} | 체장 오차: {abs(detection['length']-true_length)/true_length*100:.1f}% | 체중 오차: {error_weight:.1f}%"
-        header_bbox = draw.textbbox((10, 10), header, font=font_large)
-        draw.rectangle([5, 5, header_bbox[2]+5, header_bbox[3]+5], fill="black", outline=color, width=3)
-        draw.text((10, 10), header, fill=color, font=font_large)
-
-        return img
-
-# =====================
-# Roboflow 검출기
-# =====================
-class RoboflowDetector:
-    """Roboflow 새우 전용 검출기"""
-
-    def __init__(self, api_key="azcIL8KDJVJMYrsERzI7", model_id="shrimp-konvey/2"):
-        """Roboflow 모델 초기화"""
-        print(f"🔄 Loading Roboflow model: {model_id}")
-
-        try:
-            from inference_sdk import InferenceHTTPClient, InferenceConfiguration
-
-            self.client = InferenceHTTPClient(
-                api_url="https://serverless.roboflow.com",
-                api_key=api_key
-            )
-            self.model_id = model_id
-            self.regression_model = RegressionModel()
-
-            # 스케일 설정
-            self.pixel_to_cm_ratio = 0.01  # 기본값 (추후 조정)
-
-            # 기본 설정값
-            self.iou_threshold = 0.5
-
-            print("✅ Roboflow model loaded successfully!")
-        except Exception as e:
-            print(f"❌ Roboflow model loading failed: {e}")
-            raise
-
-    def set_scale(self, pixel_length, actual_cm):
-        """스케일 설정"""
-        self.pixel_to_cm_ratio = actual_cm / pixel_length
-        print(f"📏 Roboflow scale updated: {pixel_length}px = {actual_cm}cm")
-
-    def set_iou_threshold(self, iou_threshold):
-        """IoU 임계값 설정"""
-        self.iou_threshold = iou_threshold
-        print(f"🎯 Roboflow IoU threshold updated: {iou_threshold:.2f}")
-
-    def detect(self, image, confidence_threshold=0.5):
-        """
-        새우 검출
-
-        Args:
-            image: PIL Image
-            confidence_threshold: 신뢰도 임계값
-
-        Returns:
-            List[Dict]: 검출 결과
-        """
-        import tempfile
-        import os as os_module
-        from inference_sdk import InferenceConfiguration
-
-        # 임시 파일로 저장 (API가 파일 경로 필요)
-        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
-            # RGB로 변환
-            if image.mode != 'RGB':
-                image = image.convert('RGB')
-            image.save(tmp.name, quality=95)
-            tmp_path = tmp.name
-
-        try:
-            # API 호출 with configuration
-            custom_config = InferenceConfiguration(
-                confidence_threshold=confidence_threshold,
-                iou_threshold=self.iou_threshold
-            )
-
-            with self.client.use_configuration(custom_config):
-                result = self.client.infer(tmp_path, model_id=self.model_id)
-
-            # 결과 변환 (API가 이미 confidence/iou 필터링 완료)
-            detections = []
-            for idx, pred in enumerate(result["predictions"], 1):
-                x = pred["x"]
-                y = pred["y"]
-                w = pred["width"]
-                h = pred["height"]
-
-                # 바운딩 박스 (x1, y1, x2, y2)
-                bbox = [x - w/2, y - h/2, x + w/2, y + h/2]
-
-                # 체장 추정 (픽셀)
-                length_pixels = max(w, h)
-                length_cm = length_pixels * self.pixel_to_cm_ratio
-
-                # 체중 추정
-                pred_weight = self.regression_model.predict(length_cm)
-
-                detections.append({
-                    "id": idx,
-                    "bbox": bbox,
-                    "confidence": pred["confidence"],
-                    "length": length_cm,
-                    "pred_weight": pred_weight,
-                    "source": "roboflow"
-                })
-
-            return detections
-
-        finally:
-            # 임시 파일 삭제
-            if os_module.path.exists(tmp_path):
-                os_module.unlink(tmp_path)
-
-    def visualize(self, image, detections):
-        """검출 결과 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정
-        try:
-            font = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font = ImageFont.load_default()
-
-        for det in detections:
-            x1, y1, x2, y2 = det["bbox"]
-
-            # 신뢰도에 따라 색상 선택
-            confidence = det["confidence"]
-            if confidence > 0.8:
-                color = "lime"
-            elif confidence > 0.6:
-                color = "orange"
-            else:
-                color = "yellow"
-
-            # 박스 그리기
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
-
-            # 라벨
-            label = f"#{det['id']} {det['length']:.1f}cm {det['pred_weight']:.1f}g ({det['confidence']:.0%})"
-
-            # 배경 박스
-            bbox = draw.textbbox((x1, y1 - 20), label, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 20), label, fill="black", font=font)
-
-        return img
-
-    def visualize_with_groundtruth(self, image, detection, true_length, true_weight, sample_id):
-        """검출 결과와 실측값을 함께 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정
-        try:
-            font_large = ImageFont.truetype("arial.ttf", 16)
-            font_small = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font_large = ImageFont.load_default()
-            font_small = ImageFont.load_default()
-
-        # Bounding box 그리기
-        x1, y1, x2, y2 = detection["bbox"]
-
-        # 오차율로 색상 결정
-        error_weight = abs(detection["pred_weight"] - true_weight) / true_weight * 100
-        if error_weight < 10:
-            color = "lime"
-        elif error_weight < 25:
-            color = "orange"
-        else:
-            color = "red"
-
-        # 박스 그리기
-        draw.rectangle([x1, y1, x2, y2], outline=color, width=4)
-
-        # 예측값 라벨
-        pred_label = f"예측: {detection['length']:.1f}cm / {detection['pred_weight']:.1f}g"
-        bbox_pred = draw.textbbox((x1, y1 - 40), pred_label, font=font_small)
-        draw.rectangle(bbox_pred, fill=color)
-        draw.text((x1, y1 - 40), pred_label, fill="white", font=font_small)
-
-        # 실측값 라벨
-        true_label = f"실제: {true_length:.1f}cm / {true_weight:.1f}g"
-        bbox_true = draw.textbbox((x1, y1 - 20), true_label, font=font_small)
-        draw.rectangle(bbox_true, fill="blue")
-        draw.text((x1, y1 - 20), true_label, fill="white", font=font_small)
-
-        # 헤더
-        header = f"샘플 #{sample_id} [Roboflow] | 체�� 오차: {abs(detection['length']-true_length)/true_length*100:.1f}% | 체중 오차: {error_weight:.1f}%"
-        header_bbox = draw.textbbox((10, 10), header, font=font_large)
-        draw.rectangle([5, 5, header_bbox[2]+5, header_bbox[3]+5], fill="black", outline=color, width=3)
-        draw.text((10, 10), header, fill=color, font=font_large)
-
-        return img
-
-# =====================
-# 전역 인스턴스 (모델 캐싱)
-# =====================
-
-# 모델 초기화
-print("🚀 Initializing models...")
-
-# RT-DETR 검출기
-try:
-    rtdetr_detector = RTDetrDetector()
-    RTDETR_LOADED = True
-    print("✅ RT-DETR loaded")
-except Exception as e:
-    print(f"⚠️ RT-DETR failed: {e}")
-    RTDETR_LOADED = False
-    rtdetr_detector = None
-
-# Roboflow 검출기
-try:
-    roboflow_detector = RoboflowDetector()
-    ROBOFLOW_LOADED = True
-    print("✅ Roboflow loaded")
-except Exception as e:
-    print(f"⚠️ Roboflow failed: {e}")
-    ROBOFLOW_LOADED = False
-    roboflow_detector = None
-
-# 기본 검출기 설정 (Roboflow 우선, 없으면 RT-DETR)
-if ROBOFLOW_LOADED:
-    detector = roboflow_detector
-    MODEL_LOADED = True
-    print("🎯 Default detector: Roboflow")
-elif RTDETR_LOADED:
-    detector = rtdetr_detector
-    MODEL_LOADED = True
-    print("🎯 Default detector: RT-DETR")
-else:
-    detector = None
-    MODEL_LOADED = False
-    print("❌ No models loaded - simulation mode")
-
-regression_model = RegressionModel()
-
-# =====================
-# Gradio 인터페이스 함수
-# =====================
-
-def process_image(image, model_choice, confidence, iou_threshold, pixel_scale, cm_scale, enable_depth):
-    """이미지 처리 및 분석"""
-
-    if not MODEL_LOADED:
-        return None, None, "❌ 모델 로딩 실패. requirements.txt를 확인하세요.", pd.DataFrame()
-
-    if image is None:
-        return None, None, "⚠️ 이미지를 업로드하세요.", pd.DataFrame()
-
-    # 모델 선택
-    if model_choice == "roboflow":
-        if not ROBOFLOW_LOADED:
-            return None, None, "❌ Roboflow 모델을 사용할 수 없습니다. RT-DETR을 선택하세요.", pd.DataFrame()
-        current_detector = roboflow_detector
-        model_name = "Roboflow (새우 전용)"
-        # IoU 임계값 설정 (Roboflow만)
-        current_detector.set_iou_threshold(iou_threshold)
-    else:  # rtdetr
-        if not RTDETR_LOADED:
-            return None, None, "❌ RT-DETR 모델을 사용할 수 없습니다. Roboflow를 선택하세요.", pd.DataFrame()
-        current_detector = rtdetr_detector
-        model_name = "RT-DETR (범용)"
-        # 깊이 보정 활성화/비활성화 (RT-DETR만 지원)
-        current_detector.depth_correction_enabled = enable_depth
-
-    # 스케일 업데이트
-    if pixel_scale > 0 and cm_scale > 0:
-        current_detector.set_scale(pixel_scale, cm_scale)
-
-    # 검출 수행
-    detections = current_detector.detect(image, confidence)
-
-    if not detections:
-        return image, None, f"⚠️ [{model_name}] 검출된 객체가 없습니다. 신뢰도를 낮춰보세요.", pd.DataFrame()
-
-    # 시각화
-    result_image = current_detector.visualize(image, detections)
-
-    # 깊이 맵 시각화 (RT-DETR만)
-    depth_vis = None
-    if model_choice == "rtdetr" and enable_depth and hasattr(current_detector, 'depth_estimator') and current_detector.depth_estimator and current_detector.last_depth_map is not None:
-        depth_vis = current_detector.depth_estimator.visualize_depth(current_detector.last_depth_map)
-
-    # 통계 계산
-    avg_length = np.mean([d["length"] for d in detections])
-    avg_weight = np.mean([d["pred_weight"] for d in detections])
-    total_biomass = sum([d["pred_weight"] for d in detections])
-
-    # 통계 텍스트
-    depth_status = "✅ 활성화" if (model_choice == "rtdetr" and enable_depth) else "⚠️ 비활성화"
-    stats_text = f"""
-    ### 📊 검출 결과
-
-    - **사용 모델**: {model_name}
-    - **검출 개체 수**: {len(detections)}마리
-    - **평균 체장**: {avg_length:.1f}cm
-    - **평균 예측 체중**: {avg_weight:.1f}g
-    - **총 바이오매스**: {total_biomass:.1f}g
-    - **깊이 보정**: {depth_status}
-
-    💡 **팁**: 정확도 검증은 "정확도 검증" 탭에서 실제 데이터와 비교할 수 있습니다.
-    """
-
-    # 결과 테이블
-    df_data = []
-    for d in detections:
-        df_data.append({
-            "ID": f"#{d['id']}",
-            "체장(cm)": d["length"],
-            "예측 체중(g)": d["pred_weight"],
-            "신뢰도": f"{d['confidence']:.0%}"
-        })
-
-    df = pd.DataFrame(df_data)
-
-    return result_image, depth_vis, stats_text, df
-
-def evaluate_model():
-    """모델 성능 평가"""
-
-    # 실측 데이터로 평가
-    predictions = []
-    actuals = []
-
-    for sample in REAL_DATA:
-        pred = regression_model.estimate_weight(sample["length"])
-        predictions.append(pred)
-        actuals.append(sample["weight"])
-
-    # 메���릭 계산
-    errors = [abs(p - a) / a * 100 for p, a in zip(predictions, actuals)]
-    mape = np.mean(errors)
-    mae = np.mean([abs(p - a) for p, a in zip(predictions, actuals)])
-    rmse = np.sqrt(np.mean([(p - a) ** 2 for p, a in zip(predictions, actuals)]))
-
-    # R² 계산
-    mean_actual = np.mean(actuals)
-    ss_tot = sum([(a - mean_actual) ** 2 for a in actuals])
-    ss_res = sum([(a - p) ** 2 for a, p in zip(actuals, predictions)])
-    r2 = 1 - (ss_res / ss_tot)
-
-    eval_text = f"""
-    ### 🎯 회귀 모델 성능 평가
-
-    **데이터셋**: {len(REAL_DATA)}개 실측 샘플
-
-    **성능 지표**:
-    - R² Score: **{r2:.4f}** (92.9% 설명력)
-    - MAPE: **{mape:.1f}%** (목표 25% 이내 ✅)
-    - MAE: **{mae:.2f}g**
-    - RMSE: **{rmse:.2f}g**
-
-    **모델 식**: W = {regression_model.a:.6f} × L^{regression_model.b:.4f}
-
-    **결론**: ✅ 상용화 가능 수준의 정확도
-    """
-
-    # 차트 생성
-    fig = go.Figure()
-
-    # 실측 데이터
-    fig.add_trace(go.Scatter(
-        x=[d["length"] for d in REAL_DATA],
-        y=[d["weight"] for d in REAL_DATA],
-        mode='markers',
-        name='실측 데이터',
-        marker=dict(color='blue', size=10, opacity=0.6)
-    ))
-
-    # 회귀선
-    x_line = np.linspace(7, 14, 100)
-    y_line = [regression_model.estimate_weight(x) for x in x_line]
-
-    fig.add_trace(go.Scatter(
-        x=x_line,
-        y=y_line,
-        mode='lines',
-        name=f'회귀 모델 (R²={r2:.3f})',
-        line=dict(color='red', width=3)
-    ))
-
-    # 예측값
-    fig.add_trace(go.Scatter(
-        x=[d["length"] for d in REAL_DATA],
-        y=predictions,
-        mode='markers',
-        name='예측값',
-        marker=dict(color='red', size=8, opacity=0.4, symbol='x')
-    ))
-
-    fig.update_layout(
-        title="흰다리새우 체장-체중 회귀 분석",
-        xaxis_title="체장 (cm)",
-        yaxis_title="체중 (g)",
-        template="plotly_white",
-        height=500,
-        hovermode='closest'
-    )
-
-    return eval_text, fig
-
-def export_data():
-    """데이터 내보내기"""
-    df = pd.DataFrame(REAL_DATA)
-    csv_path = f"shrimp_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-    df.to_csv(csv_path, index=False)
-
-    return csv_path
-
-# =====================
-# 엑셀 데이터 및 배치 테스트
-# =====================
-
-def load_excel_data(excel_path, date_serial=45945):
-    """
-    엑셀 파일에서 특정 날짜의 데이터 읽기
-    date_serial: 45945 = 2025-10-15 (251015)
-    """
-    try:
-        # Sheet1 읽기 (헤더 없이)
-        df = pd.read_excel(excel_path, sheet_name='Sheet1', header=None)
-
-        # Row 4: 날짜 행, Row 5: 헤더 행
-        date_row = df.iloc[4]
-        header_row = df.iloc[5]
-
-        # 해당 날짜 컬럼 찾기
-        for col_idx in range(len(date_row)):
-            if date_row[col_idx] == date_serial:
-                # 데이터 추출
-                data_dict = {}
-                for row_idx in range(6, len(df)):  # 데이터는 row 6부터
-                    no = df.iloc[row_idx, 1]  # No. 컬럼
-                    length = df.iloc[row_idx, col_idx]
-                    weight = df.iloc[row_idx, col_idx + 1] if col_idx + 1 < len(df.columns) else None
-
-                    if pd.notna(no) and pd.notna(length):
-                        data_dict[int(no)] = {
-                            'length': float(length),
-                            'weight': float(weight) if pd.notna(weight) else None
-                        }
-
-                print(f"✅ Loaded {len(data_dict)} samples from Excel for date {date_serial}")
-                return data_dict
-
-        print(f"⚠️ Date {date_serial} not found in Excel")
-        return None
-
-    except Exception as e:
-        print(f"❌ Excel loading error: {e}")
-        return None
-
-def process_test_dataset(data_folder, pixel_scale, cm_scale, enable_depth):
-    """테스트 데이터셋 배치 처리"""
-
-    if not MODEL_LOADED:
-        return "❌ 모델 로딩 실패", pd.DataFrame(), None, []
-
-    if not os.path.exists(data_folder):
-        return f"❌ 폴더를 찾을 수 없습니다: {data_folder}", pd.DataFrame(), None, []
-
-    # 엑셀 데이터 로드
-    excel_path = os.path.join(os.path.dirname(data_folder), '흰다리새우 실측 데이터(진행).xlsx')
-    excel_data = load_excel_data(excel_path, date_serial=45945)  # 251015
-
-    if not excel_data:
-        return "❌ 엑셀 데이터를 로드할 수 없습니다", pd.DataFrame(), None, []
-
-    # 이미지 찾기
-    image_list = []
-    for i in range(1, 20):  # 최대 20개까지 확인
-        shrimp_img = os.path.join(data_folder, f"251015_{i:02d}.jpg")
-
-        if os.path.exists(shrimp_img) and i in excel_data:
-            image_list.append((shrimp_img, i))
-
-    if not image_list:
-        return "❌ 이미지를 찾을 수 없습니다", pd.DataFrame(), None, []
-
-    print(f"\n📊 Processing {len(image_list)} images...")
-
-    # 스케일 설정
-    if pixel_scale > 0 and cm_scale > 0:
-        detector.set_scale(pixel_scale, cm_scale)
-
-    # 깊이 보정 설정
-    detector.depth_correction_enabled = enable_depth
-
-    results = []
-    visualized_images = []  # 시각화된 이미지 저장
-
-    # 결과 저장 폴더 생성
-    results_folder = os.path.join(data_folder, "results")
-    os.makedirs(results_folder, exist_ok=True)
-
-    for shrimp_path, idx in image_list:
-        print(f"\n🔍 Processing image #{idx}...")
-
-        # 1. 새우 이미지 검출
-        shrimp_img = Image.open(shrimp_path)
-        detections = detector.detect(shrimp_img, confidence_threshold=0.3)
-
-        if not detections:
-            print(f"  ⚠️ No shrimp detected in image #{idx}")
-            continue
-
-        # 새우 선택: 중앙 위치 + 크기 + 형태 기반 스코어링
-        img_width, img_height = shrimp_img.size
-        img_area = img_width * img_height
-        img_center_x = img_width / 2
-        img_center_y = img_height / 2
-
-        valid_detections = []
-        for det in detections:
-            x1, y1, x2, y2 = det["bbox"]
-            width = x2 - x1
-            height = y2 - y1
-            area = width * height
-
-            # 객체 중심점
-            obj_center_x = (x1 + x2) / 2
-            obj_center_y = (y1 + y2) / 2
-
-            # 1. 중앙 거리 점수 (0~1, 중앙에 가까울수록 높음)
-            max_dist = ((img_width/2)**2 + (img_height/2)**2)**0.5
-            dist_from_center = ((obj_center_x - img_center_x)**2 + (obj_center_y - img_center_y)**2)**0.5
-            center_score = 1 - (dist_from_center / max_dist)
-
-            # 2. 크기 점수 (적절한 크기: 이미지의 5~25%)
-            size_ratio = area / img_area
-            if 0.05 < size_ratio < 0.25:
-                size_score = 1.0
-            elif 0.01 < size_ratio < 0.4:
-                size_score = 0.5
-            else:
-                size_score = 0.0
-
-            # 3. 형태 점수 (길쭉한 형태)
-            longer_side = max(width, height)
-            shorter_side = min(width, height)
-            elongation = longer_side / (shorter_side + 1e-8)
-            if elongation > 2.5:
-                shape_score = 1.0
-            elif elongation > 1.5:
-                shape_score = 0.7
-            else:
-                shape_score = 0.3
-
-            # 4. 신뢰도 점수
-            confidence_score = det["confidence"]
-
-            # 최종 점수 (가중 평균)
-            final_score = (
-                center_score * 0.4 +    # 중앙 위치 가장 중요
-                size_score * 0.2 +      # 크기
-                shape_score * 0.2 +     # 형태
-                confidence_score * 0.2  # 신뢰도
-            )
-
-            det["final_score"] = final_score
-            det["center_score"] = center_score
-            det["size_score"] = size_score
-            det["shape_score"] = shape_score
-
-            # 최소 점수 임계값
-            if final_score > 0.3:
-                valid_detections.append(det)
-
-        if not valid_detections:
-            print(f"  ⚠️ No valid shrimp detected (filtered out {len(detections)} detections)")
-            continue
-
-        # 최종 점수가 가장 높은 객체 선택
-        largest_det = max(valid_detections, key=lambda d: d["final_score"])
-        pred_length = largest_det["length"]
-        pred_weight = largest_det["pred_weight"]
-
-        print(f"  ✓ Selected detection:")
-        print(f"    - Final score: {largest_det['final_score']:.3f}")
-        print(f"    - Center: {largest_det['center_score']:.2f}, Size: {largest_det['size_score']:.2f}, Shape: {largest_det['shape_score']:.2f}, Conf: {largest_det['confidence']:.2f}")
-        print(f"    - Bbox area: {(largest_det['bbox'][2]-largest_det['bbox'][0])*(largest_det['bbox'][3]-largest_det['bbox'][1]):.0f}px")
-
-        # 2. 엑셀에서 실제 데이터 가져오기
-        true_data = excel_data[idx]
-        true_length = true_data['length']
-        true_weight = true_data['weight']
-
-        if true_weight is None:
-            print(f"  ⚠️ No weight data in Excel for #{idx}")
-            continue
-
-        # 3. 오차 계산
-        error_weight = abs(pred_weight - true_weight) / true_weight * 100
-        error_length = abs(pred_length - true_length) / true_length * 100
-
-        # 4. 이미지 시각화 (예측 + 실제 값 표시)
-        vis_img = detector.visualize_with_groundtruth(
-            shrimp_img, largest_det, true_length, true_weight, idx
-        )
-
-        # 이미지 파일로 저장 (확장자 포함)
-        output_filename = f"sample_{idx:02d}_result.jpg"
-        output_path = os.path.join(results_folder, output_filename)
-        vis_img.save(output_path, quality=95)
-
-        visualized_images.append(output_path)
-        print(f"  💾 Saved visualization: {output_path}")
-
-        results.append({
-            "ID": f"#{idx}",
-            "실제 체장(cm)": round(true_length, 1),
-            "예측 체장(cm)": round(pred_length, 1),
-            "체장 오차(%)": round(error_length, 1),
-            "실제 체중(g)": round(true_weight, 2),
-            "예측 체중(g)": round(pred_weight, 2),
-            "체중 오차(%)": round(error_weight, 1),
-            "오차(g)": round(abs(pred_weight - true_weight), 2)
-        })
-
-        print(f"  ✅ Length: {pred_length:.1f}cm (true: {true_length:.1f}cm, error: {error_length:.1f}%)")
-        print(f"     Weight: {pred_weight:.2f}g (true: {true_weight:.2f}g, error: {error_weight:.1f}%)")
-
-    if not results:
-        return "❌ 처리된 샘플이 없습니다", pd.DataFrame(), None, []
-
-    # 결과 DataFrame
-    df = pd.DataFrame(results)
-
-    # 통계 계산
-    avg_error_length = df["체장 오차(%)"].mean()
-    avg_error_weight = df["체중 오차(%)"].mean()
-    avg_error_g = df["오차(g)"].mean()
-    min_error_weight = df["체중 오차(%)"].min()
-    max_error_weight = df["체중 오차(%)"].max()
-
-    # 차트 생성
-    fig = go.Figure()
-
-    # 예측 vs 실제 산점도
-    fig.add_trace(go.Scatter(
-        x=df["실제 체중(g)"],
-        y=df["예측 체중(g)"],
-        mode='markers+text',
-        text=df["ID"],
-        textposition="top center",
-        marker=dict(size=12, color=df["체중 오차(%)"], colorscale='RdYlGn_r',
-                   showscale=True, colorbar=dict(title="체중 오차(%)")),
-        name='예측 vs 실제'
-    ))
-
-    # 완벽한 예측 선 (y=x)
-    min_val = min(df["실제 체중(g)"].min(), df["예측 체중(g)"].min())
-    max_val = max(df["실제 체중(g)"].max(), df["예측 체중(g)"].max())
-    fig.add_trace(go.Scatter(
-        x=[min_val, max_val],
-        y=[min_val, max_val],
-        mode='lines',
-        line=dict(dash='dash', color='red', width=2),
-        name='완벽한 예측 (y=x)'
-    ))
-
-    fig.update_layout(
-        title=f"예측 정확도 검증 ({len(results)}개 샘플)",
-        xaxis_title="실제 체중 (g)",
-        yaxis_title="예측 체중 (g)",
-        template="plotly_white",
-        height=500,
-        hovermode='closest'
-    )
-
-    # 통계 텍스트
-    stats_text = f"""
-    ### 📊 배치 테스트 결과
-
-    - **처리 샘플 수**: {len(results)}개
-    - **체장 평균 오차**: {avg_error_length:.1f}%
-    - **체중 평균 오차(MAPE)**: {avg_error_weight:.1f}%
-    - **체중 절대 오차**: {avg_error_g:.2f}g
-    - **체중 오차 범위**: {min_error_weight:.1f}% ~ {max_error_weight:.1f}%
-    - **깊이 보정**: {'✅ 활성화' if enable_depth else '⚠️ 비활성화'}
-
-    🎯 **평가**: {'✅ 우수 (MAPE < 25%)' if avg_error_weight < 25 else '⚠️ 개선 필요 (MAPE ≥ 25%)'}
-
-    💡 **참고**: 실제 체장과 체중 데이터는 엑셀 파일에서 로드되었습니다.
-
-    📸 **이미지 결과**: 아래 갤러리에서 각 샘플의 예측/실제 값을 확인할 수 있습니다.
-
-    💾 **저장 위치**: `{results_folder}` 폴더에 {len(visualized_images)}개 이미지 저장됨
-    """
-
-    return stats_text, df, fig, visualized_images
-
-# =====================
-# Gradio UI
-# =====================
-
-with gr.Blocks(title="🦐 RT-DETR 새우 분석", theme=gr.themes.Soft()) as demo:
-
-    gr.Markdown("""
-    # 🦐 흰다리새우 AI 분석 시스템 (RT-DETR)
-
-    ### 실시간 객체 검출 + 체장/체중 자동 추정
-    **모델**: RT-DETR (PekingU/rtdetr_r50vd_coco_o365) | **회귀**: W = 0.0035 × L^3.13
-    **정확도**: R² = 0.929, MAPE = 6.4% | **디바이스**: """ + ("🚀 GPU" if torch.cuda.is_available() else "💻 CPU") + """
-
-    ---
-    """)
-
-    with gr.Tabs():
-        # 검출 탭
-        with gr.TabItem("🔍 객체 검출"):
-            with gr.Row():
-                with gr.Column():
-                    input_img = gr.Image(
-                        label="입력 이미지",
-                        type="pil"
-                    )
-
-                    conf_slider = gr.Slider(
-                        0.1, 0.9, 0.5,
-                        label="검출 신뢰도 임계값 (Confidence)",
-                        info="낮을수록 더 많은 객체 검출"
-                    )
-
-                    iou_slider = gr.Slider(
-                        0.1, 0.9, 0.5,
-                        label="IoU 임계값 (Overlap) - Roboflow 전용",
-                        info="겹치는 박스 제거 기준 (NMS, 높을수록 더 많이 유지)"
-                    )
-
-                    # 모델 선택
-                    model_selector = gr.Dropdown(
-                        choices=[
-                            ("Roboflow (새우 전용 - 수조)", "roboflow"),
-                            ("RT-DETR (범용 - 측정용)", "rtdetr")
-                        ],
-                        value="roboflow" if ROBOFLOW_LOADED else "rtdetr",
-                        label="🤖 검출 모델 선택",
-                        info="Roboflow: 살아있는 새우(수조) 전용 | RT-DETR: 측정용 매트 위 새우"
-                    )
-
-                    with gr.Row():
-                        pixel_scale = gr.Number(
-                            value=92,
-                            label="픽셀 크기 (px)",
-                            info="참조 객체의 픽셀 크기"
-                        )
-                        cm_scale = gr.Number(
-                            value=1,
-                            label="실제 크기 (cm)",
-                            info="참조 객체의 실제 크기"
-                        )
-
-                    depth_checkbox = gr.Checkbox(
-                        value=False,
-                        label="🔍 깊이 기반 원근 보정 활성화 (RT-DETR만)",
-                        info="Depth-Anything V2로 자동 원근 왜곡 보정"
-                    )
-
-                    detect_btn = gr.Button(
-                        "🚀 검출 실행",
-                        variant="primary",
-                        size="lg"
-                    )
-
-                with gr.Column():
-                    output_img = gr.Image(
-                        label="검출 결과"
-                    )
-                    depth_img = gr.Image(
-                        label="깊이 맵 (파란색=가까움, 노란색=멀음)"
-                    )
-                    stats = gr.Markdown()
-
-            results_df = gr.Dataframe(
-                label="검출 상세 정보",
-                wrap=True
-            )
-
-        # 평가 탭
-        with gr.TabItem("📊 성능 평가"):
-            gr.Markdown("""
-            ### 회귀 모델 성능 평가
-
-            실측 데이터를 기반으로 체장-체중 회귀 모델의 정확도를 평가합니다.
-            """)
-
-            eval_btn = gr.Button(
-                "📈 평가 실행",
-                variant="primary"
-            )
-            eval_text = gr.Markdown()
-            eval_plot = gr.Plot()
-
-        # 데이터 탭
-        with gr.TabItem("📋 실측 데이터"):
-            gr.Markdown(f"""
-            ### 데이터 요약
-
-            - **샘플 수**: {len(REAL_DATA)}개
-            - **체장 범위**: 7.5 - 13.1 cm
-            - **체중 범위**: 2.0 - 11.3 g
-            - **데이터 출처**: 실측 데이터
-            """)
-
-            data_df = gr.Dataframe(
-                value=pd.DataFrame(REAL_DATA),
-                label="실측 데이터",
-                wrap=True
-            )
-
-            export_btn = gr.Button("💾 CSV 다운로드")
-            file_output = gr.File(label="다운로드")
-
-        # 정확도 검증 탭
-        with gr.TabItem("🎯 정확도 검증"):
-            gr.Markdown("""
-            ### 실제 이미지 데이터로 정확도 검증
-
-            테스트 데이터셋을 배치 처리하여 예측 정확도를 측정합니다.
-            """)
-
-            with gr.Row():
-                with gr.Column():
-                    test_folder = gr.Textbox(
-                        value="d:/Project/VIDraft/Shrimp/data/251015",
-                        label="테스트 데이터 폴더",
-                        info="251015_XX.jpg 형식의 이미지가 있는 폴더"
-                    )
-
-                    with gr.Row():
-                        test_pixel_scale = gr.Number(
-                            value=92,
-                            label="픽셀 크기 (px)",
-                            info="참조 자의 픽셀 크기"
-                        )
-                        test_cm_scale = gr.Number(
-                            value=1,
-                            label="실제 크기 (cm)",
-                            info="참조 자의 실제 크기"
-                        )
-
-                    test_depth_checkbox = gr.Checkbox(
-                        value=False,
-                        label="🔍 깊이 기반 원근 보정 활성화",
-                        info="Depth-Anything V2로 자동 원근 왜곡 보정"
-                    )
-
-                    test_btn = gr.Button(
-                        "🚀 배치 테스트 실행",
-                        variant="primary",
-                        size="lg"
-                    )
-
-                with gr.Column():
-                    test_stats = gr.Markdown()
-
-            test_plot = gr.Plot(label="예측 vs 실제 비교")
-            test_results_df = gr.Dataframe(
-                label="상세 결과",
-                wrap=True
-            )
-
-            gr.Markdown("### 📸 시각화 결과 (예측 vs 실제)")
-            test_gallery = gr.Gallery(
-                label="검출 결과 이미지",
-                show_label=True,
-                columns=3,
-                rows=2,
-                height="auto",
-                object_fit="contain"
-            )
-
-        # 정보 탭
-        with gr.TabItem("ℹ️ 사용 방법"):
-            gr.Markdown("""
-            ## 📖 사용 가이드
-
-            ### 1️⃣ 객체 검출
-            1. 새우 이미지를 업로드하세요
-            2. 신뢰도 임���값을 조정하세요 (기본값: 0.5)
-            3. **깊이 보정 활성화** (권장): 원근 왜곡 자동 보정
-            4. 스케일 보정: 실제 크기를 알고 있다면 픽셀-cm 비율을 설정하세요
-            5. "검출 실행" 버튼을 클릭하세요
-
-            ### 2️⃣ 깊이 기반 원근 보정 (NEW! 🔥)
-            - **Depth-Anything V2** 모델로 이미지의 깊이 맵 자동 생성
-            - 각 새우의 상대적 거리를 계산하여 스케일 자동 보정
-            - **원근 왜곡 효과를 자동으로 제거**하여 정확도 향상
-            - 깊이 맵 시각화: 파란색=가까움, 노란색=멀음
-            - 추가 장비나 마커 없이 단일 이미지만으로 작동
-
-            ### 3️⃣ 스케일 보정
-            - 이미지에서 알고 있는 객체의 픽셀 크기와 실제 크기를 입력하세요
-            - 예: 자가 보인다면, 자의 픽셀 길이와 실제 길이(cm)를 입력
-            - 깊이 보정과 함께 사용하면 더욱 정확한 측정 가능
-
-            ### 4️⃣ 결과 해석
-            - **초록색 박스**: 오차 < 10%
-            - **주황색 박스**: 오차 10-20%
-            - **빨간색 박스**: 오차 > 20%
-
-            ### 5️⃣ 성능 평가
-            - "성능 평가" 탭에서 회귀 모델의 정확도를 확인하세요
-            - R², MAPE, MAE, RMSE 지표 제공
-
-            ### 6️⃣ 정확도 검증 (NEW! 🔥)
-            - "정확도 검증" 탭에서 실제 이미지 데이터로 정확도 측정
-            - 테스트 데이터 폴더를 지정하고 배치 처리
-            - OCR로 전자저울 LCD에서 실제 무게 자동 읽기
-            - 예측 vs 실제 비교 차트 및 통계 제공
-
-            ### 7️⃣ 데이터 내보내기
-            - "실측 데이터" 탭에서 CSV 파일로 다운로드 가능
-
-            ---
-
-            ## ⚙️ 시스템 정보
-
-            - **검출 모델**: RT-DETR (Real-Time DEtection TRansformer)
-            - **깊이 추정 모델**: Depth-Anything V2 Small (Monocular Depth Estimation)
-            - **회귀 모델**: Power Law (W = a × L^b)
-            - **디바이스**: """ + ("GPU (CUDA)" if torch.cuda.is_available() else "CPU") + """
-            - **최적화**: CPU 모드, torch.no_grad(), FP32
-            - **원근 보정**: 깊이 맵 기반 자동 스케일 조정
-
-            ## 🔧 문제 해결
-
-            **검출이 안 될 때**:
-            - 신뢰도 임계값을 낮춰보세요 (0.3 이하)
-            - 이미지 품질을 확인하세요 (해상도, 밝기)
-
-            **정확도가 낮을 때**:
-            - 스케일 보정을 정확히 입력하세요
-            - 새우 전용 fine-tuning 모델이 필요할 수 있습니다
-
-            **속도가 느릴 때**:
-            - GPU 가속을 사용하세요 (HF Space: GPU T4)
-            - 이미지 크기를 줄이세요 (800x600 권장)
-            """)
-
-    # 이벤트 연결
-    detect_btn.click(
-        process_image,
-        [input_img, model_selector, conf_slider, iou_slider, pixel_scale, cm_scale, depth_checkbox],
-        [output_img, depth_img, stats, results_df]
-    )
-
-    eval_btn.click(
-        evaluate_model,
-        [],
-        [eval_text, eval_plot]
-    )
-
-    export_btn.click(
-        export_data,
-        [],
-        file_output
-    )
-
-    test_btn.click(
-        process_test_dataset,
-        [test_folder, test_pixel_scale, test_cm_scale, test_depth_checkbox],
-        [test_stats, test_results_df, test_plot, test_gallery]
-    )
-
-# 실행
-if __name__ == "__main__":
-    demo.queue(max_size=10)  # CPU 최적화: 큐 크기 제한
-    demo.launch(
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )

check_250818_labeling.py

@@ -1,83 +0,0 @@
-# -*- 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

@@ -1,38 +0,0 @@
-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

@@ -1,181 +0,0 @@
-# -*- 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

@@ -1,185 +0,0 @@
-# -*- 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

@@ -1,38 +0,0 @@
-# -*- 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("✅ 디버깅 완료")

evaluate_yolo.py

@@ -1,239 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-YOLOv8 학습 모델 평가
-GT 데이터로 성능 측정 및 RT-DETR과 비교
-"""
-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
-
-def calculate_iou(box1, box2):
-    """IoU 계산"""
-    x1_1, y1_1, x2_1, y2_1 = box1
-    x1_2, y1_2, x2_2, y2_2 = box2
-
-    # Intersection
-    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)
-
-    # Union
-    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 evaluate_model(model_path, gt_file, data_base_dir, confidence_threshold=0.25, iou_threshold=0.5):
-    """모델 평가"""
-    print(f"\n📊 모델 평가 시작: {model_path}")
-    print(f"   - Confidence: {confidence_threshold}")
-    print(f"   - IoU Threshold: {iou_threshold}")
-
-    # 모델 로드
-    model = YOLO(model_path)
-    print(f"✅ 모델 로드 완료")
-
-    # GT 로드
-    with open(gt_file, 'r', encoding='utf-8') as f:
-        gt_data = json.load(f)
-
-    # 통계
-    total_gt = 0
-    total_pred = 0
-    true_positives = 0
-    false_positives = 0
-    false_negatives = 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
-
-        # YOLOv8 추론
-        results = model(img_path, conf=confidence_threshold, verbose=False)
-
-        # 예측 박스 추출
-        pred_boxes = []
-        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()  # [x1, y1, x2, y2]
-                confs = result.boxes.conf.cpu().numpy()
-
-                for box, conf in zip(boxes, confs):
-                    pred_boxes.append({
-                        'bbox': box.tolist(),
-                        'confidence': float(conf)
-                    })
-
-        # GT 박스
-        gt_boxes_only = [{'bbox': ann['bbox']} for ann in gt_boxes]
-
-        # 매칭
-        matched_gt = set()
-        matched_pred = set()
-
-        for i, pred in enumerate(pred_boxes):
-            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(pred_boxes) - 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_pred += len(pred_boxes)
-
-        results_detail.append({
-            'filename': filename,
-            'gt_count': len(gt_boxes_only),
-            'pred_count': len(pred_boxes),
-            '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
-
-    return {
-        'precision': precision,
-        'recall': recall,
-        'f1': f1,
-        'tp': true_positives,
-        'fp': false_positives,
-        'fn': false_negatives,
-        'total_gt': total_gt,
-        'total_pred': total_pred
-    }
-
-def main():
-    print("=" * 60)
-    print("🎯 YOLOv8 모델 평가")
-    print("=" * 60)
-
-    # 경로 설정
-    best_model = "runs/train/shrimp_yolov8n/weights/best.pt"
-    gt_file = "ground_truth.json"
-    data_base_dir = "data/흰다리새우 실측 데이터_익투스에이아이(주)"
-
-    if not os.path.exists(best_model):
-        print(f"\n❌ 모델 파일 없음: {best_model}")
-        print("   먼저 train_yolo.py를 실행하세요.")
-        return
-
-    print(f"\n📁 모델: {best_model}")
-    print(f"📁 GT: {gt_file}")
-
-    # 여러 confidence threshold 테스트 (낮은 값부터)
-    confidence_thresholds = [0.001, 0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3]
-
-    print(f"\n🔍 Confidence Threshold 최적화 중...")
-    print(f"   테스트 범위: {confidence_thresholds}")
-
-    best_f1 = 0
-    best_conf = 0
-    best_result = None
-    all_results = []
-
-    for conf in confidence_thresholds:
-        result = evaluate_model(best_model, gt_file, data_base_dir, confidence_threshold=conf)
-        result['conf'] = conf
-        all_results.append(result)
-
-        print(f"\n   Conf={conf:.2f}: P={result['precision']:.1%}, R={result['recall']:.1%}, F1={result['f1']:.1%}")
-
-        if result['f1'] > best_f1:
-            best_f1 = result['f1']
-            best_conf = conf
-            best_result = result
-
-    # 최적 결과 출력
-    print("\n" + "=" * 60)
-    print("✅ 평가 완료!")
-    print("=" * 60)
-
-    print(f"\n🏆 최적 성능 (Confidence={best_conf}):")
-    print(f"   - Precision: {best_result['precision']:.1%}")
-    print(f"   - Recall: {best_result['recall']:.1%}")
-    print(f"   - F1 Score: {best_result['f1']:.1%}")
-    print(f"\n   - True Positives: {best_result['tp']}")
-    print(f"   - False Positives: {best_result['fp']}")
-    print(f"   - False Negatives: {best_result['fn']}")
-    print(f"   - Total GT: {best_result['total_gt']}")
-    print(f"   - Total Pred: {best_result['total_pred']}")
-
-    # RT-DETR 비교
-    print(f"\n📊 RT-DETR + Filter 비교:")
-    print(f"   RT-DETR (Conf=0.065, Filter=90):")
-    print(f"   - Precision: 44.2%")
-    print(f"   - Recall: 94.0%")
-    print(f"   - F1 Score: 56.1%")
-    print(f"\n   YOLOv8 (Conf={best_conf}):")
-    print(f"   - Precision: {best_result['precision']:.1%}")
-    print(f"   - Recall: {best_result['recall']:.1%}")
-    print(f"   - F1 Score: {best_result['f1']:.1%}")
-
-    # 개선율
-    baseline_f1 = 0.561
-    improvement = (best_result['f1'] - baseline_f1) / baseline_f1 * 100
-    print(f"\n   F1 개선율: {improvement:+.1f}%")
-
-    # 결과 저장
-    output_file = "yolo_evaluation_results.json"
-    with open(output_file, 'w', encoding='utf-8') as f:
-        json.dump({
-            'best_result': best_result,
-            'all_results': all_results,
-            'baseline': {
-                'precision': 0.442,
-                'recall': 0.940,
-                'f1': 0.561
-            }
-        }, f, indent=2, ensure_ascii=False)
-
-    print(f"\n💾 결과 저장: {output_file}")
-
-if __name__ == "__main__":
-    main()

labeling_tool.py

@@ -1,650 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Ground Truth 라벨링 도구
-RT-DETR 검출 결과에서 사용자가 올바른 박스만 선택하여 라벨링
-"""
-import sys
-sys.stdout.reconfigure(encoding='utf-8')
-
-import gradio as gr
-from PIL import Image, ImageDraw, ImageFont
-import json
-import os
-import glob
-from datetime import datetime
-import torch
-from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
-
-# 전역 변수 - 모델은 필요시에만 로드
-processor = None
-model = None
-
-def load_rtdetr_model():
-    """RT-DETR 모델을 필요시에만 로딩"""
-    global processor, model
-    if processor is None or model is None:
-        print("🔄 RT-DETR 모델 로딩 중...")
-        processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
-        model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
-        model.eval()
-        print("✅ RT-DETR 로딩 완료")
-
-current_data = {
-    'folder': None,
-    'images': [],
-    'current_idx': 0,
-    'detections': {},
-    'selections': {},
-    'confidence_threshold': 0.2,  # 기본 신뢰도 임계값 (낮춤)
-    'image_cache': {}  # 이미지 캐싱 (속도 향상)
-}
-
-GROUND_TRUTH_FILE = "ground_truth.json"
-DATA_BASE = "data/흰다리새우 실측 데이터_익투스에이아이(주)"
-
-def detect_with_rtdetr_fast(image, confidence=0.3):
-    """RT-DETR 빠른 검출"""
-    global processor, model
-
-    # 모델이 로드되지 않았으면 로드
-    load_rtdetr_model()
-
-    inputs = processor(images=image, return_tensors="pt")
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    target_sizes = torch.tensor([image.size[::-1]])
-    results = processor.post_process_object_detection(
-        outputs,
-        target_sizes=target_sizes,
-        threshold=confidence
-    )[0]
-
-    detections = []
-    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-        x1, y1, x2, y2 = box.tolist()
-        detections.append({
-            'bbox': [x1, y1, x2, y2],
-            'confidence': score.item()
-        })
-
-    return detections
-
-def load_existing_ground_truth():
-    """기존 ground_truth.json 로드"""
-    if os.path.exists(GROUND_TRUTH_FILE):
-        with open(GROUND_TRUTH_FILE, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    return {}
-
-def save_ground_truth(data):
-    """ground_truth.json 저장"""
-    # 백업 폴더 생성
-    backup_dir = "backups"
-    if not os.path.exists(backup_dir):
-        os.makedirs(backup_dir)
-
-    # 백업 (기존 파일이 있을 때만)
-    if os.path.exists(GROUND_TRUTH_FILE):
-        backup_name = f"ground_truth_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-        backup_path = os.path.join(backup_dir, backup_name)
-
-        # 기존 파일을 백업 폴더로 복사
-        import shutil
-        shutil.copy2(GROUND_TRUTH_FILE, backup_path)
-
-    # 저장
-    with open(GROUND_TRUTH_FILE, 'w', encoding='utf-8') as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-
-    print(f"✅ Ground Truth 저장 완료: {len(data)}개 이미지")
-
-def get_folders():
-    """사용 가능한 폴더 목록"""
-    folders = sorted(glob.glob(os.path.join(DATA_BASE, "2*")))
-    return [os.path.basename(f) for f in folders if os.path.isdir(f)]
-
-def start_labeling(folder):
-    """라벨링 시작"""
-    if not folder:
-        return None, "❌ 폴더를 선택하세요.", "", 0.2
-
-    # 이미지 로드
-    folder_path = os.path.join(DATA_BASE, folder)
-    all_images = sorted(glob.glob(os.path.join(folder_path, "*.jpg")))
-
-    # 필터링: YYMMDD_NN.jpg 형식만 허용 (YYMMDD_NN-N.jpg 제외)
-    import re
-    pattern = re.compile(r'^\d{6}_\d{2}\.jpg$')  # 250818_01.jpg
-    images = [img for img in all_images if pattern.match(os.path.basename(img))]
-
-    if not images:
-        return None, f"❌ {folder}에 올바른 형식의 이미지가 없습니다. (YYMMDD_NN.jpg)", "", 0.2
-
-    current_data['folder'] = folder
-    current_data['images'] = [os.path.basename(img) for img in images]
-    current_data['current_idx'] = 0
-    current_data['detections'] = {}
-    current_data['selections'] = {}
-    current_data['confidence_threshold'] = 0.2
-    current_data['image_cache'] = {}  # 캐시 초기화
-
-    filtered_count = len(all_images) - len(images)
-    if filtered_count > 0:
-        print(f"📂 폴더: {folder}, 이미지: {len(images)}개 (제외: {filtered_count}개)")
-    else:
-        print(f"📂 폴더: {folder}, 이미지: {len(images)}개")
-
-    # 첫 이미지 로드
-    return load_image(0)
-
-def load_image(idx, confidence_threshold=None):
-    """이미지 로드 및 검출"""
-    if idx < 0 or idx >= len(current_data['images']):
-        return None, "❌ 범위를 벗어난 인덱스입니다.", "", ""
-
-    current_data['current_idx'] = idx
-    filename = current_data['images'][idx]
-    folder = current_data['folder']
-    img_path = os.path.join(DATA_BASE, folder, filename)
-
-    # 신뢰도 임계값 업데이트
-    if confidence_threshold is not None:
-        current_data['confidence_threshold'] = confidence_threshold
-
-    # 이미지 캐시 사용 (디스크 I/O 최소화)
-    if filename not in current_data['image_cache']:
-        img_path = os.path.join(DATA_BASE, folder, filename)
-        current_data['image_cache'][filename] = Image.open(img_path).convert('RGB')
-
-    image = current_data['image_cache'][filename]
-
-    # RT-DETR 검출 (신뢰도 변경 시 재검출)
-    cache_key = f"{filename}_{current_data['confidence_threshold']}"
-    if cache_key not in current_data['detections']:
-        print(f"🔍 RT-DETR 검출 중: {filename} (신뢰도={current_data['confidence_threshold']:.2f})")
-        detections = detect_with_rtdetr_fast(image, confidence=current_data['confidence_threshold'])
-        current_data['detections'][cache_key] = detections
-    else:
-        detections = current_data['detections'][cache_key]
-
-    # 선택 상태 초기화
-    if filename not in current_data['selections']:
-        current_data['selections'][filename] = []
-
-    # 시각화
-    img_with_boxes = draw_boxes(image, detections, current_data['selections'][filename])
-
-    # 진행률
-    progress = f"{idx + 1}/{len(current_data['images'])} ({(idx+1)/len(current_data['images'])*100:.0f}%)"
-
-    # 정보
-    info = f"""
-### 📷 이미지: {filename}
-
-- **진행률**: {progress}
-- **신뢰도 임계값**: {current_data['confidence_threshold']:.2f}
-- **검출된 박스**: {len(detections)}개
-- **선택된 박스**: {len(current_data['selections'][filename])}개
-
-### 📝 사용 방법
-
-1. **새우가 맞는 박스를 클릭**하여 선택 (파란색으로 변경)
-2. 잘못 선택 시 **다시 클릭**하여 해제 (녹색으로 되돌림)
-3. **신뢰도 슬라이더**로 검출 민감도 조정 (낮을수록 더 많이 검출)
-4. **"다음"** 버튼으로 저장 및 다음 이미지로 이동
-
-**박스 색상:**
-- 🟢 녹색: 검출됨 (선택 안 됨)
-- 🔵 파란색: 선택됨 (새우)
-"""
-
-    return img_with_boxes, info, progress, current_data['confidence_threshold']
-
-def draw_boxes(image, detections, selected_indices):
-    """박스 그리기 (클릭 가능한 번호 버튼 포함) - 최적화"""
-    # 이미지 복사 대신 직접 수정 (속도 향상)
-    img = image.copy()
-    draw = ImageDraw.Draw(img)
-
-    try:
-        font = ImageFont.truetype("arial.ttf", 28)  # 더 큰 폰트
-        font_tiny = ImageFont.truetype("arial.ttf", 10)
-    except:
-        font = ImageFont.load_default()
-        font_tiny = ImageFont.load_default()
-
-    # 선택되지 않은 박스 먼저 그리기 (뒤쪽 레이어)
-    for idx, det in enumerate(detections):
-        if idx not in selected_indices:
-            x1, y1, x2, y2 = det['bbox']
-            color = "lime"
-
-            # 박스 테두리
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=10)
-
-            # 코너 라벨
-            corner_label = f"#{idx+1}"
-            draw.rectangle([x1-2, y1-24, x1+30, y1-2], fill=color)
-            draw.text((x1, y1 - 22), corner_label, fill="white", font=font_tiny)
-
-    # 선택된 박스 나중에 그리기 (앞쪽 레이어)
-    for idx, det in enumerate(detections):
-        if idx in selected_indices:
-            x1, y1, x2, y2 = det['bbox']
-            color = "blue"
-
-            # 박스 테두리 (더 두껍게)
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=14)
-
-            # 코너 라벨
-            corner_label = f"✓#{idx+1}"
-            draw.rectangle([x1-2, y1-24, x1+40, y1-2], fill=color)
-            draw.text((x1, y1 - 22), corner_label, fill="white", font=font_tiny)
-
-    # 원형 버튼 (모든 박스)
-    for idx, det in enumerate(detections):
-        x1, y1, x2, y2 = det['bbox']
-        center_x = (x1 + x2) / 2
-        center_y = (y1 + y2) / 2
-
-        # 선택 여부
-        selected = idx in selected_indices
-        btn_color = "blue" if selected else "lime"
-        btn_text = f"✓{idx+1}" if selected else f"{idx+1}"
-
-        # 버튼 크기
-        box_width = x2 - x1
-        box_height = y2 - y1
-        radius = min(55, box_width * 0.18, box_height * 0.35)
-
-        # 외곽 원 (흰색 테두리)
-        draw.ellipse(
-            [center_x - radius - 4, center_y - radius - 4,
-             center_x + radius + 4, center_y + radius + 4],
-            fill=btn_color,
-            outline="white",
-            width=5
-        )
-
-        # 내부 원
-        draw.ellipse(
-            [center_x - radius, center_y - radius,
-             center_x + radius, center_y + radius],
-            fill=btn_color
-        )
-
-        # 텍스트 중앙 정렬
-        text_bbox = draw.textbbox((0, 0), btn_text, font=font)
-        text_width = text_bbox[2] - text_bbox[0]
-        text_height = text_bbox[3] - text_bbox[1]
-        text_x = center_x - text_width / 2
-        text_y = center_y - text_height / 2 - 2
-
-        # 텍스트 (그림자 + 본체)
-        draw.text((text_x + 2, text_y + 2), btn_text, fill="black", font=font)
-        draw.text((text_x, text_y), btn_text, fill="white", font=font)
-
-    # 헤더
-    header = f"검출: {len(detections)}개 | 선택: {len(selected_indices)}개"
-    header_bbox = draw.textbbox((10, 10), header, font=font)
-    draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10], fill="black", outline="white", width=2)
-    draw.text((10, 10), header, fill="white", font=font)
-
-    return img
-
-def redraw_current_image():
-    """현재 이미지 빠르게 재그리기 (재검출 없이 박스만 다시 그리기)"""
-    idx = current_data['current_idx']
-    filename = current_data['images'][idx]
-    folder = current_data['folder']
-
-    # 이미지 캐시 확인 (디스크 I/O 최소화)
-    if filename not in current_data['image_cache']:
-        img_path = os.path.join(DATA_BASE, folder, filename)
-        current_data['image_cache'][filename] = Image.open(img_path).convert('RGB')
-
-    image = current_data['image_cache'][filename]
-
-    # 캐시된 검출 결과 사용 (재검출 없음!)
-    cache_key = f"{filename}_{current_data['confidence_threshold']}"
-    detections = current_data['detections'][cache_key]
-
-    # 선택 상태
-    selections = current_data['selections'][filename]
-
-    # 박스만 다시 그리기
-    img_with_boxes = draw_boxes(image, detections, selections)
-
-    # 진행률 (간소화)
-    progress = f"{idx + 1}/{len(current_data['images'])}"
-
-    # 정보 (간소화 - 텍스트 생성 시간 단축)
-    info = f"**{filename}** | 검출: {len(detections)}개 | 선택: {len(selections)}개"
-
-    return img_with_boxes, info, progress, current_data['confidence_threshold']
-
-def toggle_selection(evt: gr.SelectData):
-    """박스 클릭 시 선택/해제 (원형 버튼 우선 감지)"""
-    # 클릭 좌표
-    click_x, click_y = evt.index
-
-    filename = current_data['images'][current_data['current_idx']]
-    cache_key = f"{filename}_{current_data['confidence_threshold']}"
-    detections = current_data['detections'][cache_key]
-    selections = current_data['selections'][filename]
-
-    if not detections:
-        return redraw_current_image()
-
-    # 1단계: 원형 버튼 내부 클릭 감지 (최우선)
-    button_candidates = []
-
-    for idx, det in enumerate(detections):
-        x1, y1, x2, y2 = det['bbox']
-        center_x = (x1 + x2) / 2
-        center_y = (y1 + y2) / 2
-
-        # 버튼 크기 계산 (draw_boxes와 동일)
-        box_width = x2 - x1
-        box_height = y2 - y1
-        radius = min(50, box_width * 0.15, box_height * 0.3)
-
-        # 클릭이 원형 버튼 내부인지 확인
-        distance_from_center = ((click_x - center_x) ** 2 + (click_y - center_y) ** 2) ** 0.5
-
-        if distance_from_center <= radius:
-            # 버튼 내부 클릭!
-            button_candidates.append((idx, distance_from_center))
-
-    # 2단계: 버튼 클릭이 있으면 가장 가까운 버튼 선택
-    clicked_idx = None
-    if button_candidates:
-        # 버튼 중심에 가장 가까운 것 선택
-        button_candidates.sort(key=lambda x: x[1])
-        clicked_idx = button_candidates[0][0]
-        print(f"🎯 버튼 클릭 → 박스 #{clicked_idx+1}")
-
-    # 3단계: 버튼 클릭 없으면 박스 영역 클릭 확인
-    else:
-        box_candidates = []
-        for idx, det in enumerate(detections):
-            x1, y1, x2, y2 = det['bbox']
-
-            # 박스 내부인지 확인
-            if x1 <= click_x <= x2 and y1 <= click_y <= y2:
-                center_x = (x1 + x2) / 2
-                center_y = (y1 + y2) / 2
-                distance = ((click_x - center_x) ** 2 + (click_y - center_y) ** 2) ** 0.5
-                area = (x2 - x1) * (y2 - y1)
-
-                # 작은 박스 + 가까운 박스 우선
-                score = area + distance * 100
-                box_candidates.append((idx, score, area, distance))
-
-        if box_candidates:
-            box_candidates.sort(key=lambda x: x[1])
-            clicked_idx = box_candidates[0][0]
-            best = box_candidates[0]
-            print(f"📍 박스 영역 클릭 ({click_x:.0f}, {click_y:.0f}) → 박스 #{clicked_idx+1} (거리={best[3]:.0f})")
-
-    # 4단계: 선택/해제 토글
-    if clicked_idx is not None:
-        if clicked_idx in selections:
-            selections.remove(clicked_idx)
-            print(f"  ✓ 박스 #{clicked_idx+1} 선택 해제")
-        else:
-            selections.append(clicked_idx)
-            print(f"  ✓ 박스 #{clicked_idx+1} 선택됨")
-
-        current_data['selections'][filename] = selections
-    else:
-        print(f"❌ 클릭 위치에 박스 없음")
-
-    # 빠른 업데이트: 이미지만 다시 그리기 (재검출 없음)
-    return redraw_current_image()
-
-def previous_image():
-    """이전 이미지"""
-    idx = current_data['current_idx'] - 1
-    if idx < 0:
-        return load_image(current_data['current_idx']) + ("⚠️ 첫 이미지입니다.",)
-    return load_image(idx) + ("",)
-
-def next_image():
-    """다음 이미지 (저장 포함)"""
-    # 현재 선택 저장
-    save_current_selection()
-
-    idx = current_data['current_idx'] + 1
-    if idx >= len(current_data['images']):
-        return load_image(current_data['current_idx']) + ("⚠️ 마지막 이미지입니다. '완료' 버튼을 누르세요.",)
-    return load_image(idx) + ("✅ 저장되었습니다.",)
-
-def skip_image():
-    """건너뛰기"""
-    filename = current_data['images'][current_data['current_idx']]
-    current_data['selections'][filename] = []
-
-    idx = current_data['current_idx'] + 1
-    if idx >= len(current_data['images']):
-        return load_image(current_data['current_idx']) + ("⚠️ 마지막 이미지입니다.",)
-    return load_image(idx) + ("⏭️ 건너뛰었습니다.",)
-
-def reset_selection():
-    """현재 이미지의 선택 초기화"""
-    filename = current_data['images'][current_data['current_idx']]
-    current_data['selections'][filename] = []
-
-    # 빠른 업데이트: 이미지만 다시 그리기
-    return redraw_current_image() + ("🔄 선택이 초기화되었습니다.",)
-
-def save_current_selection():
-    """현재 선택 저장"""
-    filename = current_data['images'][current_data['current_idx']]
-    folder = current_data['folder']
-    selections = current_data['selections'].get(filename, [])
-    cache_key = f"{filename}_{current_data['confidence_threshold']}"
-    detections = current_data['detections'][cache_key]
-
-    # Ground Truth 형식으로 변환
-    gt_data = load_existing_ground_truth()
-
-    gt_data[filename] = [
-        {
-            "bbox": detections[idx]['bbox'],
-            "label": "shrimp",
-            "folder": folder,
-            "confidence": detections[idx]['confidence']
-        }
-        for idx in selections
-    ]
-
-    # 임시 저장 (매번)
-    save_ground_truth(gt_data)
-
-def finish_labeling():
-    """라벨링 완료"""
-    # 마지막 이미지 저장
-    save_current_selection()
-
-    gt_data = load_existing_ground_truth()
-    total_images = len(gt_data)
-    total_boxes = sum(len(v) for v in gt_data.values())
-
-    msg = f"""
-## ✅ 라벨링 완료!
-
-- **총 이미지**: {total_images}개
-- **총 바운딩 박스**: {total_boxes}개
-- **저장 위치**: {GROUND_TRUTH_FILE}
-
-### 다음 단계:
-
-```bash
-python test_quantitative_evaluation.py
-```
-
-성능 측정 후 결과를 확인하세요!
-"""
-
-    return None, msg, "완료"
-
-# 키보드 단축키를 위한 JavaScript
-keyboard_js = """
-<script>
-document.addEventListener('keydown', function(event) {
-    // 입력 필드에서는 단축키 비활성화
-    if (event.target.tagName === 'INPUT' || event.target.tagName === 'TEXTAREA') {
-        return;
-    }
-
-    // 화살표 키, 스페이스바, S, R 키 처리
-    if (event.key === 'ArrowRight' || event.key === ' ') {
-        event.preventDefault();
-        const nextBtn = document.querySelector('button:has-text("다음")') ||
-                       Array.from(document.querySelectorAll('button')).find(btn => btn.textContent.includes('다음'));
-        if (nextBtn) nextBtn.click();
-    } else if (event.key === 'ArrowLeft') {
-        event.preventDefault();
-        const prevBtn = Array.from(document.querySelectorAll('button')).find(btn => btn.textContent.includes('이전'));
-        if (prevBtn) prevBtn.click();
-    } else if (event.key.toLowerCase() === 's') {
-        event.preventDefault();
-        const skipBtn = Array.from(document.querySelectorAll('button')).find(btn => btn.textContent.includes('건너뛰기'));
-        if (skipBtn) skipBtn.click();
-    } else if (event.key.toLowerCase() === 'r') {
-        event.preventDefault();
-        const resetBtn = Array.from(document.querySelectorAll('button')).find(btn => btn.textContent.includes('초기화'));
-        if (resetBtn) resetBtn.click();
-    }
-});
-</script>
-"""
-
-# Gradio 인터페이스
-with gr.Blocks(title="🏷️ Ground Truth 라벨링 도구", theme=gr.themes.Soft(), head=keyboard_js) as demo:
-
-    gr.Markdown("""
-    # 🏷️ Ground Truth 라벨링 도구
-
-    RT-DETR 검출 결과에서 올바른 새우 박스만 선택하여 라벨링합니다.
-
-    ---
-    """)
-
-    with gr.Row():
-        folder_dropdown = gr.Dropdown(
-            choices=get_folders(),
-            label="📁 라벨링할 폴더 선택",
-            value=None
-        )
-        start_btn = gr.Button("🚀 시작", variant="primary")
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            image_output = gr.Image(label="이미지 (박스 클릭으로 선택/해제)", type="pil")
-
-        with gr.Column(scale=1):
-            info_output = gr.Markdown()
-
-            progress_output = gr.Textbox(label="진행률", interactive=False)
-
-            confidence_slider = gr.Slider(
-                minimum=0.05,
-                maximum=0.5,
-                value=0.2,
-                step=0.05,
-                label="🎯 검출 신뢰도 임계값 (낮을수록 ��� 많이 검출)",
-                info="새우가 검출 안 되면 낮추세요"
-            )
-
-            with gr.Row():
-                prev_btn = gr.Button("◀ 이전")
-                skip_btn = gr.Button("⏭ 건너뛰기")
-                next_btn = gr.Button("다음 ▶", variant="primary")
-
-            reset_btn = gr.Button("🔄 선택 초기화", variant="secondary")
-
-            finish_btn = gr.Button("✅ 완료", variant="stop", size="lg")
-
-            status_output = gr.Textbox(label="상태", interactive=False)
-
-    gr.Markdown("""
-    ---
-
-    ### 💡 사용 팁
-
-    **마우스:**
-    - **클릭**: 박스를 클릭하여 선택/해제
-    - **녹색 → 파란색**: 선택됨 (새우)
-    - **파란색 → 녹색**: 해제됨
-
-    **키보드 단축키:**
-    - **→ (오른쪽 화살표)**: 다음 이미지 (저장)
-    - **← (왼쪽 화살표)**: 이전 이미지
-    - **Space (스페이스바)**: 다음 이미지 (저장)
-    - **S**: 건너뛰기
-    - **R**: 선택 초기화
-
-    **기타:**
-    - **신뢰도 슬라이더**: 검출 민감도 조정 (0.05~0.5)
-    - **10장마다 자동 저장됩니다.**
-    """)
-
-    # 이벤트 연결
-    start_btn.click(
-        start_labeling,
-        [folder_dropdown],
-        [image_output, info_output, progress_output, confidence_slider]
-    )
-
-    # 신뢰도 슬라이더 변경 시 현재 이미지 재검출
-    confidence_slider.change(
-        lambda conf: load_image(current_data['current_idx'], conf),
-        [confidence_slider],
-        [image_output, info_output, progress_output, confidence_slider]
-    )
-
-    image_output.select(
-        toggle_selection,
-        None,
-        [image_output, info_output, progress_output, confidence_slider]
-    )
-
-    prev_btn.click(
-        previous_image,
-        None,
-        [image_output, info_output, progress_output, confidence_slider, status_output]
-    )
-
-    next_btn.click(
-        next_image,
-        None,
-        [image_output, info_output, progress_output, confidence_slider, status_output]
-    )
-
-    skip_btn.click(
-        skip_image,
-        None,
-        [image_output, info_output, progress_output, confidence_slider, status_output]
-    )
-
-    reset_btn.click(
-        reset_selection,
-        None,
-        [image_output, info_output, progress_output, confidence_slider, status_output]
-    )
-
-    finish_btn.click(
-        finish_labeling,
-        None,
-        [image_output, info_output, progress_output]
-    )
-
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=None,  # 자동으로 빈 포트 찾기
-        share=False
-    )

optimize_yolov8_confidence.py

@@ -1,217 +0,0 @@
-"""
-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

@@ -1,204 +0,0 @@
-"""
-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

@@ -1,89 +0,0 @@
-# -*- 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

@@ -1,127 +0,0 @@
-# -*- 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}")

shrimp_detection_app.py

@@ -1,1150 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-🦐 새우 검출 통합 시스템
-3개의 앱을 하나로 통합: 자동 검출, 라벨링 도구, 데모
-RT-DETR 또는 VIDraft/Shrimp 클라우드 모델 선택 가능
-"""
-import sys
-sys.stdout.reconfigure(encoding='utf-8')
-
-import gradio as gr
-from PIL import Image, ImageDraw, ImageFont
-import numpy as np
-import json
-import os
-import glob
-from datetime import datetime
-import torch
-from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
-import requests
-import base64
-from io import BytesIO
-from inference_sdk import InferenceHTTPClient
-import tempfile
-
-# test_visual_validation에서 가져오기 (지연 import로 변경)
-# from test_visual_validation import (
-#     load_rtdetr_model,
-#     detect_with_rtdetr,
-#     apply_universal_filter,
-#     calculate_morphological_features,
-#     calculate_visual_features
-# )
-
-# YOLOv8 import
-from ultralytics import YOLO
-
-# ============================================================
-# YOLOv8 모델 설정
-# ============================================================
-YOLO_MODEL_PATH = "runs/train/yolov8m_shrimp2/weights/best.pt"
-yolo_model = None
-
-def load_yolo_model():
-    """YOLOv8 모델 로딩"""
-    global yolo_model
-    if yolo_model is None:
-        print(f"🔄 YOLOv8 모델 로딩 중: {YOLO_MODEL_PATH}")
-        yolo_model = YOLO(YOLO_MODEL_PATH)
-        print("✅ YOLOv8 모델 로딩 완료")
-    return yolo_model
-
-def detect_with_yolo(image, confidence=0.1):
-    """YOLOv8 모델로 검출"""
-    try:
-        model = load_yolo_model()
-
-        # 추론 실행
-        results = model.predict(
-            source=image,
-            conf=confidence,
-            verbose=False
-        )
-
-        detections = []
-        for result in results:
-            boxes = result.boxes
-            for box in boxes:
-                x1, y1, x2, y2 = box.xyxy[0].tolist()
-                conf = box.conf[0].item()
-
-                detections.append({
-                    'bbox': [x1, y1, x2, y2],
-                    'confidence': conf
-                })
-
-        print(f"✅ YOLOv8 검출 완료: {len(detections)}개")
-        return detections
-
-    except Exception as e:
-        print(f"❌ YOLOv8 검출 오류: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return []
-
-# ============================================================
-# Roboflow SDK 설정 (최적화된 방식)
-# ============================================================
-ROBOFLOW_API_KEY = "azcIL8KDJVJMYrsERzI7"
-
-# Roboflow Inference SDK 클라이언트 (connection pooling 지원)
-roboflow_client = InferenceHTTPClient(
-    api_url="https://serverless.roboflow.com",
-    api_key=ROBOFLOW_API_KEY
-)
-
-def detect_with_roboflow(image, confidence=0.065):
-    """Roboflow API를 사용한 최적화된 검출 (로컬 테스트와 동일)"""
-    try:
-        # 원본 이미지 보존
-        image_original = image
-        original_size = image_original.size
-
-        # 리사이즈 (API 전송용)
-        image_resized = image_original.copy()
-        image_resized.thumbnail((640, 640), Image.Resampling.LANCZOS)
-        print(f"📐 이미지 리사이즈: {original_size} → {image_resized.size}")
-
-        # 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")
-
-        print(f"🔄 Roboflow API 추론 시작...")
-
-        # 🚀 최적화 3: requests로 API 호출 (SDK 대신 사용 - 더 안정적)
-        response = requests.post(
-            'https://serverless.roboflow.com/vidraft/workflows/find-shrimp-6',
-            headers={'Content-Type': 'application/json'},
-            json={
-                'api_key': ROBOFLOW_API_KEY,
-                'inputs': {
-                    'image': {'type': 'base64', 'value': img_base64}
-                }
-            },
-            timeout=30
-        )
-
-        if response.status_code != 200:
-            print(f"❌ Roboflow API 오류: {response.status_code}")
-            print(f"응답: {response.text}")
-            return []
-
-        result = response.json()
-        print(f"🔍 Roboflow 응답: {json.dumps(result, indent=2, ensure_ascii=False)[:500]}...")
-
-        # Workflow 응답 구조 파싱
-        detections = []
-        predictions = []
-
-        # 방법 1: outputs[0].predictions.predictions (workflow 형태)
-        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']
-                # predictions가 dict이고 그 안에 predictions 배열이 있는 경우
-                if isinstance(pred_data, dict) and 'predictions' in pred_data:
-                    predictions = pred_data['predictions']
-                # predictions가 바로 배열인 경우
-                elif isinstance(pred_data, list):
-                    predictions = pred_data
-                else:
-                    predictions = [pred_data]
-
-        # 방법 2: 직접 predictions
-        elif isinstance(result, dict) and 'predictions' in result:
-            predictions = result['predictions']
-
-        # 방법 3: 다른 구조
-        elif isinstance(result, list):
-            predictions = result
-
-        print(f"📦 찾은 predictions: {len(predictions)}개")
-
-        # 스케일 계산 (리사이즈된 좌표 → 원본 좌표)
-        scale_x = original_size[0] / image_resized.size[0]
-        scale_y = original_size[1] / image_resized.size[1]
-        print(f"📏 스케일: x={scale_x:.2f}, y={scale_y:.2f}")
-
-        for pred in predictions:
-            # 클래스 필터링 (shrimp만 검출)
-            pred_class = pred.get('class', '')
-            if pred_class != 'shrimp':
-                continue
-
-            # 신뢰도 필터링
-            pred_confidence = pred.get('confidence', 0)
-            if pred_confidence < confidence:
-                continue
-
-            # 바운딩 박스 추출 (리사이즈된 좌표)
-            x = pred.get('x', 0)
-            y = pred.get('y', 0)
-            width = pred.get('width', 0)
-            height = pred.get('height', 0)
-
-            # 원본 크기로 스케일 변환
-            x_scaled = x * scale_x
-            y_scaled = y * scale_y
-            width_scaled = width * scale_x
-            height_scaled = height * scale_y
-
-            # 중심점 좌표를 좌상단/우하단 좌표로 변환
-            x1 = x_scaled - width_scaled / 2
-            y1 = y_scaled - height_scaled / 2
-            x2 = x_scaled + width_scaled / 2
-            y2 = y_scaled + height_scaled / 2
-
-            detections.append({
-                'bbox': [x1, y1, x2, y2],
-                'confidence': pred_confidence
-            })
-            print(f"  ✓ 검출 (shrimp): conf={pred_confidence:.2%}, bbox=[{x1:.0f},{y1:.0f},{x2:.0f},{y2:.0f}]")
-
-        print(f"✅ Roboflow 검출 완료: {len(detections)}개")
-        return detections
-
-    except Exception as e:
-        print(f"❌ Roboflow SDK 오류: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return []
-
-# ============================================================
-# 전역 모델 변수 (지연 로딩)
-# ============================================================
-processor = None
-model = None
-
-def load_rtdetr_on_demand():
-    """RT-DETR 모델을 필요시에만 로딩"""
-    global processor, model
-    if processor is None or model is None:
-        print("🔄 RT-DETR 모델 로딩 중...")
-        from test_visual_validation import load_rtdetr_model
-        processor, model = load_rtdetr_model()
-        print("✅ RT-DETR 로딩 완료")
-        return "✅ RT-DETR 모델 로딩 완료"
-    else:
-        return "ℹ️ RT-DETR 모델이 이미 로딩되어 있습니다"
-
-print("✅ VIDraft/Shrimp 클라우드 모델 사용 가능\n")
-
-# ============================================================
-# 라벨링 도구 전역 변수
-# ============================================================
-current_data = {
-    'folder': None,
-    'images': [],
-    'current_idx': 0,
-    'detections': {},
-    'selections': {},
-    'confidence_threshold': 0.2,
-    'image_cache': {},
-    'model_type': 'RT-DETR'  # 현재 선택된 모델
-}
-
-GROUND_TRUTH_FILE = "ground_truth.json"
-DATA_BASE = "data/흰다리새우 실측 데이터_익투스에이아이(주)"
-
-# ============================================================
-# 모델별 검출 함수
-# ============================================================
-
-def detect_with_selected_model(image, confidence, model_type):
-    """선택된 모델로 검출"""
-    if model_type == "RT-DETR":
-        if processor is None or model is None:
-            raise ValueError("⚠️ RT-DETR 모델이 로딩되지 않았습니다. '🔄 RT-DETR 로드' 버튼을 먼저 클릭하세요.")
-        from test_visual_validation import detect_with_rtdetr
-        return detect_with_rtdetr(image, processor, model, confidence)
-    elif model_type == "VIDraft/Shrimp":
-        return detect_with_roboflow(image, confidence)
-    elif model_type == "YOLOv8":
-        return detect_with_yolo(image, confidence)
-    else:
-        return []
-
-# ============================================================
-# 탭 1: 자동 검출 (Interactive Validation)
-# ============================================================
-
-def interactive_detect(image, confidence, filter_threshold, show_all, model_type, use_filter):
-    """대화형 검출"""
-    if image is None:
-        return None, "⚠️ 이미지를 업로드하세요."
-
-    try:
-        # 선택된 모델로 검출
-        all_detections = detect_with_selected_model(image, confidence, model_type)
-
-        # 필터 적용 여부에 따라 처리
-        if not use_filter:
-            # 필터 미사용: 신뢰도만 적용
-            filtered_detections = all_detections
-            for det in filtered_detections:
-                det['filter_score'] = det['confidence'] * 100
-                det['filter_reasons'] = [f"신뢰도: {det['confidence']:.0%} (필터 미사용)"]
-            all_detections_scored = filtered_detections
-        else:
-            # 필터 사용
-            if model_type in ["VIDraft/Shrimp", "YOLOv8"]:
-                # Roboflow & YOLOv8: 신뢰도를 필터 점수로 사용
-                for det in all_detections:
-                    det['filter_score'] = det['confidence'] * 100
-                    det['filter_reasons'] = [f"{model_type} 신뢰도: {det['confidence']:.0%}"]
-                all_detections_scored = all_detections
-            else:
-                # RT-DETR: Universal Filter 사용
-                from test_visual_validation import apply_universal_filter
-                all_detections_scored = apply_universal_filter(all_detections, image, threshold=0)
-
-            # 필터 임계값 적용
-            filtered_detections = [det for det in all_detections_scored if det['filter_score'] >= filter_threshold]
-
-        # 시각화
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        try:
-            font = ImageFont.truetype("arial.ttf", 14)
-            font_large = ImageFont.truetype("arial.ttf", 18)
-            font_small = ImageFont.truetype("arial.ttf", 10)
-        except:
-            font = ImageFont.load_default()
-            font_large = ImageFont.load_default()
-            font_small = ImageFont.load_default()
-
-        # 제거된 객체 먼저 표시 (빨간색)
-        rejected_detections = [det for det in all_detections_scored if det['filter_score'] < filter_threshold]
-        for idx, det in enumerate(rejected_detections, 1):
-            x1, y1, x2, y2 = det['bbox']
-            score = det['filter_score']
-
-            # 빨간색 박스 (제거됨)
-            draw.rectangle([x1, y1, x2, y2], outline="red", width=8)
-
-            # 라벨 (작게)
-            label = f"✗{idx} {score:.0f}점"
-            bbox = draw.textbbox((x1, y1 - 20), label, font=font_small)
-            draw.rectangle(bbox, fill="red")
-            draw.text((x1, y1 - 20), label, fill="white", font=font_small)
-
-        # 전체 검출 표시 (옵션) - 회색
-        if show_all:
-            for det in all_detections_scored:
-                if det not in filtered_detections and det not in rejected_detections:
-                    x1, y1, x2, y2 = det['bbox']
-                    draw.rectangle([x1, y1, x2, y2], outline="gray", width=4)
-
-        # 필터링된 결과 (통과) - 녹색/노란색/주황색
-        for idx, det in enumerate(filtered_detections, 1):
-            x1, y1, x2, y2 = det['bbox']
-            score = det['filter_score']
-
-            # 점수에 따라 색상
-            if score >= 75:
-                color = "lime"
-            elif score >= 50:
-                color = "yellow"
-            else:
-                color = "orange"
-
-            # 박스 (두껍게)
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=10)
-
-            # 라벨
-            label = f"✓#{idx} {score:.0f}점"
-            bbox = draw.textbbox((x1, y1 - 25), label, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 25), label, fill="black", font=font)
-
-            # 세부 정보 (작게)
-            details = f"{model_type}:{det['confidence']:.0%}"
-            draw.text((x1, y2 + 5), details, fill=color, font=font_small)
-
-        # 헤더
-        header = f"[{model_type}] ✓ {len(filtered_detections)}개 / ✗ {len(rejected_detections)}개 (전체: {len(all_detections_scored)}개)"
-        header_bbox = draw.textbbox((10, 10), header, font=font_large)
-        draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10],
-                      fill="black", outline="lime", width=2)
-        draw.text((10, 10), header, fill="lime", font=font_large)
-
-        # 정보 생성
-        info = f"""
-### 📊 검출 결과 (모델: {model_type})
-
-- **전체 검출**: {len(all_detections_scored)}개
-- **필터링 후**: {len(filtered_detections)}개
-- **제거됨**: {len(rejected_detections)}개
-
----
-
-### 🎯 검출된 객체 상세 (✅ 통과)
-
-"""
-
-        for idx, det in enumerate(filtered_detections, 1):
-            info += f"""
-**#{idx} - 점수: {det['filter_score']:.0f}점** ({model_type} 신뢰도: {det['confidence']:.0%})
-
-"""
-            # 주요 특징만 5개
-            for reason in det['filter_reasons'][:5]:
-                info += f"- {reason}\n"
-
-        if not filtered_detections:
-            info += """
-⚠️ **검출된 객체가 없습니다.**
-
-"""
-
-        # 제거된 객체 정보 추가
-        if rejected_detections:
-            info += f"""
-
----
-
-### ❌ 제거된 객체 ({len(rejected_detections)}개)
-
-"""
-            for idx, det in enumerate(rejected_detections[:3], 1):  # 최대 3개만 표시
-                info += f"""
-**제거 #{idx} - 점수: {det['filter_score']:.0f}점** (임계값 미달)
-- {model_type} 신뢰도: {det['confidence']:.0%}
-
-"""
-                # 실패 이유 표시
-                for reason in det['filter_reasons'][:3]:
-                    info += f"- {reason}\n"
-
-        return img, info
-
-    except Exception as e:
-        import traceback
-        error_detail = traceback.format_exc()
-        return None, f"❌ 오류 발생:\n\n```\n{error_detail}\n```"
-
-
-# ============================================================
-# 탭 2: 라벨링 도구 (Labeling Tool)
-# ============================================================
-
-def detect_with_rtdetr_fast(image, confidence=0.3):
-    """RT-DETR 빠른 검출"""
-    inputs = processor(images=image, return_tensors="pt")
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    target_sizes = torch.tensor([image.size[::-1]])
-    results = processor.post_process_object_detection(
-        outputs,
-        target_sizes=target_sizes,
-        threshold=confidence
-    )[0]
-
-    detections = []
-    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-        x1, y1, x2, y2 = box.tolist()
-        detections.append({
-            'bbox': [x1, y1, x2, y2],
-            'confidence': score.item()
-        })
-
-    return detections
-
-
-def load_existing_ground_truth():
-    """기존 ground_truth.json 로드"""
-    if os.path.exists(GROUND_TRUTH_FILE):
-        with open(GROUND_TRUTH_FILE, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    return {}
-
-
-def save_ground_truth(data):
-    """ground_truth.json 저장"""
-    backup_dir = "backups"
-    if not os.path.exists(backup_dir):
-        os.makedirs(backup_dir)
-
-    if os.path.exists(GROUND_TRUTH_FILE):
-        backup_name = f"ground_truth_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-        backup_path = os.path.join(backup_dir, backup_name)
-        import shutil
-        shutil.copy2(GROUND_TRUTH_FILE, backup_path)
-
-    with open(GROUND_TRUTH_FILE, 'w', encoding='utf-8') as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-
-    print(f"✅ Ground Truth 저장 완료: {len(data)}개 이미지")
-
-
-def get_folders():
-    """사용 가능한 폴더 목록"""
-    folders = sorted(glob.glob(os.path.join(DATA_BASE, "2*")))
-    return [os.path.basename(f) for f in folders if os.path.isdir(f)]
-
-
-def start_labeling(folder, conf_threshold, model_type):
-    """라벨링 시작"""
-    if not folder:
-        return None, "❌ 폴더를 선택하세요.", ""
-
-    current_data['folder'] = folder
-    current_data['confidence_threshold'] = conf_threshold
-    current_data['model_type'] = model_type
-
-    folder_path = os.path.join(DATA_BASE, folder)
-    all_images = sorted(glob.glob(os.path.join(folder_path, "*.jpg")))
-
-    # -1, -2 등이 붙은 파일 제외 (예: 251017_01-1.jpg 제외, 251017_01.jpg만 포함)
-    import re
-    images = [img for img in all_images if not re.search(r'-\d+\.jpg$', os.path.basename(img))]
-
-    if not images:
-        return None, "❌ 이미지 없음", ""
-
-    print(f"📁 폴더: {folder}")
-    print(f"   전체 이미지: {len(all_images)}개")
-    print(f"   라벨링 대상: {len(images)}개 (-숫자 파일 제외)")
-
-    current_data['images'] = images
-    current_data['current_idx'] = 0
-    current_data['detections'] = {}
-    current_data['selections'] = {}
-
-    # 기존 GT 로드
-    gt = load_existing_ground_truth()
-
-    # 이미 라벨링된 이미지 건너뛰기
-    for i, img_path in enumerate(images):
-        filename = os.path.basename(img_path)
-        if filename in gt:
-            current_data['selections'][filename] = [j for j in range(len(gt[filename]))]
-            print(f"⏭️  건너뛰기: {filename} (이미 라벨링됨)")
-
-    # 첫 미라벨링 이미지 찾기
-    while current_data['current_idx'] < len(images):
-        filename = os.path.basename(images[current_data['current_idx']])
-        if filename not in current_data['selections']:
-            break
-        current_data['current_idx'] += 1
-
-    if current_data['current_idx'] >= len(images):
-        return None, "✅ 모든 이미지 라벨링 완료!", ""
-
-    return show_current_image()
-
-
-def show_current_image():
-    """현재 이미지 표시"""
-    if current_data['current_idx'] >= len(current_data['images']):
-        return None, "✅ 완료!", ""
-
-    img_path = current_data['images'][current_data['current_idx']]
-    filename = os.path.basename(img_path)
-
-    # 캐시 확인
-    if filename in current_data['image_cache']:
-        image = current_data['image_cache'][filename]
-    else:
-        image = Image.open(img_path)
-        current_data['image_cache'][filename] = image
-
-    # 선택된 모델로 검출
-    if filename not in current_data['detections']:
-        if current_data['model_type'] == 'RT-DETR':
-            detections = detect_with_rtdetr_fast(image, current_data['confidence_threshold'])
-        elif current_data['model_type'] == 'YOLOv8':
-            detections = detect_with_yolo(image, current_data['confidence_threshold'])
-        else:  # VIDraft/Shrimp
-            detections = detect_with_roboflow(image, current_data['confidence_threshold'])
-        current_data['detections'][filename] = detections
-    else:
-        detections = current_data['detections'][filename]
-
-    # 선택된 박스
-    selected_indices = current_data['selections'].get(filename, [])
-
-    # 시각화
-    vis_image = draw_detections(image, detections, selected_indices)
-
-    info = f"""
-### 📁 {current_data['folder']} - 이미지 {current_data['current_idx']+1}/{len(current_data['images'])}
-
-**파일**: {filename}
-**모델**: {current_data['model_type']}
-
-**검출**: {len(detections)}개
-**선택**: {len(selected_indices)}개
-
----
-
-### 🖱️ 사용 방법:
-1. 이미지를 클릭하여 박스 선택/해제
-2. "다음" 버튼으로 저장 후 이동
-3. "건너뛰기"로 선택 없이 이동
-"""
-
-    return vis_image, info, filename
-
-
-def draw_detections(image, detections, selected_indices):
-    """검출 결과 그리기"""
-    img = image.copy()
-    draw = ImageDraw.Draw(img)
-
-    try:
-        font_tiny = ImageFont.truetype("arial.ttf", 10)
-        font_large = ImageFont.truetype("arial.ttf", 40)
-    except:
-        font_tiny = ImageFont.load_default()
-        font_large = ImageFont.load_default()
-
-    # 선택되지 않은 박스 먼저 (뒤쪽 레이어)
-    for idx, det in enumerate(detections):
-        if idx not in selected_indices:
-            x1, y1, x2, y2 = det['bbox']
-            draw.rectangle([x1, y1, x2, y2], outline="lime", width=20)
-            corner_label = f"#{idx+1}"
-            draw.rectangle([x1-2, y1-24, x1+30, y1-2], fill="lime")
-            draw.text((x1, y1 - 22), corner_label, fill="white", font=font_tiny)
-
-    # 선택된 박스 나중에 (앞쪽 레이어)
-    for idx, det in enumerate(detections):
-        if idx in selected_indices:
-            x1, y1, x2, y2 = det['bbox']
-            draw.rectangle([x1, y1, x2, y2], outline="blue", width=28)
-            corner_label = f"✓#{idx+1}"
-            draw.rectangle([x1-2, y1-24, x1+40, y1-2], fill="blue")
-            draw.text((x1, y1 - 22), corner_label, fill="white", font=font_tiny)
-
-    # 원형 버튼
-    for idx, det in enumerate(detections):
-        x1, y1, x2, y2 = det['bbox']
-        center_x = (x1 + x2) / 2
-        center_y = (y1 + y2) / 2
-
-        selected = idx in selected_indices
-        btn_color = "blue" if selected else "lime"
-        btn_text = f"✓{idx+1}" if selected else f"{idx+1}"
-
-        box_width = x2 - x1
-        box_height = y2 - y1
-        radius = min(55, box_width * 0.18, box_height * 0.35)
-
-        # 원형 버튼
-        draw.ellipse(
-            [center_x - radius, center_y - radius,
-             center_x + radius, center_y + radius],
-            fill=btn_color, outline="white", width=4
-        )
-        draw.text((center_x - radius*0.5, center_y - radius*0.6),
-                 btn_text, fill="white", font=font_large)
-
-    return img
-
-
-def labeling_click(image, filename, evt: gr.SelectData):
-    """이미지 클릭 이벤트"""
-    if not filename or filename not in current_data['detections']:
-        return image, "⚠️ 이미지를 먼저 로드하세요."
-
-    click_x, click_y = evt.index[0], evt.index[1]
-    detections = current_data['detections'][filename]
-    selected_indices = set(current_data['selections'].get(filename, []))
-
-    # 클릭한 박스 찾기
-    clicked_idx = None
-    button_candidates = []
-
-    # 버튼 영역 확인
-    for idx, det in enumerate(detections):
-        x1, y1, x2, y2 = det['bbox']
-        center_x = (x1 + x2) / 2
-        center_y = (y1 + y2) / 2
-
-        box_width = x2 - x1
-        box_height = y2 - y1
-        radius = min(55, box_width * 0.18, box_height * 0.35)
-
-        distance = ((click_x - center_x) ** 2 + (click_y - center_y) ** 2) ** 0.5
-
-        if distance <= radius:
-            button_candidates.append((idx, distance))
-
-    # 버튼 클릭이 있으면 선택
-    if button_candidates:
-        button_candidates.sort(key=lambda x: x[1])
-        clicked_idx = button_candidates[0][0]
-    else:
-        # 박스 영역 클릭 확인
-        for idx, det in enumerate(detections):
-            x1, y1, x2, y2 = det['bbox']
-            if x1 <= click_x <= x2 and y1 <= click_y <= y2:
-                clicked_idx = idx
-                break
-
-    # 선택 토글
-    if clicked_idx is not None:
-        if clicked_idx in selected_indices:
-            selected_indices.remove(clicked_idx)
-            print(f"❌ 선택 해제: 박스 #{clicked_idx+1}")
-        else:
-            selected_indices.add(clicked_idx)
-            print(f"✅ 선택: 박스 #{clicked_idx+1}")
-
-        current_data['selections'][filename] = list(selected_indices)
-
-        # 이미지 다시 그리기
-        img_path = current_data['images'][current_data['current_idx']]
-        image = Image.open(img_path)
-        vis_image = draw_detections(image, detections, list(selected_indices))
-
-        info = f"✅ 박스 #{clicked_idx+1} {'선택' if clicked_idx in selected_indices else '해제'}"
-        return vis_image, info
-
-    return image, "❌ 박스를 찾을 수 없습니다."
-
-
-def save_and_next():
-    """저장 후 다음"""
-    if current_data['current_idx'] >= len(current_data['images']):
-        return None, "✅ 완료!", ""
-
-    img_path = current_data['images'][current_data['current_idx']]
-    filename = os.path.basename(img_path)
-
-    # GT 저장
-    gt = load_existing_ground_truth()
-    selected_indices = current_data['selections'].get(filename, [])
-
-    if selected_indices:
-        detections = current_data['detections'][filename]
-        gt[filename] = [
-            {
-                'bbox': detections[i]['bbox'],
-                'folder': current_data['folder']
-            }
-            for i in selected_indices
-        ]
-        save_ground_truth(gt)
-        print(f"💾 저장: {filename} - {len(selected_indices)}개 박스")
-    else:
-        print(f"⏭️  건너뛰기: {filename} - 선택 없음")
-
-    # 다음 이미지
-    current_data['current_idx'] += 1
-
-    # 다음 미라벨링 이미지 찾기
-    while current_data['current_idx'] < len(current_data['images']):
-        next_filename = os.path.basename(current_data['images'][current_data['current_idx']])
-        if next_filename not in current_data['selections']:
-            break
-        current_data['current_idx'] += 1
-
-    if current_data['current_idx'] >= len(current_data['images']):
-        return None, "✅ 모든 이미지 라벨링 완료!", ""
-
-    return show_current_image()
-
-
-def skip_image():
-    """건너뛰기"""
-    current_data['current_idx'] += 1
-
-    if current_data['current_idx'] >= len(current_data['images']):
-        return None, "✅ 완료!", ""
-
-    return show_current_image()
-
-
-# ============================================================
-# 탭 3: 간단 데모 (App Demo)
-# ============================================================
-
-def demo_detect(image, confidence_threshold, filter_threshold, model_type, use_filter):
-    """간단한 데모 검출"""
-    if image is None:
-        return None, "이미지를 업로드하세요."
-
-    if isinstance(image, np.ndarray):
-        image = Image.fromarray(image)
-
-    # 선택된 모델로 검출
-    all_detections = detect_with_selected_model(image, confidence_threshold, model_type)
-
-    # 필터 적용 여부
-    if not use_filter:
-        # 필터 미사용
-        filtered_detections = all_detections
-        for det in filtered_detections:
-            det['filter_score'] = det['confidence'] * 100
-    else:
-        # 필터 사용
-        if model_type in ["Roboflow", "YOLOv8"]:
-            # Roboflow & YOLOv8: 신뢰도 기반 필터
-            for det in all_detections:
-                det['filter_score'] = det['confidence'] * 100
-            filtered_detections = [det for det in all_detections if det['filter_score'] >= filter_threshold]
-        else:
-            # RT-DETR: Universal Filter
-            from test_visual_validation import apply_universal_filter
-            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=8)
-
-        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"""
-📊 **검출 결과 (모델: {model_type}):**
-   • 전체 검출: {len(all_detections)}개
-   • 필터 통과: {len(filtered_detections)}개
-   • 제거됨: {len(all_detections) - len(filtered_detections)}개
-
-⚙️ **설정:**
-   • {model_type} Confidence: {confidence_threshold}
-   • Filter Threshold: {filter_threshold}
-
-🎯 **성능 (50개 GT 기준, RT-DETR):**
-   • 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 인터페이스 - 3개 탭으로 통합
-# ============================================================
-
-with gr.Blocks(title="🦐 새우 검출 통합 시스템", theme=gr.themes.Soft()) as demo:
-
-    gr.Markdown("""
-    # 🦐 새우 검출 통합 시스템
-
-    **3가지 모델로 새우를 정확하게 검출하세요**
-
-    ---
-    """)
-
-    # ==================== 최상단: 모델 선택 ====================
-    with gr.Row():
-        with gr.Column(scale=3):
-            model_selector = gr.Radio(
-                choices=["RT-DETR", "VIDraft/Shrimp", "YOLOv8"],
-                value="YOLOv8",
-                label="🤖 검출 모델 선택",
-                info="모든 탭에 적용됩니다"
-            )
-        with gr.Column(scale=1):
-            load_rtdetr_btn = gr.Button("🔄 RT-DETR 로드", size="sm", variant="secondary")
-            rtdetr_status = gr.Textbox(label="모델 상태", value="⏸️ RT-DETR 미로드 (VIDraft/Shrimp 클라우드 모델 사용 가능)", interactive=False, lines=1)
-
-    # RT-DETR 로딩 버튼 이벤트
-    load_rtdetr_btn.click(
-        load_rtdetr_on_demand,
-        inputs=[],
-        outputs=[rtdetr_status]
-    )
-
-    gr.Markdown("---")
-
-    with gr.Tabs():
-        # ==================== 탭 1: 자동 검출 ====================
-        with gr.TabItem("🤖 자동 검출 & 검증"):
-            gr.Markdown("""
-            ### 실시간으로 파라미터를 조정하며 검출 결과를 확인
-            최적화된 파라미터로 새우 검출을 테스트하세요.
-            """)
-
-            with gr.Row():
-                with gr.Column():
-                    input_image_detect = gr.Image(label="입력 이미지", type="pil")
-
-                    confidence_slider_detect = gr.Slider(
-                        0.01, 1.0, 0.1,
-                        step=0.01,
-                        label="신뢰도 임계값",
-                        info="RT-DETR: 0.065 | VIDraft/Shrimp: 0.3~0.5 | YOLOv8: 0.1~0.3 권장"
-                    )
-
-                    use_filter_check = gr.Checkbox(
-                        label="🔍 필터 점수 임계값 사용",
-                        value=False,
-                        info="체크하면 필터 점수 기준으로 추가 필터링"
-                    )
-
-                    filter_slider_detect = gr.Slider(
-                        0, 100, 90,
-                        step=5,
-                        label="필터 점수 임계값",
-                        info="RT-DETR: Universal Filter | VIDraft/Shrimp: 신뢰도 기반",
-                        visible=True
-                    )
-
-                    show_all_check = gr.Checkbox(
-                        label="전체 검출 결과 표시 (회색)",
-                        value=False
-                    )
-
-                    detect_btn = gr.Button("🚀 검출 실행", variant="primary", size="lg")
-
-                    # 예제 이미지 (결과 파일 제외)
-                    example_images = [
-                        "data/yolo_dataset/images/train/250818_01.jpg",
-                        "data/yolo_dataset/images/train/250818_03.jpg",
-                        "data/yolo_dataset/images/train/250818_04.jpg",
-                        "data/yolo_dataset/images/train/250818_05.jpg",
-                        "data/yolo_dataset/images/train/250818_10.jpg",
-                    ]
-
-                    # 파일이 존재하는 것만 필터링
-                    example_images = [img for img in example_images if os.path.exists(img)]
-
-                    if example_images:
-                        gr.Examples(
-                            examples=[[img] for img in example_images],
-                            inputs=[input_image_detect],
-                            label="📷 예제 이미지"
-                        )
-
-                with gr.Column():
-                    output_image_detect = gr.Image(label="검출 결과")
-                    output_info_detect = gr.Markdown()
-
-            detect_btn.click(
-                interactive_detect,
-                [input_image_detect, confidence_slider_detect, filter_slider_detect, show_all_check, model_selector, use_filter_check],
-                [output_image_detect, output_info_detect]
-            )
-
-            # 필터 사용 체크박스에 따라 필터 슬라이더 활성화/비활성화
-            def update_filter_interactivity(use_filter):
-                return gr.update(interactive=use_filter)
-
-            use_filter_check.change(
-                update_filter_interactivity,
-                inputs=[use_filter_check],
-                outputs=[filter_slider_detect]
-            )
-
-            gr.Markdown("""
-            ### 💡 사용 팁
-            - 모델을 선택하고 신뢰도를 조정하여 검출 결과를 확인하세요
-            - 검출이 적을 때는 신뢰도를 낮추고, 오검출이 많을 때는 높이세요
-            - 필터 기능을 사용하여 더 정확한 결과를 얻을 수 있습��다
-
-            **박스 색상:** 🟢 녹색(높은 확률) | 🟡 노란색(중간 확률) | 🟠 주황색(낮은 확률) | 🔴 빨간색(제거됨)
-            """)
-
-        # ==================== 탭 2: 라벨링 도구 ====================
-        with gr.TabItem("📝 Ground Truth 라벨링"):
-            gr.Markdown("""
-            ### 선택된 모델의 검출 결과에서 올바른 박스만 선택하여 라벨링
-            이미지를 클릭하여 새우 박스를 선택/해제하세요.
-            """)
-
-            with gr.Row():
-                with gr.Column(scale=1):
-                    folder_dropdown = gr.Dropdown(
-                        choices=get_folders(),
-                        label="📁 폴더 선택",
-                        info="라벨링할 폴더를 선택하세요"
-                    )
-
-                    conf_slider_label = gr.Slider(
-                        0.01, 0.5, 0.2,
-                        step=0.05,
-                        label="신뢰도",
-                        info="검출 민감도 조정"
-                    )
-
-                    start_btn = gr.Button("▶️ 라벨링 시작", variant="primary", size="lg")
-
-                    gr.Markdown("---")
-
-                    next_btn = gr.Button("⏭️ 저장 & 다음", variant="secondary", size="lg")
-                    skip_btn = gr.Button("⏩ 건너뛰기", size="lg")
-
-                    labeling_info = gr.Markdown("폴더를 선택하고 '라벨링 시작'을 클릭하세요.")
-
-                with gr.Column(scale=2):
-                    labeling_image = gr.Image(
-                        label="🖱️ 클릭하여 박스 선택/해제",
-                        type="pil",
-                        interactive=True
-                    )
-
-                    labeling_filename = gr.Textbox(visible=False)
-                    click_info = gr.Markdown()
-
-            # 이벤트 핸들러
-            start_btn.click(
-                start_labeling,
-                [folder_dropdown, conf_slider_label, model_selector],
-                [labeling_image, labeling_info, labeling_filename]
-            )
-
-            labeling_image.select(
-                labeling_click,
-                [labeling_image, labeling_filename],
-                [labeling_image, click_info]
-            )
-
-            next_btn.click(
-                save_and_next,
-                [],
-                [labeling_image, labeling_info, labeling_filename]
-            )
-
-            skip_btn.click(
-                skip_image,
-                [],
-                [labeling_image, labeling_info, labeling_filename]
-            )
-
-            gr.Markdown("""
-            ### 🖱️ 사용 방법
-            1. **모델 선택** (최상단에서 선택)
-            2. 폴더 선택 후 "라벨링 시작"
-            3. 이미지에서 **원형 버튼 클릭** 또는 **박스 영역 클릭**으로 선택/해제
-            4. "저장 & 다음"으로 다음 이미지로 이동 (자동 저장)
-            5. "건너뛰기"로 선택 없이 다음 이미지로
-
-            **💾 저장 위치:** `ground_truth.json` (자동 백업: `backups/`)
-            """)
-
-        # ==================== 탭 3: 간단 데모 ====================
-        with gr.TabItem("🎯 간단 데모"):
-            gr.Markdown("""
-            ### 빠르고 간단한 새우 검출 데모
-            이미지를 업로드하고 바로 결과를 확인하세요.
-            """)
-
-            with gr.Row():
-                with gr.Column():
-                    input_image_demo = gr.Image(label="입력 이미지", type="pil")
-
-                    confidence_slider_demo = gr.Slider(
-                        0.01, 1.0, 0.1,
-                        step=0.01,
-                        label="신뢰도",
-                        info="RT-DETR: 0.065 | VIDraft/Shrimp: 0.3~0.5 | YOLOv8: 0.1~0.3 권장"
-                    )
-
-                    use_filter_demo = gr.Checkbox(
-                        label="🔍 필터 점수 임계값 사용",
-                        value=False,
-                        info="체크하면 필터 점수 기준으로 추가 필터링"
-                    )
-
-                    filter_slider_demo = gr.Slider(
-                        0, 100, 90,
-                        step=5,
-                        label="필터 임계값",
-                        info="RT-DETR: Universal Filter | VIDraft/Shrimp: 신뢰도 기반",
-                        visible=True
-                    )
-
-                    demo_detect_btn = gr.Button("🚀 검출", variant="primary", size="lg")
-
-                    # 예제 이미지
-                    example_images_demo = [
-                        "data/yolo_dataset/images/train/250818_01.jpg",
-                        "data/yolo_dataset/images/train/250818_03.jpg",
-                        "data/yolo_dataset/images/train/250818_04.jpg",
-                        "data/yolo_dataset/images/train/250818_05.jpg",
-                        "data/yolo_dataset/images/train/250818_10.jpg",
-                    ]
-
-                    # 파일이 존재하는 것만 필터링
-                    example_images_demo = [img for img in example_images_demo if os.path.exists(img)]
-
-                    if example_images_demo:
-                        gr.Examples(
-                            examples=[[img] for img in example_images_demo],
-                            inputs=[input_image_demo],
-                            label="📷 예제 이미지"
-                        )
-
-                with gr.Column():
-                    output_image_demo = gr.Image(label="검출 결과")
-                    output_info_demo = gr.Markdown()
-
-            demo_detect_btn.click(
-                demo_detect,
-                [input_image_demo, confidence_slider_demo, filter_slider_demo, model_selector, use_filter_demo],
-                [output_image_demo, output_info_demo]
-            )
-
-            # 필터 사용 체크박스에 따라 필터 슬라이더 활성화/비활성화
-            use_filter_demo.change(
-                lambda x: gr.update(interactive=x),
-                inputs=[use_filter_demo],
-                outputs=[filter_slider_demo]
-            )
-
-            gr.Markdown("""
-            ### 💡 빠르고 간단한 검출
-            이미지를 업로드하거나 예제 이미지를 선택하여 바로 검출 결과를 확인하세요.
-            """)
-
-    gr.Markdown("""
-    ---
-
-    ### 🤖 모델 설명
-    - **RT-DETR**: 로컬 모델, 빠른 추론 속도, 오프라인 사용 가능
-    - **VIDraft/Shrimp**: 클라우드 모델, 인터넷 연결 필요
-    - **YOLOv8**: 로컬 커스텀 학습 모델, 빠른 추론 속도
-
-    ---
-
-    © 2025 VIDraft. All rights reserved.
-    """)
-
-if __name__ == "__main__":
-    print("\n" + "="*60)
-    print("🦐 새우 검출 통합 시스템 v2.1 시작")
-    print("="*60)
-    print("🤖 사용 가능한 모델:")
-    print("   1. RT-DETR (로컬)")
-    print("   2. VIDraft/Shrimp (클라우드)")
-    print("   3. YOLOv8 (로컬 학습) ⭐ 기본값")
-    print(f"\n📦 YOLOv8 모델: {YOLO_MODEL_PATH}")
-    print("="*60)
-
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=None,  # 자동으로 빈 포트 찾기
-        share=False
-    )

test_10_images.py

@@ -1,205 +0,0 @@
-# -*- 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

@@ -1,82 +0,0 @@
-# -*- 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

@@ -1,219 +0,0 @@
-# -*- 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

@@ -1,177 +0,0 @@
-# -*- 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

@@ -1,183 +0,0 @@
-# -*- 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

@@ -1,336 +0,0 @@
-# -*- 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

@@ -1,234 +0,0 @@
-"""
-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

@@ -1,112 +0,0 @@
-"""
-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

@@ -1,144 +0,0 @@
-"""
-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

@@ -1,367 +0,0 @@
-"""
-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")

train_yolo.py

@@ -1,127 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-YOLOv8 Few-shot Training for Shrimp Detection
-최소 데이터(50개)로 빠른 학습
-"""
-import sys
-sys.stdout.reconfigure(encoding='utf-8')
-
-from ultralytics import YOLO
-import torch
-from pathlib import Path
-import yaml
-
-def main():
-    print("=" * 60)
-    print("🦐 YOLOv8 Few-shot Training 시작")
-    print("=" * 60)
-
-    # GPU 확인
-    device = 'cuda' if torch.cuda.is_available() else 'cpu'
-    print(f"\n🖥️  Device: {device}")
-    if device == 'cuda':
-        print(f"   GPU: {torch.cuda.get_device_name(0)}")
-        print(f"   VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
-    else:
-        print("   ⚠️  GPU 없음 - CPU로 학습 (느림)")
-
-    # 데이터셋 경로
-    data_yaml = "data/yolo_dataset/data.yaml"
-
-    # data.yaml 확인
-    print(f"\n📂 데이터셋 설정 로딩: {data_yaml}")
-    with open(data_yaml, 'r', encoding='utf-8') as f:
-        data_config = yaml.safe_load(f)
-        print(f"   - Classes: {data_config['names']}")
-        print(f"   - Train: {data_config['train']}")
-        print(f"   - Val: {data_config['val']}")
-
-    # YOLOv8 모델 선택
-    # yolov8n: nano (가장 빠름, 작은 데이터셋에 적합)
-    # yolov8s: small
-    # yolov8m: medium
-    model_size = 'n'  # nano - Few-shot에 최적
-    print(f"\n🤖 모델: YOLOv8{model_size} (nano)")
-    print("   - 이유: 작은 데이터셋(50개)에서 과적합 방지")
-
-    # 모델 로드 (사전 학습 가중치 포함)
-    model = YOLO(f'yolov8{model_size}.pt')
-
-    # 학습 하이퍼파라미터
-    epochs = 100  # Few-shot이므로 많은 epoch
-    batch_size = 8  # 작은 배치 (데이터 적음)
-    imgsz = 640  # 입력 이미지 크기
-    patience = 20  # Early stopping patience
-
-    print(f"\n⚙️  학습 설정:")
-    print(f"   - Epochs: {epochs}")
-    print(f"   - Batch size: {batch_size}")
-    print(f"   - Image size: {imgsz}")
-    print(f"   - Patience: {patience} (early stopping)")
-    print(f"   - Device: {device}")
-
-    # Data Augmentation 설정 (Few-shot에 중요!)
-    print(f"\n🔄 Data Augmentation:")
-    augment_params = {
-        'hsv_h': 0.015,  # Hue augmentation (색상 변화)
-        'hsv_s': 0.7,    # Saturation augmentation
-        'hsv_v': 0.4,    # Value (brightness) augmentation
-        'degrees': 10.0,  # Rotation
-        'translate': 0.1,  # Translation
-        'scale': 0.5,     # Scaling
-        'shear': 0.0,     # Shear
-        'perspective': 0.0,  # Perspective
-        'flipud': 0.0,    # Vertical flip (새우는 세로 방향 없음)
-        'fliplr': 0.5,    # Horizontal flip (좌우는 OK)
-        'mosaic': 1.0,    # Mosaic augmentation
-        'mixup': 0.0,     # Mixup augmentation
-    }
-    for k, v in augment_params.items():
-        print(f"   - {k}: {v}")
-
-    print(f"\n🚀 학습 시작...")
-    print("   (진행 상황은 콘솔에 표시됩니다)")
-    print("-" * 60)
-
-    # 학습 실행
-    results = model.train(
-        data=data_yaml,
-        epochs=epochs,
-        batch=batch_size,
-        imgsz=imgsz,
-        device=device,
-        patience=patience,
-        save=True,
-        project='runs/train',
-        name='shrimp_yolov8n',
-        exist_ok=True,
-        pretrained=True,
-        verbose=True,
-        # Data augmentation
-        **augment_params
-    )
-
-    print("\n" + "=" * 60)
-    print("✅ 학습 완료!")
-    print("=" * 60)
-
-    # 결과 출력
-    best_model_path = Path('runs/train/shrimp_yolov8n/weights/best.pt')
-    last_model_path = Path('runs/train/shrimp_yolov8n/weights/last.pt')
-
-    print(f"\n📊 학습 결과:")
-    print(f"   - Best 모델: {best_model_path}")
-    print(f"   - Last 모델: {last_model_path}")
-    print(f"\n📈 성능 그래프:")
-    print(f"   - runs/train/shrimp_yolov8n/results.png")
-    print(f"\n📁 전체 결과:")
-    print(f"   - runs/train/shrimp_yolov8n/")
-
-    # Validation 결과 출력
-    print(f"\n🎯 다음 단계:")
-    print(f"   1. 결과 확인: runs/train/shrimp_yolov8n/")
-    print(f"   2. 성능 평가: python evaluate_yolo.py")
-    print(f"   3. 추론 테스트: python test_yolo_inference.py")
-
-if __name__ == "__main__":
-    main()

validate_ground_truth.py

@@ -1,190 +0,0 @@
-# -*- 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

@@ -1,135 +0,0 @@
-# -*- 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()