Update smart_breed_matcher.py

smart_breed_matcher.py

@@ -130,51 +130,66 @@ class SmartBreedMatcher:
     #     return final_similarity
 
     def _calculate_breed_similarity(self, breed1_features: Dict, breed2_features: Dict) -> float:
-        """計算兩個品種之間的相似度，包含健康和噪音因素"""
-        # 計算描述文本的相似度
+        """增強版品種相似度計算"""
+        # 基礎相似度計算
         desc1_embedding = self._get_cached_embedding(breed1_features['description'])
         desc2_embedding = self._get_cached_embedding(breed2_features['description'])
         description_similarity = float(util.pytorch_cos_sim(desc1_embedding, desc2_embedding))
-    
-        # 使用改進後的尺寸相似度計算
-        size_similarity = self._calculate_size_similarity(
-            breed1_features['size'],
+        
+        # 尺寸相似度（加強版）
+        size_similarity = self._calculate_size_similarity_enhanced(
+            breed1_features['size'], 
             breed2_features['size'],
-            self._get_preferred_size_range(breed1_features['description'])
+            breed2_features['description']  # 加入描述以判斷適應性
         )
-    
-        # 其他相似度計算
-        exercise_similarity = self._calculate_exercise_similarity(breed1_features['exercise'], breed2_features['exercise'])
+        
+        # 運動需求相似度（加強版）
+        exercise_similarity = self._calculate_exercise_similarity_enhanced(
+            breed1_features['exercise'],
+            breed2_features['exercise']
+        )
+        
+        # 美容需求相似度
+        grooming_similarity = self._calculate_grooming_similarity(
+            breed1_features['breed_name'],
+            breed2_features['breed_name']
+        )
+        
+        # 其他相似度計算保持不變
         temp1_embedding = self._get_cached_embedding(breed1_features['temperament'])
         temp2_embedding = self._get_cached_embedding(breed2_features['temperament'])
         temperament_similarity = float(util.pytorch_cos_sim(temp1_embedding, temp2_embedding))
+        
         health_score1 = self._calculate_health_score(breed1_features['breed_name'])
         health_score2 = self._calculate_health_score(breed2_features['breed_name'])
         health_similarity = 1.0 - abs(health_score1 - health_score2)
+        
         noise_similarity = self._calculate_noise_similarity(
             breed1_features['breed_name'],
             breed2_features['breed_name']
         )
     
-        # 調整權重，增加尺寸的重要性
+        # 調整權重分配
         weights = {
-            'description': 0.20,  # 降低描述權重
-            'temperament': 0.20,
-            'exercise': 0.20,
-            'size': 0.20,        # 顯著提高尺寸權重
-            'health': 0.10,      # 略微降低
-            'noise': 0.10        # 略微降低
+            'size': 0.20,        # 仍然重要但不過分主導
+            'exercise': 0.20,    # 保持高權重因為這是主要需求
+            'temperament': 0.15, # 保持不變因為性格很重要
+            'grooming': 0.15,    # 保持不變
+            'health': 0.15,      # 提高一點因為這影響長期生活
+            'description': 0.10, # 保持不變
+            'noise': 0.05        # 保持不變因為不是主要考慮因素
         }
-    
+        
         final_similarity = (
-            description_similarity * weights['description'] +
-            temperament_similarity * weights['temperament'] +
-            exercise_similarity * weights['exercise'] +
             size_similarity * weights['size'] +
+            exercise_similarity * weights['exercise'] +
+            grooming_similarity * weights['grooming'] +
+            temperament_similarity * weights['temperament'] +
+            description_similarity * weights['description'] +
             health_similarity * weights['health'] +
             noise_similarity * weights['noise']
         )
-    
+        
         return final_similarity
 
 
@@ -240,104 +255,111 @@ class SmartBreedMatcher:
             'scores': {k: round(v, 4) for k, v in scores.items()}
         }
 
-    def _get_preferred_size_range(self, description: str) -> tuple:
-        """分析描述文本，確定用戶偏好的尺寸範圍"""
-        description = description.lower()
-        
-        # 定義關鍵詞匹配
-        size_indicators = {
-            'small': ['small', 'tiny', 'little'],
-            'medium': ['medium', 'medium-sized', 'moderate size'],
-            'medium-large': ['medium to large', 'slightly larger', 'medium-large'],
-            'large': ['large', 'big'],
-            'giant': ['giant', 'huge', 'very large']
+    def _calculate_size_similarity_enhanced(self, size1: str, size2: str, description: str) -> float:
+        """增強版尺寸相似度計算"""
+        # 更細緻的尺寸映射
+        size_map = {
+            'Tiny': 0,
+            'Small': 1,
+            'Small-Medium': 2,
+            'Medium': 3,
+            'Medium-Large': 4,
+            'Large': 5,
+            'Giant': 6
         }
         
-        # 檢測負面提及
-        negative_indicators = {
-            'small': ['not too small', 'not small'],
-            'large': ['not too large', 'not too big', 'not large'],
-            'giant': ['not giant', 'not huge']
-        }
+        # 轉換尺寸到數值
+        value1 = size_map.get(self._normalize_size(size1), 3)  # 預設為 Medium
+        value2 = size_map.get(self._normalize_size(size2), 3)
         
-        # 默認為中型
-        preferred_min = 2  # medium
-        preferred_max = 3  # large
+        # 計算基礎相似度
+        base_similarity = 1.0 - (abs(value1 - value2) / 6.0)
         
-        # 分析描述中的尺寸偏好
-        for size, keywords in size_indicators.items():
-            for keyword in keywords:
-                if keyword in description:
-                    if size == 'small':
-                        preferred_min, preferred_max = 1, 2
-                    elif size == 'medium':
-                        preferred_min, preferred_max = 2, 2
-                    elif size == 'medium-large':
-                        preferred_min, preferred_max = 2, 3
-                    elif size == 'large':
-                        preferred_min, preferred_max = 3, 3
-                    elif size == 'giant':
-                        preferred_min, preferred_max = 3, 4
+        # 根據用戶需求的尺寸偏好調整分數
+        if size2 in ['Small', 'Tiny']:
+            base_similarity *= 0.5  # 顯著降低小型犬的分數
+        elif size2 == 'Giant':
+            base_similarity *= 0.6  # 顯著降低巨型犬的分數
+        elif size2 in ['Medium', 'Medium-Large']:
+            base_similarity *= 1.2  # 提高中型和中大型犬的分數
         
-        # 檢查負面提及並調整
-        for size, keywords in negative_indicators.items():
-            for keyword in keywords:
-                if keyword in description:
-                    if size == 'small':
-                        preferred_min = max(2, preferred_min)
-                    elif size == 'large':
-                        preferred_max = min(2, preferred_max)
-                    elif size == 'giant':
-                        preferred_max = min(3, preferred_max)
+        # 考慮適應性
+        if 'apartment' in description.lower() and size2 in ['Large', 'Giant']:
+            base_similarity *= 0.8  # 降低大型犬在公寓的適應性分數
         
-        return (preferred_min, preferred_max)
+        return min(1.0, base_similarity)  # 確保不超過1.0
     
-    def _calculate_size_similarity(self, size1: str, size2: str, preferred_range: tuple = None) -> float:
-        """改進的尺寸相似度計算"""
-        # 更細緻的尺寸映射
-        size_map = {
-            'Tiny': 0.5,
-            'Small': 1,
-            'Small-Medium': 1.5,
-            'Medium': 2,
-            'Medium-Large': 2.5,
-            'Large': 3,
-            'Giant': 4
+    def _normalize_size(self, size: str) -> str:
+        """標準化尺寸分類"""
+        size = size.lower()
+        if 'tiny' in size:
+            return 'Tiny'
+        elif 'small' in size:
+            return 'Small'
+        elif 'medium' in size and 'large' in size:
+            return 'Medium-Large'
+        elif 'medium' in size:
+            return 'Medium'
+        elif 'giant' in size:
+            return 'Giant'
+        elif 'large' in size:
+            return 'Large'
+        return 'Medium'  # 預設
+    
+    def _calculate_exercise_similarity_enhanced(self, exercise1: str, exercise2: str) -> float:
+        """增強版運動需求相似度計算"""
+        exercise_map = {
+            'Low': 1,
+            'Moderate': 2,
+            'High': 3,
+            'Very High': 4
         }
         
-        # 獲取數值
-        value1 = size_map.get(size1, 2)
-        value2 = size_map.get(size2, 2)
+        value1 = exercise_map.get(exercise1, 2)
+        value2 = exercise_map.get(exercise2, 2)
         
-        # 基礎相似度計算
-        base_similarity = 1.0 - (abs(value1 - value2) / 3.5)  # 3.5 是最大可能差異
+        # 基礎相似度
+        base_similarity = 1.0 - abs(value1 - value2) / 3.0
         
-        # 如果有偏好範圍，進行額外調整
-        if preferred_range:
-            preferred_min, preferred_max = preferred_range
-            
-            # 檢查是否在偏好範圍內
-            in_range = (preferred_min <= value2 <= preferred_max)
-            
-            # 如果不在範圍內，根據距離降低分數
-            if not in_range:
-                distance_to_range = min(
-                    abs(value2 - preferred_min),
-                    abs(value2 - preferred_max)
-                )
-                penalty = distance_to_range * 0.2  # 每單位差異降低20%
-                base_similarity *= (1 - penalty)
+        # 根據用戶需求調整
+        if exercise2 in ['High', 'Very High']:
+            base_similarity *= 1.2  # 提高高運動量品種的分數
+        elif exercise2 == 'Low':
+            base_similarity *= 0.7  # 降低低運動量品種的分數
         
-        return max(0.0, min(1.0, base_similarity))  # 確保在 [0, 1] 範圍內
-    
-    def _calculate_exercise_similarity(self, exercise1: str, exercise2: str) -> float:
-        exercise_map = {'Low': 1, 'Moderate': 2, 'High': 3, 'Very High': 4}
-        value1 = exercise_map.get(exercise1, 2)  # 預設為 'Moderate'
-        value2 = exercise_map.get(exercise2, 2)  # 預設為 'Moderate'
+        return min(1.0, base_similarity)
     
-        # 計算相似度
-        exercise_similarity = 1.0 - abs(value1 - value2) / 3
-        return max(0.0, exercise_similarity)  # 確保相似度在 [0, 1] 範圍內
+    def _calculate_grooming_similarity(self, breed1: str, breed2: str) -> float:
+        """計算美容需求相似度"""
+        grooming_map = {
+            'Low': 1,
+            'Moderate': 2,
+            'High': 3
+        }
+        
+        # 從dog_data中獲取美容需求
+        breed1_info = next((dog for dog in self.dog_data if dog[1] == breed1), None)
+        breed2_info = next((dog for dog in self.dog_data if dog[1] == breed2), None)
+        
+        if not breed1_info or not breed2_info:
+            return 0.5  # 默認中等相似度
+            
+        grooming1 = breed1_info[8]  # Grooming_Needs index
+        grooming2 = breed2_info[8]
+        
+        value1 = grooming_map.get(grooming1, 2)
+        value2 = grooming_map.get(grooming2, 2)
+        
+        # 基礎相似度
+        base_similarity = 1.0 - abs(value1 - value2) / 2.0
+        
+        # 根據用戶需求調整
+        if grooming2 == 'Moderate':
+            base_similarity *= 1.1  # 稍微提高中等美容需求的分數
+        elif grooming2 == 'High':
+            base_similarity *= 0.9  # 稍微降低高美容需求的分數
+        
+        return min(1.0, base_similarity)
 
     def _calculate_health_score(self, breed_name: str) -> float:
         """計算品種的健康分數"""