feat: LPIPS로 점수측정방법 변경

app.py

@@ -28,6 +28,13 @@ except ImportError:
             return 100
         return 20 * np.log10(255.0 / np.sqrt(mse))
 import io
+import torch
+import lpips
+import torchvision.transforms as transforms
+import ssl
+
+# Fix SSL error for model download (macOS specific)
+ssl._create_default_https_context = ssl._create_unverified_context
 
 class ImageSimilarityLeaderboard:
     def __init__(self, reference_image_path="label2.jpg", data_file="leaderboard.json"):
@@ -45,6 +52,16 @@ class ImageSimilarityLeaderboard:
         # 락 초기화 후 데이터 로드
         self.leaderboard_data = self.load_leaderboard()
         self.last_modified = self.get_file_modified_time()
+        
+        # LPIPS 모델 초기화 (한 번만 로드)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        try:
+            self.lpips_model = lpips.LPIPS(net='vgg').to(self.device)
+            self.lpips_model.eval() # 평가 모드
+            print(f"✅ LPIPS 모델 로드 완료 (Device: {self.device})")
+        except Exception as e:
+            print(f"⚠️ LPIPS 모델 로드 실패: {e}")
+            self.lpips_model = None
 
         # macOS 호환성을 위한 경고 억제
         import warnings
@@ -124,7 +141,35 @@ class ImageSimilarityLeaderboard:
     
     def calculate_similarity(self, image1, image2):
         try:
-            # 1) 그레이스케일 변환
+            # 1) LPIPS 계산 (Perceptual Similarity) - 가장 중요
+            lpips_score = 0.0
+            if self.lpips_model is not None:
+                try:
+                    # LPIPS를 위한 전처리 (-1 ~ 1 사이 값으로 정규화, RGB)
+                    # 이미지 크기는 224x224 이상 권장, 여기서는 256x256으로 리사이즈
+                    lpips_size = (256, 256)
+                    
+                    # numpy -> tensor
+                    img1_t = cv2.resize(image1, lpips_size).astype(np.float32) / 127.5 - 1.0
+                    img2_t = cv2.resize(image2, lpips_size).astype(np.float32) / 127.5 - 1.0
+                    
+                    img1_t = torch.from_numpy(img1_t).permute(2, 0, 1).unsqueeze(0).to(self.device)
+                    img2_t = torch.from_numpy(img2_t).permute(2, 0, 1).unsqueeze(0).to(self.device)
+                    
+                    with torch.no_grad():
+                        d = self.lpips_model(img1_t, img2_t)
+                        dist = d.item()
+                        
+                    # LPIPS 거리를 점수로 변환 (0이 동일, 보통 0.5 이상이면 꽤 다름)
+                    # 거리가 0이면 100점, 0.5면 50점, 1.0이면 0점
+                    # 조금 더 관대하게: max(0, (1 - dist) * 100)
+                    lpips_score = max(0, (1 - dist) * 100)
+                    
+                except Exception as e:
+                    print(f"LPIPS 계산 오류: {e}")
+                    lpips_score = 0.0
+
+            # 2) 그레이스케일 변환 (기존 로직 유지)
             if image1.ndim == 3:
                 gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)
             else:
@@ -135,7 +180,7 @@ class ImageSimilarityLeaderboard:
             else:
                 gray2 = image2.copy()
 
-            # 2) 각 이미지를 독립적으로 표준 크기로 리사이즈 (512x512)
+            # 3) 각 이미지를 독립적으로 표준 크기로 리사이즈 (512x512)
             target_size = (512, 512)
 
             gray1 = cv2.resize(gray1, target_size, interpolation=cv2.INTER_LINEAR)
@@ -164,26 +209,31 @@ class ImageSimilarityLeaderboard:
             hist_corr = cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL)
             hist_score = (hist_corr + 1) / 2  # -1~1 → 0~1
 
-            # 7) 최종 점수 계산 (더 단순하게)
-            final_score = (ssim_score * 0.7 + hist_score * 0.3) * 100
+            # 7) 최종 점수 계산 (LPIPS 비중 대폭 강화)
+            # LPIPS 모델이 있으면 LPIPS 80%, SSIM 10%, Hist 10%
+            # 없으면 기존 방식 (SSIM 70%, Hist 30%)
+            
+            if self.lpips_model is not None:
+                final_score = (lpips_score * 0.8) + (ssim_score * 100 * 0.1) + (hist_score * 100 * 0.1)
+            else:
+                print(f"LPIPS 모델이 없어서 SSIM 70%, Hist 30%로 계산")
+                final_score = (ssim_score * 0.7 + hist_score * 0.3) * 100
 
-            # 8) PSNR이 높으면 약간의 보너스
+            # 8) PSNR이 높으면 약간의 보너스 (최대 5점)
             if psnr_score > 0.8:
-                bonus = min((psnr_score - 0.8) * 25, 5)  # 최대 5점 보너스
+                bonus = min((psnr_score - 0.8) * 25, 5)
                 final_score = min(final_score + bonus, 100)
 
             return {
                 'ssim': float(ssim_score),
-                'psnr': float(psnr_score * 100),  # 백분율로 변환
+                'psnr': float(psnr_score * 100),
                 'histogram': float(hist_score),
-                'template': 0.0,  # 사용하지 않음
-                'edge': 0.0,      # 사용하지 않음
-                'phash': 0.0,     # 사용하지 않음
+                'lpips': float(lpips_score), # 결과에 포함
                 'final_score': float(final_score)
             }
         except Exception as e:
             print(f"유사도 계산 오류: {e}")
-            return {'ssim':0.0,'psnr':0.0,'histogram':0.0,'template':0.0,'edge':0.0,'phash':0.0,'final_score':0.0}
+            return {'ssim':0.0,'psnr':0.0,'histogram':0.0,'lpips':0.0,'final_score':0.0}
     
     def process_image(self, uploaded_image, username):
         """업로드된 이미지를 처리하고 점수를 계산합니다."""
@@ -247,7 +297,8 @@ class ImageSimilarityLeaderboard:
                     'date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                     'ssim': float(round(similarity_scores['ssim'], 4)),
                     'psnr': float(round(similarity_scores['psnr'], 2)),
-                    'histogram': float(round(similarity_scores['histogram'], 4))
+                    'histogram': float(round(similarity_scores['histogram'], 4)),
+                    'lpips': float(round(similarity_scores.get('lpips', 0.0), 2))
                 }
                 
                 # 같은 이름의 기존 기록이 있는지 확인하고, 더 높은 점수만 유지

requirements.txt

@@ -2,3 +2,6 @@ gradio
 opencv-python
 numpy
 pandas
+torch
+torchvision
+lpips