Update models/clip_model.py

models/clip_model.py

@@ -30,6 +30,9 @@ logger = logging.getLogger(__name__)
 CLIP_MODEL_NAME = os.getenv('CLIP_MODEL_NAME', 'Bingsu/clip-vit-large-patch14-ko')
 DEVICE = "cuda" if torch.cuda.is_available() and os.getenv('USE_GPU', 'True').lower() == 'true' else "cpu"
 
+# 요청 타임아웃 설정
+REQUEST_TIMEOUT = int(os.getenv('REQUEST_TIMEOUT', '10'))  # 10초 타임아웃
+
 def preload_clip_model():
     """CLIP 모델을 사전에 다운로드하고 캐시"""
     try:
@@ -40,7 +43,8 @@ def preload_clip_model():
         CLIPModel.from_pretrained(
             CLIP_MODEL_NAME, 
             cache_dir='/tmp/huggingface_cache',
-            low_cpu_mem_usage=True  # 메모리 사용 최적화
+            low_cpu_mem_usage=True,  # 메모리 사용 최적화
+            torch_dtype=torch.float32  # float32 타입으로 통일
         )
         
         CLIPProcessor.from_pretrained(
@@ -62,6 +66,7 @@ class KoreanCLIPModel:
         """CLIP 모델 초기화 - 메모리 최적화"""
         self.device = device
         self.model_name = model_name
+        self.embedding_dim = None  # 추가: 임베딩 차원 저장
         
         logger.info(f"CLIP 모델 '{model_name}' 로드 중 (device: {device})...")
         
@@ -70,14 +75,20 @@ class KoreanCLIPModel:
             os.environ["TRANSFORMERS_CACHE"] = "/tmp/transformers_cache"
             os.makedirs("/tmp/transformers_cache", exist_ok=True)
             
-            # 메모리 최적화 옵션 추가
+            # 메모리 최적화 옵션 추가 - float32 타입으로 통일
             self.model = CLIPModel.from_pretrained(
                 model_name,
                 cache_dir='/tmp/huggingface_cache',
                 low_cpu_mem_usage=True,
-                torch_dtype=torch.float16  # 반정밀도 사용
+                torch_dtype=torch.float32  # float16에서 float32로 변경
             ).to(device)
             
+            # 임베딩 차원 저장
+            self.text_embedding_dim = self.model.text_model.config.hidden_size
+            self.image_embedding_dim = self.model.vision_model.config.hidden_size
+            
+            logger.info(f"텍스트 임베딩 차원: {self.text_embedding_dim}, 이미지 임베딩 차원: {self.image_embedding_dim}")
+            
             self.processor = CLIPProcessor.from_pretrained(
                 model_name,
                 cache_dir='/tmp/huggingface_cache'
@@ -114,7 +125,8 @@ class KoreanCLIPModel:
             return text_embeddings.cpu().numpy()
         except Exception as e:
             logger.error(f"텍스트 인코딩 중 오류 발생: {str(e)}")
-            return np.zeros((len(text), self.model.text_embed_dim))
+            # 차원이 일치하는 0 벡터 반환
+            return np.zeros((len(text), self.text_embedding_dim))
             
     def encode_image(self, image_source):
         """
@@ -130,12 +142,32 @@ class KoreanCLIPModel:
             # 이미지 로드 (URL, 파일 경로, PIL 이미지 객체 또는 Base64)
             if isinstance(image_source, str):
                 if image_source.startswith('http'):
-                    # URL에서 이미지 로드
-                    response = requests.get(image_source)
-                    image = Image.open(BytesIO(response.content)).convert('RGB')
+                    # URL에서 이미지 로드 - 타임아웃 추가
+                    try:
+                        response = requests.get(image_source, timeout=REQUEST_TIMEOUT)
+                        if response.status_code == 200:
+                            image = Image.open(BytesIO(response.content)).convert('RGB')
+                        else:
+                            logger.warning(f"이미지 URL에서 응답 오류: {response.status_code}")
+                            # 오류 시 더미 이미지 생성 (검은색 이미지)
+                            image = Image.new('RGB', (224, 224), color='black')
+                    except requests.exceptions.RequestException as e:
+                        logger.error(f"이미지 URL 접근 중 오류 발생: {str(e)}")
+                        # 오류 시 더미 이미지 생성 (검은색 이미지)
+                        image = Image.new('RGB', (224, 224), color='black')
                 else:
                     # 로컬 파일에서 이미지 로드
-                    image = Image.open(image_source).convert('RGB')
+                    try:
+                        if os.path.exists(image_source):
+                            image = Image.open(image_source).convert('RGB')
+                        else:
+                            logger.warning(f"이미지 파일이 존재하지 않음: {image_source}")
+                            # 파일이 없는 경우 더미 이미지 생성
+                            image = Image.new('RGB', (224, 224), color='black')
+                    except Exception as e:
+                        logger.error(f"로컬 이미지 로드 중 오류: {str(e)}")
+                        # 오류 시 더미 이미지 생성
+                        image = Image.new('RGB', (224, 224), color='black')
             else:
                 # 이미 PIL 이미지 객체인 경우
                 image = image_source.convert('RGB')
@@ -151,29 +183,38 @@ class KoreanCLIPModel:
             return image_embeddings.cpu().numpy()
         except Exception as e:
             logger.error(f"이미지 인코딩 중 오류 발생: {str(e)}")
-            return np.zeros((1, self.model.vision_embed_dim))
+            # 차원이 일치하는 0 벡터 반환
+            return np.zeros((1, self.image_embedding_dim))
     
-    def calculate_similarity(self, text_embedding, image_embedding=None):
+    def calculate_similarity(self, embedding1, embedding2):
         """
-        텍스트와 이미지 임베딩 간의 유사도 계산
+        두 임베딩 간의 유사도 계산
         
         Args:
-            text_embedding (numpy.ndarray): 텍스트 임베딩
-            image_embedding (numpy.ndarray, optional): 이미지 임베딩 (없으면 텍스트만 비교)
+            embedding1 (numpy.ndarray): 첫 번째 임베딩
+            embedding2 (numpy.ndarray): 두 번째 임베딩
             
         Returns:
             float: 유사도 점수 (0~1 사이)
         """
-        if image_embedding is None:
-            # 텍스트-텍스트 유사도 계산 (코사인 유사도)
-            similarity = np.dot(text_embedding, text_embedding.T)[0, 0]
-        else:
-            # 텍스트-이미지 유사도 계산 (코사인 유사도)
-            similarity = np.dot(text_embedding, image_embedding.T)[0, 0]
+        try:
+            # 차원 확인 및 로깅
+            logger.debug(f"임베딩1 shape: {embedding1.shape}, 임베딩2 shape: {embedding2.shape}")
             
-        # 유사도를 0~1 범위로 정규화
-        similarity = (similarity + 1) / 2
-        return float(similarity)
+            # 차원이 다른 경우 예외 처리 - 차원이 맞지 않으면 기본값 반환
+            if embedding1.shape[1] != embedding2.shape[1]:
+                logger.warning(f"임베딩 차원 불일치: {embedding1.shape} vs {embedding2.shape}")
+                return 0.5
+                
+            # 코사인 유사도 계산
+            similarity = np.dot(embedding1, embedding2.T)[0, 0]
+                
+            # 유사도를 0~1 범위로 정규화
+            similarity = (similarity + 1) / 2
+            return float(similarity)
+        except Exception as e:
+            logger.error(f"유사도 계산 중 오류 발생: {str(e)}")
+            return 0.5  # 오류 시 중간값 반환
         
     def encode_batch_texts(self, texts):
         """