Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -206,205 +206,6 @@ def calculate_additional_factors(breed_info: dict, user_prefs: 'UserPreferences'
     return factors
 
 
-@staticmethod
-def calculate_family_safety_score(breed_info: dict, children_age: str) -> float:
-    temperament = breed_info.get('Temperament', '').lower()
-    size = breed_info.get('Size', 'Medium')
-    
-    # 基礎安全分數必須根據孩童年齡有所不同
-    base_safety_scores = {
-        'toddler': {
-            "Small": 0.85,     # 幼童與小型犬相對安全
-            "Medium": 0.60,    # 中型犬需要更多注意
-            "Large": 0.40,     # 大型犬風險較高
-            "Giant": 0.30      # 巨型犬風險最高
-        },
-        'school_age': {
-            "Small": 0.90,     # 學齡兒童與小型犬很合適
-            "Medium": 0.75,    # 中型犬可以接受
-            "Large": 0.55,     # 大型犬需要注意
-            "Giant": 0.45      # 巨型犬仍需謹慎
-        },
-        'teenager': {
-            "Small": 0.95,     # 青少年幾乎能應付所有小型犬
-            "Medium": 0.85,    # 中型犬很合適
-            "Large": 0.70,     # 大型犬可以考慮
-            "Giant": 0.60      # 巨型犬仍需小心
-        }
-    }
-    
-    # 根據孩童年齡選擇對應的基礎分數
-    safety_score = base_safety_scores[children_age][size]
-    
-    # 年齡特定的危險特徵評估
-    age_specific_dangerous_traits = {
-        'toddler': {
-            'aggressive': -0.40,    # 幼童最危險
-            'territorial': -0.35,
-            'protective': -0.30,
-            'nervous': -0.30,
-            'dominant': -0.25,
-            'energetic': -0.20      # 過度活潑對幼童也是風險
-        },
-        'school_age': {
-            'aggressive': -0.30,
-            'territorial': -0.25,
-            'protective': -0.20,
-            'nervous': -0.20,
-            'dominant': -0.15,
-            'energetic': -0.10
-        },
-        'teenager': {
-            'aggressive': -0.20,
-            'territorial': -0.15,
-            'protective': -0.10,
-            'nervous': -0.15,
-            'dominant': -0.10,
-            'energetic': -0.05
-        }
-    }
-    
-    # 套用年齡特定的特徵評估
-    for trait, penalty in age_specific_dangerous_traits[children_age].items():
-        if trait in temperament:
-            safety_score += penalty
-    
-    # 正面特徵評估（根據年齡調整獎勵程度）
-    positive_traits_by_age = {
-        'toddler': {
-            'gentle': 0.15,
-            'patient': 0.15,
-            'calm': 0.12,
-            'tolerant': 0.12
-        },
-        'school_age': {
-            'gentle': 0.12,
-            'patient': 0.12,
-            'playful': 0.10,
-            'friendly': 0.10
-        },
-        'teenager': {
-            'friendly': 0.10,
-            'playful': 0.10,
-            'adaptable': 0.08,
-            'trainable': 0.08
-        }
-    }
-    
-    # 套用正面特徵評估
-    for trait, bonus in positive_traits_by_age[children_age].items():
-        if trait in temperament:
-            safety_score += bonus
-    
-    # 特殊風險評估（對所有年齡都很重要）
-    description = breed_info.get('Description', '').lower()
-    if 'history of' in description:
-        safety_score -= 0.25
-    if 'requires experienced' in description:
-        safety_score -= 0.15
-        
-    # 確保分數在合理範圍內
-    return max(0.2, min(0.95, safety_score))
-    
-# def calculate_family_safety_score(breed_info: dict, children_age: str) -> float:
-#     """
-#     計算品種與家庭/兒童的安全相容性分數，作為calculate_compatibility_score的一部分
-    
-#     參數:
-#     breed_info (dict): 品種資訊
-#     children_age (str): 兒童年齡組別 ('toddler', 'school_age', 'teenager')
-    
-#     返回:
-#     float: 0.2-0.95之間的安全分數
-#     """
-#     temperament = breed_info.get('Temperament', '').lower()
-#     size = breed_info.get('Size', 'Medium')
-    
-#     # 基礎安全分數（根據體型）
-#     base_safety_scores = {
-#         "Small": 0.80,     # 從 0.85 降至 0.80
-#         "Medium": 0.65,    # 從 0.75 降至 0.65
-#         "Large": 0.50,     # 從 0.65 降至 0.50
-#         "Giant": 0.40      # 從 0.55 降至 0.40
-#     }
-#     safety_score = base_safety_scores.get(size, 0.60)
-    
-#     # 加強年齡相關的調整力度
-#     age_factors = {
-#         'toddler': {
-#             'base_modifier': -0.25,  # 從 -0.15 降至 -0.25
-#             'size_penalty': {
-#                 "Small": -0.10,      # 從 -0.05 降至 -0.10
-#                 "Medium": -0.20,     # 從 -0.10 降至 -0.20
-#                 "Large": -0.30,      # 從 -0.20 降至 -0.30
-#                 "Giant": -0.35       # 從 -0.25 降至 -0.35
-#             }
-#         },
-#         'school_age': {
-#             'base_modifier': -0.15,  # 從 -0.08 降至 -0.15
-#             'size_penalty': {
-#                 "Small": -0.05,
-#                 "Medium": -0.10,
-#                 "Large": -0.20,
-#                 "Giant": -0.25
-#             }
-#         },
-#         'teenager': {
-#             'base_modifier': -0.08,  # 從 -0.05 降至 -0.08
-#             'size_penalty': {
-#                 "Small": -0.02,
-#                 "Medium": -0.05,
-#                 "Large": -0.10,
-#                 "Giant": -0.15
-#             }
-#         }
-#     }
-    
-#     # 加強對危險特徵的評估
-#     dangerous_traits = {
-#         'aggressive': -0.35,      # 從 -0.25 加重到 -0.35
-#         'territorial': -0.30,     # 從 -0.20 加重到 -0.30
-#         'protective': -0.25,      # 從 -0.15 加重到 -0.25
-#         'nervous': -0.25,         # 從 -0.15 加重到 -0.25
-#         'dominant': -0.20,        # 從 -0.15 加重到 -0.20
-#         'strong-willed': -0.18,   # 從 -0.12 加重到 -0.18
-#         'independent': -0.15,     # 從 -0.10 加重到 -0.15
-#         'energetic': -0.12       # 從 -0.08 加重到 -0.12
-#     }
-
-#     # 特殊風險評估加重
-#     if 'history of' in breed_info.get('Description', '').lower():
-#         safety_score -= 0.25      # 從 -0.15 加重到 -0.25
-#     if 'requires experienced' in breed_info.get('Description', '').lower():
-#         safety_score -= 0.20      # 從 -0.10 加重到 -0.20
-    
-#     # 計算特徵分數
-#     for trait, bonus in positive_traits.items():
-#         if trait in temperament:
-#             safety_score += bonus * 0.8  # 降低正面特徵的影響力
-            
-#     for trait, penalty in dangerous_traits.items():
-#         if trait in temperament:
-#             # 對幼童加重懲罰
-#             if children_age == 'toddler':
-#                 safety_score += penalty * 1.3
-#             # 對青少年略微減輕懲罰
-#             elif children_age == 'teenager':
-#                 safety_score += penalty * 0.8
-#             else:
-#                 safety_score += penalty
-    
-#     # 特殊風險評估
-#     description = breed_info.get('Description', '').lower()
-#     if 'history of' in description:
-#         safety_score -= 0.15
-#     if 'requires experienced' in description:
-#         safety_score -= 0.10
-    
-#     # 將分數限制在合理範圍內
-#     return max(0.2, min(0.95, safety_score))
-
-
 def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences) -> dict:
     """計算品種與使用者條件的相容性分數的優化版本"""
     try:
@@ -493,175 +294,111 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return base_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:
-            # 首先建立基礎分數矩陣，確保不同難度和經驗等級有明顯差異
+            """
+            計算使用者經驗與品種需求的匹配分數
+            
+            參數說明:
+            care_level: 品種的照顧難度 ("High", "Moderate", "Low")
+            user_experience: 使用者經驗等級 ("beginner", "intermediate", "advanced") 
+            temperament: 品種的性格特徵描述
+            
+            返回:
+            float: 0.2-1.0 之間的匹配分數
+            """
+            # 基礎分數矩陣 - 更大的分數差異來反映經驗重要性
             base_scores = {
                 "High": {
-                    "beginner": 0.2,        # 高難度品種對新手極具挑戰
-                    "intermediate": 0.5,     # 中級玩家有一定掌握能力
-                    "advanced": 0.7         # 專家也需要謹慎對待
+                    "beginner": 0.12,     # 降低起始分，反映高難度品種對新手的挑戰
+                    "intermediate": 0.65,  # 中級玩家可以應付，但仍有改善空間
+                    "advanced": 1.0       # 資深者能完全勝任
                 },
                 "Moderate": {
-                    "beginner": 0.4,
-                    "intermediate": 0.65,
-                    "advanced": 0.8
+                    "beginner": 0.35,    # 適中難度對新手來說仍具挑戰
+                    "intermediate": 0.82, # 中級玩家有很好的勝任能力
+                    "advanced": 1.0      # 資深者完全勝任
                 },
                 "Low": {
-                    "beginner": 0.6,
-                    "intermediate": 0.75,
-                    "advanced": 0.85
+                    "beginner": 0.72,    # 低難度品種適合新手
+                    "intermediate": 0.92, # 中級玩家幾乎完全勝���
+                    "advanced": 1.0      # 資深者完全勝任
                 }
             }
             
-            # 獲取基礎分數
-            base_score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
+            # 取得基礎分數
+            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
             
-            # 計算品種難度係數
-            difficulty_traits = {
-                'aggressive': 0.3,
-                'dominant': 0.25,
-                'stubborn': 0.25,
-                'independent': 0.2,
-                'protective': 0.2,
-                'strong-willed': 0.15
-            }
-            
-            difficulty_score = sum(value for trait, value in difficulty_traits.items() 
-                                 if trait in temperament_lower)
-            
-            # 根據經驗等級調整難度的影響
-            experience_modifiers = {
-                "beginner": 1.2,      # 新手受難度影響最大
-                "intermediate": 0.8,   # 中級玩家受中等影響
-                "advanced": 0.5       # 專家受較小影響但仍然存在
-            }
-            
-            # 應用經驗調整
-            difficulty_impact = difficulty_score * experience_modifiers[user_experience]
-            adjusted_score = base_score * (1 - difficulty_impact)
-            
-            # 特殊品種類型的額外調整
-            breed_type_penalties = {
-                'terrier': {'beginner': -0.15, 'intermediate': -0.08, 'advanced': -0.04},
-                'working': {'beginner': -0.2, 'intermediate': -0.1, 'advanced': -0.05},
-                'guard': {'beginner': -0.25, 'intermediate': -0.12, 'advanced': -0.06}
-            }
-            
-            for breed_type, penalties in breed_type_penalties.items():
-                if breed_type in temperament_lower:
-                    adjusted_score += penalties[user_experience]
-            
-            return max(0.2, min(0.95, adjusted_score))
+            # 確保最終分數在合理範圍內
+            final_score = max(0.2, min(1.0, score + temperament_adjustments))
+            return final_score
 
 
         def calculate_health_score(breed_name: str) -> float:
@@ -781,75 +518,6 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             
             return max(0.2, 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
-
         # 計算所有基礎分數
         scores = {
             'space': calculate_space_score(
@@ -875,56 +543,52 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'health': calculate_health_score(breed_info.get('Breed', '')),
             'noise': calculate_noise_score(breed_info.get('Breed', ''), user_prefs.noise_tolerance)
         }
-        
-        # 2. 計算品種加分
-        if user_prefs.has_children:
-            scores['family_safety'] = calculate_family_safety_score(breed_info, user_prefs.children_age)
-            weights = {
-                'space': 0.22,
-                'exercise': 0.15,
-                'grooming': 0.10,
-                'experience': 0.20,
-                'health': 0.10,
-                'noise': 0.08,
-                'family_safety': 0.15
-            }
-        else:
-            weights = {
-                'space': 0.28,
-                'exercise': 0.18,
-                'grooming': 0.12,
-                'experience': 0.22,
-                'health': 0.12,
-                'noise': 0.08
-            }
 
-        # 3. 計算加權分數
-        weighted_score = sum(score * weights[category] for category, score in scores.items())
 
-        # 4. 加入品種加分影響（限制在合理範圍內）
-        breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
-        final_score = weighted_score * (1 + breed_bonus * 0.2)
+        # 優化權重配置
+        weights = {
+            'space': 0.28,      
+            'exercise': 0.18,   
+            'grooming': 0.12,   
+            'experience': 0.22, 
+            'health': 0.12,     
+            'noise': 0.08      
+        }
 
-        # 5. 最終分數調整
-        def amplify_score(score):
-            adjusted = (score - 0.3) * 1.6
-            amplified = pow(adjusted, 2.5) / 4.0 + score
-            return max(0.45, min(0.95, amplified))
+        # 計算加權總分
+        weighted_score = sum(score * weights[category] for category, score in scores.items())
 
-        final_score = amplify_score(final_score)
+        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)
         
-        # 6. 整理回傳結果
+        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.5 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}
+        return scores
 
     except Exception as e:
-        print(f"Error in calculate_compatibility_score: {str(e)}")
-        return {k: 0.7 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}
+        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']}