Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -372,69 +372,117 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             print("Missing Size information")
             raise KeyError("Size information missing")
             
+
         # def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
-        #     """空間分數計算"""
-        #     # 基礎空間需求矩陣
+        #     # 重新設計基礎分數矩陣
         #     base_scores = {
-        #         "Small": {"apartment": 0.95, "house_small": 1.0, "house_large": 0.90},
-        #         "Medium": {"apartment": 0.60, "house_small": 0.90, "house_large": 1.0},
-        #         "Large": {"apartment": 0.30, "house_small": 0.75, "house_large": 1.0},
-        #         "Giant": {"apartment": 0.15, "house_small": 0.55, "house_large": 1.0}
+        #         "Small": {
+        #             "apartment": 1.0,      # 小型犬最適合公寓
+        #             "house_small": 0.95,   # 在大房子反而稍微降分
+        #             "house_large": 0.85    # 可能浪費空間
+        #         },
+        #         "Medium": {
+        #             "apartment": 0.45,     # 中型犬在公寓明顯受限
+        #             "house_small": 0.85,
+        #             "house_large": 1.0
+        #         },
+        #         "Large": {
+        #             "apartment": 0.15,     # 大型犬在公寓極不適合
+        #             "house_small": 0.60,   # 在小房子仍然受限
+        #             "house_large": 1.0
+        #         },
+        #         "Giant": {
+        #             "apartment": 0.1,      # 更嚴格的限制
+        #             "house_small": 0.45,
+        #             "house_large": 1.0
+        #         }
         #     }
             
         #     # 取得基礎分數
         #     base_score = base_scores.get(size, base_scores["Medium"])[living_space]
             
-        #     # 運動需求調整
+        #     # 運動需求調整更明顯
         #     exercise_adjustments = {
-        #         "Very High": -0.15 if living_space == "apartment" else 0,
-        #         "High": -0.10 if living_space == "apartment" else 0,
-        #         "Moderate": 0,
-        #         "Low": 0.05 if living_space == "apartment" else 0
+        #         "Very High": {
+        #             "apartment": -0.25,    # 在公寓更嚴重的懲罰
+        #             "house_small": -0.15,
+        #             "house_large": -0.05
+        #         },
+        #         "High": {
+        #             "apartment": -0.20,
+        #             "house_small": -0.10,
+        #             "house_large": 0
+        #         },
+        #         "Moderate": {
+        #             "apartment": -0.10,
+        #             "house_small": -0.05,
+        #             "house_large": 0
+        #         },
+        #         "Low": {
+        #             "apartment": 0.05,
+        #             "house_small": 0,
+        #             "house_large": 0
+        #         }
         #     }
             
-        #     adjustments = exercise_adjustments.get(exercise_needs.strip(), 0)
+        #     # 根據空間類型獲取對應的運動調整
+        #     adjustment = exercise_adjustments.get(exercise_needs, 
+        #                                         exercise_adjustments["Moderate"])[living_space]
             
-        #     # 院子獎勵
-        #     if has_yard and size in ["Large", "Giant"]:
-        #         adjustments += 0.10
-        #     elif has_yard:
-        #         adjustments += 0.05
-                
-        #     return min(1.0, max(0.1, base_score + adjustments))
+        #     # 院子獎勵也要根據犬種大小調整
+        #     yard_bonus = 0
+        #     if has_yard:
+        #         if size in ["Large", "Giant"]:
+        #             yard_bonus = 0.20 if living_space != "apartment" else 0.10
+        #         elif size == "Medium":
+        #             yard_bonus = 0.15 if living_space != "apartment" else 0.08
+        #         else:
+        #             yard_bonus = 0.10 if living_space != "apartment" else 0.05
+                    
+        #     final_score = base_score + adjustment + yard_bonus
+        #     return min(1.0, max(0.1, final_score))
+
 
         def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
-            # 重新設計基礎分數矩陣
+            """
+            優化的空間分數計算函數
+            
+            主要改進：
+            1. 更均衡的基礎分數分配
+            2. 更細緻的空間需求評估
+            3. 強化運動需求與空間的關聯性
+            """
+            # 重新設計基礎分數矩陣，降低普遍分數以增加區別度
             base_scores = {
                 "Small": {
-                    "apartment": 1.0,      # 小型犬最適合公寓
-                    "house_small": 0.95,   # 在大房子反而稍微降分
-                    "house_large": 0.85    # 可能浪費空間
+                    "apartment": 0.85,    # 降低滿分機會
+                    "house_small": 0.80,  # 小型犬不應在大空間得到太高分數
+                    "house_large": 0.75   # 避免小型犬總是得到最高分
                 },
                 "Medium": {
-                    "apartment": 0.45,     # 中型犬在公寓明顯受限
-                    "house_small": 0.85,
-                    "house_large": 1.0
+                    "apartment": 0.45,    # 維持對公寓環境的限制
+                    "house_small": 0.75,  # 適中的分數
+                    "house_large": 0.85   # 給予合理的獎勵
                 },
                 "Large": {
-                    "apartment": 0.15,     # 大型犬在公寓極不適合
-                    "house_small": 0.60,   # 在小房子仍然受限
-                    "house_large": 1.0
+                    "apartment": 0.15,    # 加重對大型犬在公寓的限制
+                    "house_small": 0.65,  # 中等適合度
+                    "house_large": 0.90   # 最適合的環境
                 },
                 "Giant": {
-                    "apartment": 0.1,      # 更嚴格的限制
-                    "house_small": 0.45,
-                    "house_large": 1.0
+                    "apartment": 0.10,    # 更嚴格的限制
+                    "house_small": 0.45,  # 顯著的空間限制
+                    "house_large": 0.95   # 最理想的配對
                 }
             }
             
             # 取得基礎分數
             base_score = base_scores.get(size, base_scores["Medium"])[living_space]
             
-            # 運動需求調整更明顯
+            # 運動需求相關的調整更加動態
             exercise_adjustments = {
                 "Very High": {
-                    "apartment": -0.25,    # 在公寓更嚴重的懲罰
+                    "apartment": -0.25,    # 加重在受限空間的懲罰
                     "house_small": -0.15,
                     "house_large": -0.05
                 },
@@ -449,74 +497,133 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     "house_large": 0
                 },
                 "Low": {
-                    "apartment": 0.05,
+                    "apartment": 0.05,     # 低運動需求在小空間反而有優勢
                     "house_small": 0,
-                    "house_large": 0
+                    "house_large": -0.05   # 輕微降低評分，因為空間可能過大
                 }
             }
             
-            # 根據空間類型獲取對應的運動調整
+            # 根據空間類型獲取運動需求調整
             adjustment = exercise_adjustments.get(exercise_needs, 
                                                 exercise_adjustments["Moderate"])[living_space]
             
-            # 院子獎勵也要根據犬種大小調整
-            yard_bonus = 0
+            # 院子效益根據品種大小和運動需求動態調整
             if has_yard:
-                if size in ["Large", "Giant"]:
-                    yard_bonus = 0.20 if living_space != "apartment" else 0.10
-                elif size == "Medium":
-                    yard_bonus = 0.15 if living_space != "apartment" else 0.08
-                else:
-                    yard_bonus = 0.10 if living_space != "apartment" else 0.05
+                yard_bonus = {
+                    "Giant": 0.20,
+                    "Large": 0.15,
+                    "Medium": 0.10,
+                    "Small": 0.05
+                }.get(size, 0.10)
+                
+                # 運動需求會影響院子的重要性
+                if exercise_needs in ["Very High", "High"]:
+                    yard_bonus *= 1.2
+                elif exercise_needs == "Low":
+                    yard_bonus *= 0.8
                     
-            final_score = base_score + adjustment + yard_bonus
-            return min(1.0, max(0.1, final_score))
+                current_score = base_score + adjustment + yard_bonus
+            else:
+                current_score = base_score + adjustment
+                
+            # 確保分數在合理範圍內，但避免極端值
+            return min(0.95, max(0.15, current_score))
+            
 
-        def calculate_exercise_score(breed_needs: str, user_time: int) -> float:
-            """運動需求計算"""
+        # def calculate_exercise_score(breed_needs: str, user_time: int) -> float:
+        #     """運動需求計算"""
+        #     exercise_needs = {
+        #         'VERY HIGH': {'min': 120, 'ideal': 150, 'max': 180},
+        #         'HIGH': {'min': 90, 'ideal': 120, 'max': 150},
+        #         'MODERATE': {'min': 45, 'ideal': 60, 'max': 90},
+        #         'LOW': {'min': 20, 'ideal': 30, 'max': 45},
+        #         'VARIES': {'min': 30, 'ideal': 60, 'max': 90}
+        #     }
+            
+        #     breed_need = exercise_needs.get(breed_needs.strip().upper(), exercise_needs['MODERATE'])
+            
+        #     # 計算匹配度
+        #     if user_time >= breed_need['ideal']:
+        #         if user_time > breed_need['max']:
+        #             return 0.9  # 稍微降分，因為可能過度運動
+        #         return 1.0
+        #     elif user_time >= breed_need['min']:
+        #         return 0.8 + (user_time - breed_need['min']) / (breed_need['ideal'] - breed_need['min']) * 0.2
+        #     else:
+        #         return max(0.3, 0.8 * (user_time / breed_need['min']))
+
+
+        def calculate_exercise_score(breed_needs: str, user_prefs: UserPreferences) -> float:
+            """
+            優化的運動需求評分系統
+            
+            改進：
+            1. 考慮運動類型的匹配度
+            2. 評估活動模式的適配性
+            3. 加入品種特性考量
+            """
+            # 基礎運動需求評估
             exercise_needs = {
-                'VERY HIGH': {'min': 120, 'ideal': 150, 'max': 180},
-                'HIGH': {'min': 90, 'ideal': 120, 'max': 150},
-                'MODERATE': {'min': 45, 'ideal': 60, 'max': 90},
-                'LOW': {'min': 20, 'ideal': 30, 'max': 45},
-                'VARIES': {'min': 30, 'ideal': 60, 'max': 90}
+                'VERY HIGH': {'min': 120, 'ideal': 150, 'max': 180, 'intensity': 'high'},
+                'HIGH': {'min': 90, 'ideal': 120, 'max': 150, 'intensity': 'moderate_high'},
+                'MODERATE': {'min': 45, 'ideal': 60, 'max': 90, 'intensity': 'moderate'},
+                'LOW': {'min': 20, 'ideal': 30, 'max': 45, 'intensity': 'low'},
+                'VARIES': {'min': 30, 'ideal': 60, 'max': 90, 'intensity': 'moderate'}
             }
             
             breed_need = exercise_needs.get(breed_needs.strip().upper(), exercise_needs['MODERATE'])
             
-            # 計算匹配度
-            if user_time >= breed_need['ideal']:
-                if user_time > breed_need['max']:
-                    return 0.9  # 稍微降分，因為可能過度運動
-                return 1.0
-            elif user_time >= breed_need['min']:
-                return 0.8 + (user_time - breed_need['min']) / (breed_need['ideal'] - breed_need['min']) * 0.2
+            # 基礎時間匹配度計算
+            if user_prefs.exercise_time >= breed_need['ideal']:
+                time_score = 1.0 if user_prefs.exercise_time <= breed_need['max'] else 0.9
+            elif user_prefs.exercise_time >= breed_need['min']:
+                time_score = 0.7 + (user_prefs.exercise_time - breed_need['min']) / (breed_need['ideal'] - breed_need['min']) * 0.3
             else:
-                return max(0.3, 0.8 * (user_time / breed_need['min']))
-
-        # def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
-        #     """美容需求計算"""
-        #     # 基礎分數矩陣
-        #     base_scores = {
-        #         "High": {"low": 0.3, "medium": 0.7, "high": 1.0},
-        #         "Moderate": {"low": 0.5, "medium": 0.9, "high": 1.0},
-        #         "Low": {"low": 1.0, "medium": 0.95, "high": 0.8}
-        #     }
+                time_score = max(0.3, 0.7 * (user_prefs.exercise_time / breed_need['min']))
+        
+            # 運動類型匹配度評估
+            exercise_type_scores = {
+                'light_walks': {
+                    'low': 1.0,
+                    'moderate': 0.8,
+                    'moderate_high': 0.5,
+                    'high': 0.3
+                },
+                'moderate_activity': {
+                    'low': 0.7,
+                    'moderate': 1.0,
+                    'moderate_high': 0.8,
+                    'high': 0.6
+                },
+                'active_training': {
+                    'low': 0.5,
+                    'moderate': 0.8,
+                    'moderate_high': 1.0,
+                    'high': 1.0
+                }
+            }
             
-        #     # 取得基礎分數
-        #     base_score = base_scores.get(breed_needs, base_scores["Moderate"])[user_commitment]
+            type_score = exercise_type_scores.get(user_prefs.exercise_type, exercise_type_scores['moderate_activity']).get(breed_need['intensity'], 0.7)
             
-        #     # 體型影響調整
-        #     size_adjustments = {
-        #         "Large": {"low": -0.2, "medium": -0.1, "high": 0},
-        #         "Giant": {"low": -0.3, "medium": -0.15, "high": 0},
-        #     }
+            # 時間可用性調整
+            availability_multiplier = {
+                'limited': 0.85,    # 時間有限，可能影響運動品質
+                'moderate': 1.0,    # 標準參考點
+                'flexible': 1.1     # 更靈活的時間安排有利於滿足狗狗需求
+            }.get(user_prefs.time_availability, 1.0)
             
-        #     if breed_size in size_adjustments:
-        #         adjustment = size_adjustments[breed_size].get(user_commitment, 0)
-        #         base_score = max(0.2, base_score + adjustment)
-                
-        #     return base_score
+            # 環境因素考量
+            environment_bonus = 0
+            if user_prefs.yard_access != 'no_yard':
+                if breed_needs.strip().upper() in ['VERY HIGH', 'HIGH']:
+                    environment_bonus = 0.1
+                else:
+                    environment_bonus = 0.05
+                    
+            # 計算最終分數
+            final_score = (time_score * 0.5 + type_score * 0.3) * availability_multiplier + environment_bonus
+            
+            return min(1.0, max(0.3, final_score))
 
 
         def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
@@ -648,113 +755,6 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
         
             # 確保分數在有意義的範圍內，但允許更大的差異
             return max(0.1, min(1.0, final_score))
-            
-
-        # def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
-        #     """
-        #     計算使用者經驗與品種需求的匹配分數
-            
-        #     參數說明:
-        #     care_level: 品種的照顧難度 ("High", "Moderate", "Low")
-        #     user_experience: 使用者經驗等級 ("beginner", "intermediate", "advanced") 
-        #     temperament: 品種的性格特徵描述
-            
-        #     返回:
-        #     float: 0.2-1.0 之間的匹配分數
-        #     """
-        #     # 基礎分數矩陣 - 更大的分數差異來反映經驗重要性
-        #     base_scores = {
-        #         "High": {
-        #             "beginner": 0.12,     # 降低起始分，反映高難度品種對新手的挑戰
-        #             "intermediate": 0.65,  # 中級玩家可以應付，但仍有改善空間
-        #             "advanced": 1.0       # 資深者能完全勝任
-        #         },
-        #         "Moderate": {
-        #             "beginner": 0.35,    # 適中難度對新手來說仍具挑戰
-        #             "intermediate": 0.82, # 中級玩家有很好的勝任能力
-        #             "advanced": 1.0      # 資深者完全勝任
-        #         },
-        #         "Low": {
-        #             "beginner": 0.72,    # 低難度品種適合新手
-        #             "intermediate": 0.92, # 中級玩家幾乎完全勝任
-        #             "advanced": 1.0      # 資深者完全勝任
-        #         }
-        #     }
-            
-        #     # 取得基礎分數
-        #     score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
-            
-        #     # 性格特徵評估 - 根據經驗等級調整權重
-        #     temperament_lower = temperament.lower()
-        #     temperament_adjustments = 0.0
-            
-        #     if user_experience == "beginner":
-        #         # 新手不適合的特徵 - 更嚴格的懲罰
-        #         difficult_traits = {
-        #             'stubborn': -0.15,      # 加重固執的懲罰
-        #             'independent': -0.12,    # 加重獨立性的懲罰
-        #             'dominant': -0.12,       # 加重支配性的懲罰
-        #             'strong-willed': -0.10,  # 加重強勢的懲罰
-        #             'protective': -0.08,     # 加重保護性的懲罰
-        #             'aloof': -0.08,         # 加重冷漠的懲罰
-        #             'energetic': -0.06      # 輕微懲罰高能量
-        #         }
-                
-        #         # 新手友善的特徵 - 提供更多獎勵
-        #         easy_traits = {
-        #             'gentle': 0.08,          # 增加溫和的獎勵
-        #             'friendly': 0.08,        # 增加友善的獎勵
-        #             'eager to please': 0.08, # 增加順從的獎勵
-        #             'patient': 0.06,         # 獎勵耐心
-        #             'adaptable': 0.06,       # 獎勵適應性
-        #             'calm': 0.05            # 獎勵冷靜
-        #         }
-                
-        #         # 計算特徵調整
-        #         for trait, penalty in difficult_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += penalty * 1.2  # 加重新手的懲罰
-                
-        #         for trait, bonus in easy_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += bonus
-                        
-        #         # 品種特殊調整
-        #         if any(term in temperament_lower for term in ['terrier', 'working', 'guard']):
-        #             temperament_adjustments -= 0.12  # 加重對特定類型品種的懲罰
-                    
-        #     elif user_experience == "intermediate":
-        #         # 中級玩家的調整更加平衡
-        #         moderate_traits = {
-        #             'intelligent': 0.05,     # 獎勵聰明
-        #             'athletic': 0.04,        # 獎勵運動能力
-        #             'versatile': 0.04,       # 獎勵多功能性
-        #             'stubborn': -0.06,       # 輕微懲罰固執
-        #             'independent': -0.05,    # 輕微懲罰獨立性
-        #             'protective': -0.04      # 輕微懲罰保護性
-        #         }
-                
-        #         for trait, adjustment in moderate_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += adjustment
-                        
-        #     else:  # advanced
-        #         # 資深玩家能夠應對挑戰性特徵
-        #         advanced_traits = {
-        #             'stubborn': 0.04,        # 反轉為優勢
-        #             'independent': 0.04,      # 反轉為優勢
-        #             'intelligent': 0.05,      # 獎勵聰明
-        #             'protective': 0.04,       # 獎勵保護性
-        #             'strong-willed': 0.03    # 獎勵強勢
-        #         }
-                
-        #         for trait, bonus in advanced_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += bonus
-            
-        #     # 確保最終分數在合理範圍內
-        #     final_score = max(0.2, min(1.0, score + temperament_adjustments))
-        #     return final_score
 
 
         def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
@@ -866,72 +866,6 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             
             return final_score
 
-
-        # def calculate_health_score(breed_name: str) -> float:
-        #     """計算品種健康分數"""
-        #     if breed_name not in breed_health_info:
-        #         return 0.5
-
-        #     health_notes = breed_health_info[breed_name]['health_notes'].lower()
-            
-        #     # 嚴重健康問題（降低0.15分）
-        #     severe_conditions = [
-        #         'hip dysplasia',
-        #         'heart disease',
-        #         'progressive retinal atrophy',
-        #         'bloat',
-        #         'epilepsy',
-        #         'degenerative myelopathy',
-        #         'von willebrand disease'
-        #     ]
-            
-        #     # 中度健康問題（降低0.1分）
-        #     moderate_conditions = [
-        #         'allergies',
-        #         'eye problems',
-        #         'joint problems',
-        #         'hypothyroidism',
-        #         'ear infections',
-        #         'skin issues'
-        #     ]
-            
-        #     # 輕微健康問題（降低0.05分）
-        #     minor_conditions = [
-        #         'dental issues',
-        #         'weight gain tendency',
-        #         'minor allergies',
-        #         'seasonal allergies'
-        #     ]
-
-        #     # 計算基礎健康分數
-        #     health_score = 1.0
-            
-        #     # 根據問題嚴重程度扣分
-        #     severe_count = sum(1 for condition in severe_conditions if condition in health_notes)
-        #     moderate_count = sum(1 for condition in moderate_conditions if condition in health_notes)
-        #     minor_count = sum(1 for condition in minor_conditions if condition in health_notes)
-            
-        #     health_score -= (severe_count * 0.15)
-        #     health_score -= (moderate_count * 0.1)
-        #     health_score -= (minor_count * 0.05)
-
-        #     # 壽命影響
-        #     try:
-        #         lifespan = breed_health_info[breed_name].get('average_lifespan', '10-12')
-        #         years = float(lifespan.split('-')[0])
-        #         if years < 8:
-        #             health_score *= 0.9
-        #         elif years > 13:
-        #             health_score *= 1.1
-        #     except:
-        #         pass
-
-        #     # 特殊健康優勢
-        #     if 'generally healthy' in health_notes or 'hardy breed' in health_notes:
-        #         health_score *= 1.1
-
-        #     return max(0.2, min(1.0, health_score))
-
         def calculate_health_score(breed_name: str, user_prefs: UserPreferences) -> float:
             """
             計算品種健康分數，加強健康問題的影響力和與使用者敏感度的連結
@@ -1040,58 +974,6 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return max(0.1, min(1.0, health_score))
             
 
-        # def calculate_noise_score(breed_name: str, user_noise_tolerance: str) -> float:
-        #     """計算品種噪音分數"""
-        #     if breed_name not in breed_noise_info:
-        #         return 0.5
-
-        #     noise_info = breed_noise_info[breed_name]
-        #     noise_level = noise_info['noise_level'].lower()
-        #     noise_notes = noise_info['noise_notes'].lower()
-
-        #     # 基礎噪音分數矩陣
-        #     base_scores = {
-        #         'low': {'low': 1.0, 'medium': 0.9, 'high': 0.8},
-        #         'medium': {'low': 0.7, 'medium': 1.0, 'high': 0.9},
-        #         'high': {'low': 0.4, 'medium': 0.7, 'high': 1.0},
-        #         'varies': {'low': 0.6, 'medium': 0.8, 'high': 0.9}
-        #     }
-
-        #     # 獲取基礎分數
-        #     base_score = base_scores.get(noise_level, {'low': 0.7, 'medium': 0.8, 'high': 0.6})[user_noise_tolerance]
-
-        #     # 吠叫原因評估
-        #     barking_reasons_penalty = 0
-        #     problematic_triggers = [
-        #         ('separation anxiety', -0.15),
-        #         ('excessive barking', -0.12),
-        #         ('territorial', -0.08),
-        #         ('alert barking', -0.05),
-        #         ('attention seeking', -0.05)
-        #     ]
-
-        #     for trigger, penalty in problematic_triggers:
-        #         if trigger in noise_notes:
-        #             barking_reasons_penalty += penalty
-
-        #     # 可訓練性補償
-        #     trainability_bonus = 0
-        #     if 'responds well to training' in noise_notes:
-        #         trainability_bonus = 0.1
-        #     elif 'can be trained' in noise_notes:
-        #         trainability_bonus = 0.05
-
-        #     # 特殊情況
-        #     special_adjustments = 0
-        #     if 'rarely barks' in noise_notes:
-        #         special_adjustments += 0.1
-        #     if 'howls' in noise_notes and user_noise_tolerance == 'low':
-        #         special_adjustments -= 0.1
-
-        #     final_score = base_score + barking_reasons_penalty + trainability_bonus + special_adjustments
-            
-        #     return max(0.2, min(1.0, final_score))
-
         def calculate_noise_score(breed_name: str, user_prefs: UserPreferences) -> float:
             """
             計算品種噪音分數，特別加強噪音程度與生活環境的關聯性評估
@@ -1215,83 +1097,6 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             final_score = base_score + barking_penalty + special_adjustments + trainability_bonus
             return max(0.1, min(1.0, final_score))
             
-
-        # # 計算所有基礎分數
-        # scores = {
-        #     'space': calculate_space_score(
-        #         breed_info['Size'], 
-        #         user_prefs.living_space,
-        #         user_prefs.space_for_play,
-        #         breed_info.get('Exercise Needs', 'Moderate')
-        #     ),
-        #     'exercise': calculate_exercise_score(
-        #         breed_info.get('Exercise Needs', 'Moderate'),
-        #         user_prefs.exercise_time
-        #     ),
-        #     'grooming': calculate_grooming_score(
-        #         breed_info.get('Grooming Needs', 'Moderate'),
-        #         user_prefs.grooming_commitment.lower(),
-        #         breed_info['Size']
-        #     ),
-        #     'experience': calculate_experience_score(
-        #         breed_info.get('Care Level', 'Moderate'),
-        #         user_prefs.experience_level,
-        #         breed_info.get('Temperament', '')
-        #     ),
-        #     'health': calculate_health_score(breed_info.get('Breed', '')),
-        #     'noise': calculate_noise_score(breed_info.get('Breed', ''), user_prefs.noise_tolerance)
-        # }
-
-
-    #     # 優化權重配置
-    #     weights = {
-    #         'space': 0.28,      
-    #         'exercise': 0.18,   
-    #         'grooming': 0.12,   
-    #         'experience': 0.22, 
-    #         'health': 0.12,     
-    #         'noise': 0.08      
-    #     }
-
-    #     # 計算加權總分
-    #     weighted_score = sum(score * weights[category] for category, score in scores.items())
-
-    #     def amplify_score(score):
-    #         """
-    #         優化分數放大函數，確保分數範圍合理且結果一致
-    #         """
-    #         # 基礎調整
-    #         adjusted = (score - 0.35) * 1.8
-            
-    #         # 使用 3.2 次方使曲線更平滑
-    #         amplified = pow(adjusted, 3.2) / 5.8 + score
-            
-    #         # 特別處理高分區間，確保不超過95%
-    #         if amplified > 0.90:
-    #             # 壓縮高分區間，確保最高到95%
-    #             amplified = 0.90 + (amplified - 0.90) * 0.5
-            
-    #         # 確保最終分數在合理範圍內（0.55-0.95）
-    #         final_score = max(0.55, min(0.95, amplified))
-            
-    #         # 四捨五入到小數點後第三位
-    #         return round(final_score, 3)
-        
-    #     final_score = amplify_score(weighted_score)
-
-    #     # 四捨五入所有分數
-    #     scores = {k: round(v, 4) for k, v in scores.items()}
-    #     scores['overall'] = round(final_score, 4)
-
-    #     return scores
-
-    # except Exception as e:
-    #     print(f"Error details: {str(e)}")
-    #     print(f"breed_info: {breed_info}")
-    #     # print(f"Error in calculate_compatibility_score: {str(e)}")
-    #     return {k: 0.6 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}
-
-        #
         print("\n=== 開始計算品種相容性分數 ===")
         print(f"處理品種: {breed_info.get('Breed', 'Unknown')}")
         print(f"品種信息: {breed_info}")
@@ -1396,35 +1201,128 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                 
             return penalty
 
-        # 計算權重和加權分數
-        def calculate_weighted_score(scores: dict) -> float:
+        # # 計算權重和加權分數
+        # def calculate_weighted_score(scores: dict) -> float:
+        #     """
+        #     使用動態權重計算加權分數
+        #     """
+        #     base_weights = {
+        #         'space': 0.28,      
+        #         'exercise': 0.18,   
+        #         'grooming': 0.12,   
+        #         'experience': 0.22, 
+        #         'health': 0.12,     
+        #         'noise': 0.08      
+        #     }
+            
+        #     # 根據居住環境調整權重
+        #     if user_prefs.living_space == 'apartment':
+        #         base_weights['space'] *= 1.2
+        #         base_weights['noise'] *= 1.2
+            
+        #     # 根據經驗等級調整權重
+        #     if user_prefs.experience_level == 'beginner':
+        #         base_weights['experience'] *= 1.3
+            
+        #     # 重新正規化權重
+        #     total_weight = sum(base_weights.values())
+        #     weights = {k: v/total_weight for k, v in base_weights.items()}
+            
+        #     # 計算加權分數
+        #     return sum(score * weights[category] for category, score in scores.items())
+
+        def calculate_weighted_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
             """
-            使用動態權重計算加權分數
+            優化的加權分數計算函數
+            
+            主要改進：
+            1. 動態權重調整
+            2. 品種特性加成
+            3. 更平衡的分數分配
             """
+            # 基礎權重設定
             base_weights = {
-                'space': 0.28,      
-                'exercise': 0.18,   
-                'grooming': 0.12,   
-                'experience': 0.22, 
+                'space': 0.25,      # 稍微降低空間權重
+                'exercise': 0.20,   # 提高運動權重
+                'grooming': 0.15,   # 略微提高美容權重
+                'experience': 0.18, # 降低經驗權重，避免過度主導
                 'health': 0.12,     
-                'noise': 0.08      
+                'noise': 0.10      # 提高噪音權重
             }
             
+            # 根據使用者經驗調整權重
+            if user_prefs.experience_level == 'beginner':
+                # 新手更注重易照顧程度
+                base_weights['experience'] *= 1.2
+                base_weights['health'] *= 1.1
+                base_weights['grooming'] *= 0.9
+            elif user_prefs.experience_level == 'advanced':
+                # 專家更注重運動和訓練潛力
+                base_weights['exercise'] *= 1.2
+                base_weights['experience'] *= 0.8
+                
             # 根據居住環境調整權重
             if user_prefs.living_space == 'apartment':
+                base_weights['noise'] *= 1.3
                 base_weights['space'] *= 1.2
+            elif user_prefs.living_space == 'house_large':
+                base_weights['exercise'] *= 1.2
+                base_weights['space'] *= 0.9
+        
+            # 有孩童時的權重調整
+            if user_prefs.has_children:
                 base_weights['noise'] *= 1.2
-            
-            # 根據經驗等級調整權重
-            if user_prefs.experience_level == 'beginner':
-                base_weights['experience'] *= 1.3
-            
+                base_weights['health'] *= 1.1
+                
             # 重新正規化權重
             total_weight = sum(base_weights.values())
             weights = {k: v/total_weight for k, v in base_weights.items()}
             
-            # 計算加權分數
-            return sum(score * weights[category] for category, score in scores.items())
+            # 計算基礎加權分數
+            weighted_base = sum(score * weights[category] for category, score in scores.items())
+            
+            # 計算品種特性加成
+            breed_bonus = calculate_breed_characteristic_bonus(breed_info, user_prefs)
+            
+            # 混合基礎分數和特性加成
+            final_score = (weighted_base * 0.85) + (breed_bonus * 0.15)
+            
+            return final_score
+        
+        def calculate_breed_characteristic_bonus(breed_info: dict, user_prefs: UserPreferences) -> float:
+            """
+            計算品種特性加成，增加品種多樣性
+            """
+            bonus = 0.0
+            temperament = breed_info.get('Temperament', '').lower()
+            description = breed_info.get('Description', '').lower()
+            
+            # 品種類型加成
+            breed_types = {
+                'working': {'keywords': ['working', 'guard', 'protection'], 'bonus': 0.05},
+                'companion': {'keywords': ['companion', 'friendly', 'affectionate'], 'bonus': 0.05},
+                'sporting': {'keywords': ['hunting', 'sporting', 'athletic'], 'bonus': 0.05},
+                'herding': {'keywords': ['herding', 'shepherd', 'cattle'], 'bonus': 0.05}
+            }
+            
+            # 根據使用場景給予特定加成
+            for breed_type, info in breed_types.items():
+                if any(keyword in description or keyword in temperament for keyword in info['keywords']):
+                    if user_prefs.has_children and breed_type == 'companion':
+                        bonus += info['bonus'] * 1.5
+                    elif user_prefs.exercise_type == 'active_training' and breed_type in ['working', 'sporting']:
+                        bonus += info['bonus'] * 1.3
+                    else:
+                        bonus += info['bonus']
+                        
+            # 特殊加成（增加多樣性）
+            if 'rare' in description or 'unique' in description:
+                bonus += 0.03
+            if 'independent' in temperament and user_prefs.experience_level == 'advanced':
+                bonus += 0.04
+                
+            return min(0.15, bonus)  # 限制最大加成
+            
 
         # 計算最終分數
         def calculate_final_score(base_score: float, penalty: float) -> float: