Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -409,7 +409,7 @@ def calculate_additional_factors(breed_info: dict, user_prefs: 'UserPreferences'
 
 
 def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences) -> dict:
-    """計算品種與使用者條件的相容性分數的優化版本"""
+    """計算品種與使用者條件的相容性分數"""
     try:
         print(f"Processing breed: {breed_info.get('Breed', 'Unknown')}")
         print(f"Breed info keys: {breed_info.keys()}")
@@ -417,192 +417,10 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
         if 'Size' not in breed_info:
             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:
-        #     """       
-        #     主要改進：
-        #     1. 更均衡的基礎分數分配
-        #     2. 更細緻的空間需求評估
-        #     3. 強化運動需求與空間的關聯性
-        #     """
-        #     # 重新設計基礎分數矩陣，降低普遍分數以增加區別度
-        #     base_scores = {
-        #         "Small": {
-        #             "apartment": 0.90,    # 降低滿分機會
-        #             "house_small": 0.85,  # 小型犬不應在大空間得到太高分數
-        #             "house_large": 0.80   # 避免小型犬總是得到最高分
-        #         },
-        #         "Medium": {
-        #             "apartment": 0.40,    # 維持對公寓環境的限制
-        #             "house_small": 0.80,  # 適中的分數
-        #             "house_large": 0.90   # 給予合理的獎勵
-        #         },
-        #         "Large": {
-        #             "apartment": 0.10,    # 加重對大型犬在公寓的限制
-        #             "house_small": 0.60,  # 中等適合度
-        #             "house_large": 0.95   # 最適合的環境
-        #         },
-        #         "Giant": {
-        #             "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,    # 加重在受限空間的懲罰
-        #             "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.05   # 輕微降低評分，因為空間可能過大
-        #         }
-        #     }
-            
-        #     # 根據空間類型獲取運動需求調整
-        #     adjustment = exercise_adjustments.get(exercise_needs, 
-        #                                         exercise_adjustments["Moderate"])[living_space]
-            
-        #     # 院子效益根據品種大小和運動需求動態調整
-        #     if has_yard:
-        #         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
-                    
-        #         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, exercise_time: int, exercise_type: str) -> float:
-        #     """
-        #     精確評估品種運動需求與使用者運動條件的匹配度
-            
-        #     Parameters:
-        #     breed_needs: 品種的運動需求等級
-        #     exercise_time: 使用者能提供的運動時間（分鐘）
-        #     exercise_type: 使用者偏好的運動類型
-            
-        #     Returns:
-        #     float: -0.2 到 0.2 之間的��配分數
-        #     """
-        #     # 定義更細緻的運動需求等級
-        #     exercise_levels = {
-        #         'VERY HIGH': {
-        #             'min': 120,
-        #             'ideal': 150,
-        #             'max': 180,
-        #             'intensity': 'high',
-        #             'sessions': 'multiple',
-        #             'preferred_types': ['active_training', 'intensive_exercise']
-        #         },
-        #         'HIGH': {
-        #             'min': 90,
-        #             'ideal': 120,
-        #             'max': 150,
-        #             'intensity': 'moderate_high',
-        #             'sessions': 'multiple',
-        #             'preferred_types': ['active_training', 'moderate_activity']
-        #         },
-        #         'MODERATE HIGH': {
-        #             'min': 70,
-        #             'ideal': 90,
-        #             'max': 120,
-        #             'intensity': 'moderate',
-        #             'sessions': 'flexible',
-        #             'preferred_types': ['moderate_activity', 'active_training']
-        #         },
-        #         'MODERATE': {
-        #             'min': 45,
-        #             'ideal': 60,
-        #             'max': 90,
-        #             'intensity': 'moderate',
-        #             'sessions': 'flexible',
-        #             'preferred_types': ['moderate_activity', 'light_walks']
-        #         },
-        #         'MODERATE LOW': {
-        #             'min': 30,
-        #             'ideal': 45,
-        #             'max': 70,
-        #             'intensity': 'light_moderate',
-        #             'sessions': 'flexible',
-        #             'preferred_types': ['light_walks', 'moderate_activity']
-        #         },
-        #         'LOW': {
-        #             'min': 15,
-        #             'ideal': 30,
-        #             'max': 45,
-        #             'intensity': 'light',
-        #             'sessions': 'single',
-        #             'preferred_types': ['light_walks']
-        #         }
-        #     }
-            
-        #     # 獲取品種的運動需求配置
-        #     breed_level = exercise_levels.get(breed_needs.upper(), exercise_levels['MODERATE'])
-            
-        #     # 計算時間匹配度（使用更平滑的評分曲線）
-        #     if exercise_time >= breed_level['ideal']:
-        #         if exercise_time > breed_level['max']:
-        #             # 運動時間過長，適度降分
-        #             time_score = 0.15 - (0.08 * (exercise_time - breed_level['max']) / 30)
-        #         else:
-        #             time_score = 0.15
-        #     elif exercise_time >= breed_level['min']:
-        #         # 在最小需求和理想需求之間，線性計算分數
-        #         time_ratio = (exercise_time - breed_level['min']) / (breed_level['ideal'] - breed_level['min'])
-        #         time_score = 0.05 + (time_ratio * 0.10)
-        #     else:
-        #         # 運動時間不足，根據差距程度扣分
-        #         time_ratio = max(0, exercise_time / breed_level['min'])
-        #         time_score = -0.20 * (1 - time_ratio)
-            
-        #     # 運動類型匹配度評估
-        #     type_score = 0.0
-        #     if exercise_type in breed_level['preferred_types']:
-        #         type_score = 0.05
-        #         if exercise_type == breed_level['preferred_types'][0]:
-        #             type_score = 0.08  # 最佳匹配類型給予更高分數
-            
-        #     return max(-0.2, min(0.2, time_score + type_score))
-
 
         def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
             """
-            改進的空間評分系統，提供更細緻的居住環境評估
-            
-            改進重點：
-            1. 更動態的基礎分數矩陣
+            1. 動態的基礎分數矩陣
             2. 強化空間品質評估
             3. 增加極端情況處理
             4. 考慮不同空間組合的協同效應
@@ -1479,210 +1297,212 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 
 # def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
 #     """
-#     改進的品種相容性評分系統，提供更動態和精確的評分
-    
-#     主要改進：
-#     1. 更動態的權重系統
-#     2. 更強的極端情況處理
-#     3. 更精確的品種特性評估
+#     重構的品種相容性評分系統
+#     目標：實現更大的分數差異和更高的頂部分數
 #     """
-#     def evaluate_condition_extremity():
-#         """評估使用者條件的極端程度"""
-#         extremity_count = 0
+#     def evaluate_perfect_conditions():
+#         """評估完美條件匹配度"""
+#         perfect_matches = {
+#             'size_match': False,
+#             'exercise_match': False,
+#             'experience_match': False,
+#             'general_match': False
+#         }
         
-#         # 空間條件極端性
-#         if user_prefs.living_space == 'apartment' and breed_info['Size'] in ['Large', 'Giant']:
-#             extremity_count += 2
-#         elif user_prefs.living_space == 'house_large' and breed_info['Size'] == 'Small':
-#             extremity_count += 1
+#         # 體型與空間匹配
+#         if user_prefs.living_space == 'apartment':
+#             perfect_matches['size_match'] = breed_info['Size'] == 'Small'
+#         elif user_prefs.living_space == 'house_large':
+#             perfect_matches['size_match'] = breed_info['Size'] in ['Medium', 'Large']
             
-#         # 運動需求極端性
+#         # 運動需求匹配
 #         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-#         if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 60:
-#             extremity_count += 2
-#         elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
-#             extremity_count += 1
+#         if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time >= 150:
+#             perfect_matches['exercise_match'] = True
+#         elif exercise_needs == 'LOW' and 30 <= user_prefs.exercise_time <= 90:
+#             perfect_matches['exercise_match'] = True
+#         elif 60 <= user_prefs.exercise_time <= 120:
+#             perfect_matches['exercise_match'] = True
             
-#         # 經驗等級極端性
+#         # 經驗匹配
 #         care_level = breed_info.get('Care Level', 'MODERATE')
-#         if care_level == 'High' and user_prefs.experience_level == 'beginner':
-#             extremity_count += 2
+#         if care_level == 'High' and user_prefs.experience_level == 'advanced':
+#             perfect_matches['experience_match'] = True
+#         elif care_level == 'Low' and user_prefs.experience_level == 'beginner':
+#             perfect_matches['experience_match'] = True
+#         elif user_prefs.experience_level == 'intermediate':
+#             perfect_matches['experience_match'] = True
+            
+#         # 一般條件匹配
+#         if all(score >= 0.85 for score in scores.values()):
+#             perfect_matches['general_match'] = True
             
-#         return extremity_count
+#         return perfect_matches
 
-#     def calculate_dynamic_weights():
+#     def calculate_weights():
 #         """計算動態權重"""
-#         # 基礎權重
-#         weights = {
+#         base_weights = {
 #             'space': 0.20,
 #             'exercise': 0.20,
-#             'experience': 0.15,
+#             'experience': 0.20,  
 #             'grooming': 0.15,
 #             'health': 0.15,
-#             'noise': 0.15
+#             'noise': 0.10
 #         }
         
-#         # 根據生活環境調整權重
-#         if user_prefs.living_space == 'apartment':
-#             weights['space'] *= 2.0
-#             weights['noise'] *= 1.8
-        
-#         # 根據家庭情況調整
-#         if user_prefs.has_children:
-#             if user_prefs.children_age == 'toddler':
-#                 weights['noise'] *= 2.0
-#                 weights['experience'] *= 1.8
-#                 weights['health'] *= 1.5
-#             elif user_prefs.children_age == 'school_age':
-#                 weights['noise'] *= 1.5
-#                 weights['experience'] *= 1.3
+#         # 極端條件權重調整
+#         multipliers = {}
         
-#         # 根據運動時間調整
-#         if user_prefs.exercise_time < 30:
-#             weights['exercise'] *= 2.5
-#         elif user_prefs.exercise_time > 150:
-#             weights['exercise'] *= 2.0
+#         # 經驗權重調整
+#         if user_prefs.experience_level == 'beginner':
+#             multipliers['experience'] = 3.0  # 新手經驗極其重要
+#         elif user_prefs.experience_level == 'advanced':
+#             multipliers['experience'] = 2.5  # 專家經驗很重要
+            
+#         # 運動需求權重調整
+#         if user_prefs.exercise_time > 150:
+#             multipliers['exercise'] = 3.0
+#         elif user_prefs.exercise_time < 30:
+#             multipliers['exercise'] = 3.5
+            
+#         # 空間限制權重調整
+#         if user_prefs.living_space == 'apartment':
+#             multipliers['space'] = 2.5
+#             multipliers['noise'] = 2.0
             
-#         # 根據健康敏感度調整
-#         if user_prefs.health_sensitivity == 'high':
-#             weights['health'] *= 1.8
+#         # 應用乘數
+#         for key, multiplier in multipliers.items():
+#             base_weights[key] *= multiplier
             
-#         return weights
+#         return base_weights
 
-#     # 計算條件極端程度
-#     extremity_level = evaluate_condition_extremity()
+#     # 評估完美匹配條件
+#     perfect_conditions = evaluate_perfect_conditions()
     
 #     # 計算動態權重
-#     weights = calculate_dynamic_weights()
+#     weights = calculate_weights()
     
 #     # 正規化權重
 #     total_weight = sum(weights.values())
 #     normalized_weights = {k: v/total_weight for k, v in weights.items()}
     
-#     # 計算加權分數
-#     weighted_scores = {
-#         k: scores[k] * normalized_weights[k] for k in scores.keys()
-#     }
-    
-#     # 基礎分數
-#     base_score = sum(weighted_scores.values())
+#     # 計算基礎分數
+#     base_score = sum(scores[k] * normalized_weights[k] for k in scores.keys())
     
+#     # 完美匹配獎勵
+#     perfect_bonus = 1.0
+#     if perfect_conditions['size_match']:
+#         perfect_bonus += 0.2
+#     if perfect_conditions['exercise_match']:
+#         perfect_bonus += 0.2
+#     if perfect_conditions['experience_match']:
+#         perfect_bonus += 0.2
+#     if perfect_conditions['general_match']:
+#         perfect_bonus += 0.2
+        
 #     # 品種特性加成
-#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
-    
-#     # 根據極端程度調整最終分數
-#     if extremity_level >= 3:
-#         base_score *= 0.6  # 多個極端條件的嚴重懲罰
-#     elif extremity_level >= 2:
-#         base_score *= 0.8  # 較少極端條件的適度懲罰
+#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs) * 1.5  # 增加品種特性影響
     
-#     # 完美匹配加成
-#     if all(score >= 0.8 for score in scores.values()):
-#         base_score *= 1.3
+#     # 計算最終分數
+#     final_score = (base_score * 0.7 + breed_bonus * 0.3) * perfect_bonus
     
-#     # 品種特性影響力隨匹配度增加
-#     bonus_weight = min(0.35, max(0.15, breed_bonus))
-    
-#     # 最終分數計算
-#     final_score = (base_score * (1.0 - bonus_weight)) + (breed_bonus * bonus_weight)
-    
-#     return min(1.0, max(0.0, final_score))
-
-
-# def amplify_score_extreme(score: float) -> float:
-#     """
-#     改進的分數轉換函數，提供更合理的分數分布
-    
-#     特點：
-#     1. 更大的分數範圍
-#     2. 更平滑的轉換曲線
-#     3. 更準確的極端情況處理
-#     """
-#     def sigmoid_transform(x: float, steepness: float = 10) -> float:
-#         """使用 sigmoid 函數實現更平滑的轉換"""
-#         import math
-#         return 1 / (1 + math.exp(-steepness * (x - 0.5)))
-
-#     if score < 0.2:
-#         # 極差匹配：使用更低的起始分數
-#         base = 0.40
-#         range_score = 0.15
-#         position = score / 0.2
-#         return base + (sigmoid_transform(position) * range_score)
-        
-#     elif score < 0.4:
-#         # 較差匹配：緩慢增長
-#         base = 0.55
-#         range_score = 0.15
-#         position = (score - 0.2) / 0.2
-#         return base + (sigmoid_transform(position) * range_score)
-        
-#     elif score < 0.6:
-#         # 中等匹配：較大增長
-#         base = 0.70
-#         range_score = 0.15
-#         position = (score - 0.4) / 0.2
-#         return base + (sigmoid_transform(position) * range_score)
-        
-#     elif score < 0.8:
-#         # 良好匹配：快速增長
-#         base = 0.85
-#         range_score = 0.10
-#         position = (score - 0.6) / 0.2
-#         return base + (sigmoid_transform(position) * range_score)
-        
-#     elif score < 0.9:
-#         # 優秀匹配：接近最高分
-#         base = 0.95
-#         range_score = 0.03
-#         position = (score - 0.8) / 0.1
-#         return base + (sigmoid_transform(position) * range_score)
-        
-#     else:
-#         # 完美匹配：可能達到最高分
-#         base = 0.98
-#         range_score = 0.02
-#         position = (score - 0.9) / 0.1
-#         return base + (sigmoid_transform(position) * range_score)
-
+#     return min(1.0, final_score)
 
 def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
     """
     重構的品種相容性評分系統
-    目標：實現更大的分數差異和更高的頂部分數
+    目標：實現更大的分數差異和更高的頂部分數，更精確的條件匹配
     """
     def evaluate_perfect_conditions():
-        """評估完美條件匹配度"""
+        """評估完美條件匹配度，允許部分匹配"""
         perfect_matches = {
-            'size_match': False,
-            'exercise_match': False,
-            'experience_match': False,
+            'size_match': 0,
+            'exercise_match': 0,
+            'experience_match': 0,
             'general_match': False
         }
         
-        # 體型與空間匹配
+        # 體型與空間匹配更細緻化
         if user_prefs.living_space == 'apartment':
-            perfect_matches['size_match'] = breed_info['Size'] == 'Small'
+            if breed_info['Size'] == 'Small':
+                perfect_matches['size_match'] = 1.0
+            elif breed_info['Size'] == 'Medium':
+                perfect_matches['size_match'] = 0.5
+            else:
+                perfect_matches['size_match'] = 0
+        elif user_prefs.living_space == 'house_small':
+            if breed_info['Size'] in ['Small', 'Medium']:
+                perfect_matches['size_match'] = 1.0
+            elif breed_info['Size'] == 'Large':
+                perfect_matches['size_match'] = 0.6
+            else:
+                perfect_matches['size_match'] = 0.3
         elif user_prefs.living_space == 'house_large':
-            perfect_matches['size_match'] = breed_info['Size'] in ['Medium', 'Large']
+            if breed_info['Size'] in ['Medium', 'Large']:
+                perfect_matches['size_match'] = 1.0
+            elif breed_info['Size'] == 'Small':
+                perfect_matches['size_match'] = 0.7
+            else:
+                perfect_matches['size_match'] = 0.8
             
-        # 運動需求匹配
+        # 運動需求匹配更精確
         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-        if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time >= 150:
-            perfect_matches['exercise_match'] = True
-        elif exercise_needs == 'LOW' and 30 <= user_prefs.exercise_time <= 90:
-            perfect_matches['exercise_match'] = True
-        elif 60 <= user_prefs.exercise_time <= 120:
-            perfect_matches['exercise_match'] = True
-            
-        # 經驗匹配
+        exercise_time = user_prefs.exercise_time
+        
+        if exercise_needs == 'VERY HIGH':
+            if exercise_time >= 150:
+                perfect_matches['exercise_match'] = 1.0
+            elif exercise_time >= 120:
+                perfect_matches['exercise_match'] = 0.7
+            elif exercise_time >= 90:
+                perfect_matches['exercise_match'] = 0.4
+            else:
+                perfect_matches['exercise_match'] = 0
+        elif exercise_needs == 'HIGH':
+            if 120 <= exercise_time <= 150:
+                perfect_matches['exercise_match'] = 1.0
+            elif exercise_time >= 90:
+                perfect_matches['exercise_match'] = 0.8
+            elif exercise_time >= 60:
+                perfect_matches['exercise_match'] = 0.5
+            else:
+                perfect_matches['exercise_match'] = 0.2
+        elif exercise_needs == 'MODERATE':
+            if 60 <= exercise_time <= 120:
+                perfect_matches['exercise_match'] = 1.0
+            elif exercise_time > 120:
+                perfect_matches['exercise_match'] = 0.8
+            else:
+                perfect_matches['exercise_match'] = 0.6
+        elif exercise_needs == 'LOW':
+            if 30 <= exercise_time <= 90:
+                perfect_matches['exercise_match'] = 1.0
+            elif exercise_time > 90:
+                perfect_matches['exercise_match'] = 0.7
+            else:
+                perfect_matches['exercise_match'] = 0.5
+                
+        # 經驗匹配更細緻
         care_level = breed_info.get('Care Level', 'MODERATE')
-        if care_level == 'High' and user_prefs.experience_level == 'advanced':
-            perfect_matches['experience_match'] = True
-        elif care_level == 'Low' and user_prefs.experience_level == 'beginner':
-            perfect_matches['experience_match'] = True
-        elif user_prefs.experience_level == 'intermediate':
-            perfect_matches['experience_match'] = True
+        if care_level == 'High':
+            if user_prefs.experience_level == 'advanced':
+                perfect_matches['experience_match'] = 1.0
+            elif user_prefs.experience_level == 'intermediate':
+                perfect_matches['experience_match'] = 0.6
+            else:
+                perfect_matches['experience_match'] = 0.2
+        elif care_level == 'Moderate':
+            if user_prefs.experience_level == 'advanced':
+                perfect_matches['experience_match'] = 0.9
+            elif user_prefs.experience_level == 'intermediate':
+                perfect_matches['experience_match'] = 1.0
+            else:
+                perfect_matches['experience_match'] = 0.7
+        elif care_level == 'Low':
+            if user_prefs.experience_level == 'beginner':
+                perfect_matches['experience_match'] = 1.0
+            else:
+                perfect_matches['experience_match'] = 0.9
             
         # 一般條件匹配
         if all(score >= 0.85 for score in scores.values()):
@@ -1691,11 +1511,11 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         return perfect_matches
 
     def calculate_weights():
-        """計算動態權重"""
+        """計算更動態的權重"""
         base_weights = {
             'space': 0.20,
             'exercise': 0.20,
-            'experience': 0.20,  
+            'experience': 0.20,
             'grooming': 0.15,
             'health': 0.15,
             'noise': 0.10
@@ -1704,15 +1524,25 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         # 極端條件權重調整
         multipliers = {}
         
-        # 經驗權重調整
+        # 經驗權重更細緻的調整
         if user_prefs.experience_level == 'beginner':
-            multipliers['experience'] = 3.0  # 新手經驗極其重要
+            if breed_info.get('Care Level') == 'High':
+                multipliers['experience'] = 3.5
+            else:
+                multipliers['experience'] = 3.0
         elif user_prefs.experience_level == 'advanced':
-            multipliers['experience'] = 2.5  # 專家經驗很重要
-            
-        # 運動需求權重調整
-        if user_prefs.exercise_time > 150:
-            multipliers['exercise'] = 3.0
+            if breed_info.get('Care Level') == 'High':
+                multipliers['experience'] = 2.8
+            else:
+                multipliers['experience'] = 2.5
+
+        # 運動需求更細緻的調整
+        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+        if exercise_needs == 'VERY HIGH':
+            if user_prefs.exercise_time < 90:
+                multipliers['exercise'] = 4.0
+            elif user_prefs.exercise_time > 150:
+                multipliers['exercise'] = 3.0
         elif user_prefs.exercise_time < 30:
             multipliers['exercise'] = 3.5
             
@@ -1721,12 +1551,37 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
             multipliers['space'] = 2.5
             multipliers['noise'] = 2.0
             
+        # 噪音敏感度調整
+        if user_prefs.noise_tolerance == 'low':
+            multipliers['noise'] = multipliers.get('noise', 1.0) * 2.5
+            
         # 應用乘數
         for key, multiplier in multipliers.items():
             base_weights[key] *= multiplier
             
         return base_weights
 
+    def apply_special_case_adjustments(score):
+        """處理特殊情況"""
+        # 新手不適合的特殊情況
+        if user_prefs.experience_level == 'beginner':
+            if (breed_info.get('Care Level') == 'High' and 
+                breed_info.get('Exercise Needs') == 'VERY HIGH'):
+                score *= 0.7
+                
+        # 運動時間極端不匹配的情況
+        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+        if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 60:
+            score *= 0.6
+            
+        # 噪音敏感度極端情況
+        if (user_prefs.noise_tolerance == 'low' and 
+            breed_info.get('Breed') in breed_noise_info and 
+            breed_noise_info[breed_info['Breed']]['noise_level'].lower() == 'high'):
+            score *= 0.7
+            
+        return score
+
     # 評估完美匹配條件
     perfect_conditions = evaluate_perfect_conditions()
     
@@ -1740,23 +1595,23 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
     # 計算基礎分數
     base_score = sum(scores[k] * normalized_weights[k] for k in scores.keys())
     
-    # 完美匹配獎勵
+    # 完美匹配獎勵更動態
     perfect_bonus = 1.0
-    if perfect_conditions['size_match']:
-        perfect_bonus += 0.2
-    if perfect_conditions['exercise_match']:
-        perfect_bonus += 0.2
-    if perfect_conditions['experience_match']:
-        perfect_bonus += 0.2
+    perfect_bonus += 0.2 * perfect_conditions['size_match']
+    perfect_bonus += 0.2 * perfect_conditions['exercise_match']
+    perfect_bonus += 0.2 * perfect_conditions['experience_match']
     if perfect_conditions['general_match']:
         perfect_bonus += 0.2
         
     # 品種特性加成
-    breed_bonus = calculate_breed_bonus(breed_info, user_prefs) * 1.5  # 增加品種特性影響
+    breed_bonus = calculate_breed_bonus(breed_info, user_prefs) * 1.5
     
     # 計算最終分數
     final_score = (base_score * 0.7 + breed_bonus * 0.3) * perfect_bonus
     
+    # 應用特殊情況調整
+    final_score = apply_special_case_adjustments(final_score)
+    
     return min(1.0, final_score)