feat: ResNet50 변경

app.py

@@ -28,8 +28,9 @@ except ImportError:
             return 100
         return 20 * np.log10(255.0 / np.sqrt(mse))
 import io
+from PIL import Image
 import torch
-import lpips
+import torchvision.models as models
 import torchvision.transforms as transforms
 import ssl
 
@@ -45,6 +46,7 @@ class ImageSimilarityLeaderboard:
         
         # 메모리 최적화를 위한 캐시 및 락 (먼저 초기화)
         self._ref_image_cache = None
+        self._ref_embedding = None # ResNet 임베딩 캐시
         self._cache_loaded = False
         self._file_lock = threading.Lock()  # 파일 I/O 동시성 제어
         self._processing_lock = threading.Lock()  # 처리 동시성 제어
@@ -53,15 +55,25 @@ class ImageSimilarityLeaderboard:
         self.leaderboard_data = self.load_leaderboard()
         self.last_modified = self.get_file_modified_time()
         
-        # LPIPS 모델 초기화 (한 번만 로드)
+        # ResNet 모델 초기화 (한 번만 로드)
         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})")
+            # ResNet50 (ImageNet weights) - 마지막 FC 레이어 제외
+            resnet = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
+            self.resnet_model = torch.nn.Sequential(*(list(resnet.children())[:-1])).to(self.device)
+            self.resnet_model.eval()
+            
+            # 전처리 파이프라인
+            self.preprocess = transforms.Compose([
+                transforms.Resize(256),
+                transforms.CenterCrop(224),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ])
+            print(f"✅ ResNet 모델 로드 완료 (Device: {self.device})")
         except Exception as e:
-            print(f"⚠️ LPIPS 모델 로드 실패: {e}")
-            self.lpips_model = None
+            print(f"⚠️ ResNet 모델 로드 실패: {e}")
+            self.resnet_model = None
 
         # macOS 호환성을 위한 경고 억제
         import warnings
@@ -116,6 +128,17 @@ class ImageSimilarityLeaderboard:
                             ref_image = cv2.resize(ref_image, (new_width, new_height))
 
                     self._ref_image_cache = cv2.cvtColor(ref_image, cv2.COLOR_BGR2RGB)
+                    
+                    # ResNet 임베딩 계산 및 캐시
+                    if self.resnet_model is not None:
+                        try:
+                            pil_img = Image.fromarray(self._ref_image_cache)
+                            img_t = self.preprocess(pil_img).unsqueeze(0).to(self.device)
+                            with torch.no_grad():
+                                self._ref_embedding = self.resnet_model(img_t).flatten()
+                        except Exception as e:
+                            print(f"참조 이미지 임베딩 실패: {e}")
+
                     self._cache_loaded = True
                     # 메모리 정리
                     del ref_image
@@ -141,33 +164,33 @@ class ImageSimilarityLeaderboard:
     
     def calculate_similarity(self, image1, image2):
         try:
-            # 1) LPIPS 계산 (Perceptual Similarity) - 가장 중요
-            lpips_score = 0.0
-            if self.lpips_model is not None:
+            # 1) ResNet Feature Similarity (Semantic Similarity) - 가장 중요
+            resnet_score = 0.0
+            if self.resnet_model is not None and self._ref_embedding 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)
+                    # 사용자 이미지 전처리
+                    pil_img = Image.fromarray(image2) # image2 is RGB numpy array
+                    img_t = self.preprocess(pil_img).unsqueeze(0).to(self.device)
                     
                     with torch.no_grad():
-                        d = self.lpips_model(img1_t, img2_t)
-                        dist = d.item()
+                        user_emb = self.resnet_model(img_t).flatten()
                         
-                    # LPIPS 거리를 점수로 변환 (0이 동일, 보통 0.5 이상이면 꽤 다름)
-                    # 거리가 0이면 100점, 0.5면 50점, 1.0이면 0점
-                    # 조금 더 관대하게: max(0, (1 - dist) * 100)
-                    lpips_score = max(0, (1 - dist) * 100)
+                    # Cosine Similarity
+                    cos_sim = torch.nn.functional.cosine_similarity(
+                        self._ref_embedding.unsqueeze(0), 
+                        user_emb.unsqueeze(0)
+                    ).item()
+                    
+                    # Sigmoid Scoring Formula
+                    # Sim 0.61 (Bad) -> Score 14
+                    # Sim 0.77 (Good) -> Score 80
+                    # Sim 0.92 (Perfect) -> Score 99
+                    # Formula: 100 / (1 + exp(-20 * (sim - 0.7)))
+                    resnet_score = 100 / (1 + np.exp(-20 * (cos_sim - 0.7)))
                     
                 except Exception as e:
-                    print(f"LPIPS 계산 오류: {e}")
-                    lpips_score = 0.0
+                    print(f"ResNet 계산 오류: {e}")
+                    resnet_score = 0.0
 
             # 2) 그레이스케일 변환 (기존 로직 유지)
             if image1.ndim == 3:
@@ -209,14 +232,13 @@ class ImageSimilarityLeaderboard:
             hist_corr = cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL)
             hist_score = (hist_corr + 1) / 2  # -1~1 → 0~1
 
-            # 7) 최종 점수 계산 (LPIPS 비중 대폭 강화)
-            # LPIPS 모델이 있으면 LPIPS 80%, SSIM 10%, Hist 10%
-            # 없으면 기존 방식 (SSIM 70%, Hist 30%)
+            # 7) 최종 점수 계산 (ResNet 비중 대폭 강화)
+            # ResNet 모델이 있으면 ResNet 80%, SSIM 10%, Hist 10%
             
-            if self.lpips_model is not None:
-                final_score = (lpips_score * 0.8) + (ssim_score * 100 * 0.1) + (hist_score * 100 * 0.1)
+            if self.resnet_model is not None:
+                final_score = (resnet_score * 0.8) + (ssim_score * 100 * 0.1) + (hist_score * 100 * 0.1)
             else:
-                print(f"LPIPS 모델이 없어서 SSIM 70%, Hist 30%로 계산")
+                print(f"ResNet 모델이 없어서 SSIM 70%, Hist 30%로 계산")
                 final_score = (ssim_score * 0.7 + hist_score * 0.3) * 100
 
             # 8) PSNR이 높으면 약간의 보너스 (최대 5점)
@@ -228,12 +250,12 @@ class ImageSimilarityLeaderboard:
                 'ssim': float(ssim_score),
                 'psnr': float(psnr_score * 100),
                 'histogram': float(hist_score),
-                'lpips': float(lpips_score), # 결과에 포함
+                'resnet': float(resnet_score), # 결과에 포함
                 'final_score': float(final_score)
             }
         except Exception as e:
             print(f"유사도 계산 오류: {e}")
-            return {'ssim':0.0,'psnr':0.0,'histogram':0.0,'lpips':0.0,'final_score':0.0}
+            return {'ssim':0.0,'psnr':0.0,'histogram':0.0,'resnet':0.0,'final_score':0.0}
     
     def process_image(self, uploaded_image, username):
         """업로드된 이미지를 처리하고 점수를 계산합니다."""
@@ -298,7 +320,7 @@ class ImageSimilarityLeaderboard:
                     'ssim': float(round(similarity_scores['ssim'], 4)),
                     'psnr': float(round(similarity_scores['psnr'], 2)),
                     'histogram': float(round(similarity_scores['histogram'], 4)),
-                    'lpips': float(round(similarity_scores.get('lpips', 0.0), 2))
+                    'resnet': float(round(similarity_scores.get('resnet', 0.0), 2))
                 }
                 
                 # 같은 이름의 기존 기록이 있는지 확인하고, 더 높은 점수만 유지
@@ -489,7 +511,7 @@ def create_interface():
     """Gradio 인터페이스 생성"""
     with gr.Blocks(title="비슷한 이미지를 만들어주세요!", theme=gr.themes.Soft()) as demo:
         gr.Markdown("""
-        # 🏆 참조 이미지와 얼마나 유사한지 측정하여 리더보드에 등록해보세요!
+        # 🏆 롯데 비전 스튜디오 리더보드
         """)
         
         
@@ -616,83 +638,83 @@ def create_interface():
                     outputs=[result_output_challenge, leaderboard_output_challenge]
                 )
 
-            # # Originality반 탭
-            # with gr.Tab("🎨 Originality반"):
-            #     with gr.Row():
-            #         with gr.Column(scale=1):
-            #             gr.Markdown("### 📤 이미지 업로드 (Originality반)")
-            #             image_input_originality = gr.Image(
-            #                 label="비교할 이미지를 업로드하세요",
-            #                 type="pil",
-            #                 height=300
-            #             )
-            #             username_input_originality = gr.Textbox(
-            #                 label="사용자 이름",
-            #                 placeholder="이름을 입력하세요",
-            #                 max_lines=1
-            #             )
-            #             submit_btn_originality = gr.Button("🚀 점수 계산 및 등록", variant="primary", size="lg")
-
-            #         with gr.Column(scale=1):
-            #             gr.Markdown("### 📊 결과 (Originality반)")
-            #             result_output_originality = gr.Textbox(
-            #                 label="계산 결과",
-            #                 lines=10,
-            #                 interactive=False
-            #             )
-
-            #             gr.Markdown("### 🏅 Originality반 리더보드")
-            #             leaderboard_output_originality = gr.Dataframe(
-            #                 headers=["순위", "사용자명", "점수", "날짜"],
-            #                 datatype=["number", "str", "number", "str"],
-            #                 interactive=False
-            #             )
-
-            #     # Originality반 이벤트 핸들러
-            #     submit_btn_originality.click(
-            #         fn=process_user_image_originality,
-            #         inputs=[image_input_originality, username_input_originality],
-            #         outputs=[result_output_originality, leaderboard_output_originality]
-            #     )
-
-            # # BCE반 탭
-            # with gr.Tab("🔥 BCE반"):
-            #     with gr.Row():
-            #         with gr.Column(scale=1):
-            #             gr.Markdown("### 📤 이미지 업로드 (BCE반)")
-            #             image_input_bce = gr.Image(
-            #                 label="비교할 이미지를 업로드하세요",
-            #                 type="pil",
-            #                 height=300
-            #             )
-            #             username_input_bce = gr.Textbox(
-            #                 label="사용자 이름",
-            #                 placeholder="이름을 입력하세요",
-            #                 max_lines=1
-            #             )
-            #             submit_btn_bce = gr.Button("🚀 점수 계산 및 등록", variant="primary", size="lg")
-
-            #         with gr.Column(scale=1):
-            #             gr.Markdown("### 📊 결과 (BCE반)")
-            #             result_output_bce = gr.Textbox(
-            #                 label="계산 결과",
-            #                 lines=10,
-            #                 interactive=False
-            #             )
-
-            #             gr.Markdown("### 🏅 BCE반 리더보드")
-            #             leaderboard_output_bce = gr.Dataframe(
-            #                 headers=["순위", "사용자명", "점수", "날짜"],
-            #                 datatype=["number", "str", "number", "str"],
-            #                 interactive=False
-            #             )
-
-            #     # BCE반 이벤트 핸들러
-            #     submit_btn_bce.click(
-            #         fn=process_user_image_bce,
-            #         inputs=[image_input_bce, username_input_bce],
-            #         outputs=[result_output_bce, leaderboard_output_bce]
-            #     )
+            # Originality반 탭
+            with gr.Tab("🎨 Originality반"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📤 이미지 업로드 (Originality반)")
+                        image_input_originality = gr.Image(
+                            label="비교할 이미지를 업로드하세요",
+                            type="pil",
+                            height=300
+                        )
+                        username_input_originality = gr.Textbox(
+                            label="사용자 이름",
+                            placeholder="이름을 입력하세요",
+                            max_lines=1
+                        )
+                        submit_btn_originality = gr.Button("🚀 점수 계산 및 등록", variant="primary", size="lg")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 결과 (Originality반)")
+                        result_output_originality = gr.Textbox(
+                            label="계산 결과",
+                            lines=10,
+                            interactive=False
+                        )
+
+                        gr.Markdown("### 🏅 Originality반 리더보드")
+                        leaderboard_output_originality = gr.Dataframe(
+                            headers=["순위", "사용자명", "점수", "날짜"],
+                            datatype=["number", "str", "number", "str"],
+                            interactive=False
+                        )
+
+                # Originality반 이벤트 핸들러
+                submit_btn_originality.click(
+                    fn=process_user_image_originality,
+                    inputs=[image_input_originality, username_input_originality],
+                    outputs=[result_output_originality, leaderboard_output_originality]
+                )
+
+            # BCE반 탭
+            with gr.Tab("���� BCE반"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📤 이미지 업로드 (BCE반)")
+                        image_input_bce = gr.Image(
+                            label="비교할 이미지를 업로드하세요",
+                            type="pil",
+                            height=300
+                        )
+                        username_input_bce = gr.Textbox(
+                            label="사용자 이름",
+                            placeholder="이름을 입력하세요",
+                            max_lines=1
+                        )
+                        submit_btn_bce = gr.Button("🚀 점수 계산 및 등록", variant="primary", size="lg")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 결과 (BCE반)")
+                        result_output_bce = gr.Textbox(
+                            label="계산 결과",
+                            lines=10,
+                            interactive=False
+                        )
+
+                        gr.Markdown("### 🏅 BCE반 리더보드")
+                        leaderboard_output_bce = gr.Dataframe(
+                            headers=["순위", "사용자명", "점수", "날짜"],
+                            datatype=["number", "str", "number", "str"],
+                            interactive=False
+                        )
+
+                # BCE반 이벤트 핸들러
+                submit_btn_bce.click(
+                    fn=process_user_image_bce,
+                    inputs=[image_input_bce, username_input_bce],
+                    outputs=[result_output_bce, leaderboard_output_bce]
+                )
         
         # 페이지 로드 시 모든 리더보드 표시
         demo.load(