Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1294,110 +1294,143 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
         
     return min(0.2, adaptability_score)
 
+
 # def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
 #     """
-#     重構的品種相容性評分系統
-#     目標：實現更大的分數差異和更高的頂部分數，更精確的條件匹配
+#     優化後的品種相容性評分系統
+#     主要改進：
+#     1. 更精確的條件匹配度評估
+#     2. 更動態的權重分配
+#     3. 更嚴格的特殊情況處理
 #     """
 #     def evaluate_perfect_conditions():
-#         """評估完美條件匹配度，允許部分匹配"""
+#         """評估完美條件匹配度，重點優化不同條件組合的評估邏輯"""
 #         perfect_matches = {
 #             'size_match': 0,
 #             'exercise_match': 0,
 #             'experience_match': 0,
-#             'general_match': False
+#             'living_condition_match': 0
 #         }
         
-#         # 體型與空間匹配更細緻化
-#         if user_prefs.living_space == 'apartment':
-#             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':
-#             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
-            
-#         # 運動需求匹配更精確
+#         # 體型與居住空間匹配評估
+#         size_living_matrix = {
+#             'apartment': {
+#                 'Small': 1.0,
+#                 'Medium': 0.4,
+#                 'Large': 0.1,
+#                 'Giant': 0.05
+#             },
+#             'house_small': {
+#                 'Small': 0.9,
+#                 'Medium': 1.0,
+#                 'Large': 0.5,
+#                 'Giant': 0.3
+#             },
+#             'house_large': {
+#                 'Small': 0.7,
+#                 'Medium': 0.9,
+#                 'Large': 1.0,
+#                 'Giant': 0.9
+#             }
+#         }
+#         perfect_matches['size_match'] = size_living_matrix.get(user_prefs.living_space, {}).get(breed_info['Size'], 0.5)
+        
+#         # 運動需求匹配評估
 #         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
 #         exercise_time = user_prefs.exercise_time
+#         exercise_type = user_prefs.exercise_type
         
-#         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
+#         # 建立運動時間範圍對照表
+#         exercise_ranges = {
+#             'VERY HIGH': {'ideal': (150, 180), 'acceptable': (120, 200)},
+#             'HIGH': {'ideal': (120, 150), 'acceptable': (90, 180)},
+#             'MODERATE': {'ideal': (60, 120), 'acceptable': (45, 150)},
+#             'LOW': {'ideal': (30, 60), 'acceptable': (20, 90)}
+#         }
+        
+#         # 評估運動時間匹配度
+#         breed_range = exercise_ranges.get(exercise_needs, exercise_ranges['MODERATE'])
+#         if breed_range['ideal'][0] <= exercise_time <= breed_range['ideal'][1]:
+#             time_match = 1.0
+#         elif breed_range['acceptable'][0] <= exercise_time <= breed_range['acceptable'][1]:
+#             time_match = 0.7
+#         else:
+#             time_match = 0.3
+            
+#         # 運動類型匹配評估
+#         exercise_type_matrix = {
+#             'VERY HIGH': {
+#                 'light_walks': 0.2,
+#                 'moderate_activity': 0.5,
+#                 'active_training': 1.0
+#             },
+#             'HIGH': {
+#                 'light_walks': 0.3,
+#                 'moderate_activity': 0.8,
+#                 'active_training': 1.0
+#             },
+#             'MODERATE': {
+#                 'light_walks': 0.7,
+#                 'moderate_activity': 1.0,
+#                 'active_training': 0.8
+#             },
+#             'LOW': {
+#                 'light_walks': 1.0,
+#                 'moderate_activity': 0.7,
+#                 'active_training': 0.4
+#             }
+#         }
+        
+#         type_match = exercise_type_matrix.get(exercise_needs, {}).get(exercise_type, 0.5)
+#         perfect_matches['exercise_match'] = (time_match * 0.7) + (type_match * 0.3)
+        
+#         # 經驗匹配度評估
+#         care_level = breed_info.get('Care Level', 'MODERATE').upper()
+#         experience_matrix = {
+#             'HIGH': {
+#                 'beginner': 0.1,
+#                 'intermediate': 0.6,
+#                 'advanced': 1.0
+#             },
+#             'MODERATE': {
+#                 'beginner': 0.5,
+#                 'intermediate': 1.0,
+#                 'advanced': 0.9
+#             },
+#             'LOW': {
+#                 'beginner': 1.0,
+#                 'intermediate': 0.9,
+#                 'advanced': 0.8
+#             }
+#         }
+#         perfect_matches['experience_match'] = experience_matrix.get(care_level, {}).get(user_prefs.experience_level, 0.5)
+        
+#         # 生活條件整體匹配評估
+#         living_factors = []
+        
+#         # 院子可用性評估
+#         if breed_info.get('Exercise Needs', 'MODERATE').upper() in ['HIGH', 'VERY HIGH']:
+#             if user_prefs.yard_access == 'no_yard':
+#                 living_factors.append(0.3)
+#             elif user_prefs.yard_access == 'shared_yard':
+#                 living_factors.append(0.7)
 #             else:
-#                 perfect_matches['exercise_match'] = 0.5
+#                 living_factors.append(1.0)
                 
-#         # 經驗匹配更細緻
-#         care_level = breed_info.get('Care Level', 'MODERATE')
-#         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()):
-#             perfect_matches['general_match'] = True
-            
+#         # 時間可用性評估
+#         time_availability_scores = {
+#             'limited': 0.4,
+#             'moderate': 0.7,
+#             'flexible': 1.0
+#         }
+#         living_factors.append(time_availability_scores.get(user_prefs.time_availability, 0.7))
+        
+#         perfect_matches['living_condition_match'] = sum(living_factors) / len(living_factors) if living_factors else 0.5
+        
 #         return perfect_matches
 
 #     def calculate_weights():
-#         """計算更動態的權重"""
+#         """計算動態權重，根據使用者條件調整各項評分的重要性"""
 #         base_weights = {
 #             'space': 0.20,
 #             'exercise': 0.20,
@@ -1407,22 +1440,16 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #             'noise': 0.10
 #         }
         
-#         # 極端條件權重調整
 #         multipliers = {}
         
-#         # 經驗權重更細緻的調整
-#         if user_prefs.experience_level == 'beginner':
-#             if breed_info.get('Care Level') == 'High':
-#                 multipliers['experience'] = 3.5
-#             else:
-#                 multipliers['experience'] = 3.0
-#         elif user_prefs.experience_level == 'advanced':
-#             if breed_info.get('Care Level') == 'High':
-#                 multipliers['experience'] = 2.8
-#             else:
-#                 multipliers['experience'] = 2.5
-
-#         # 運動需求更細緻的調整
+#         # 居住空間權重調整
+#         if user_prefs.living_space == 'apartment':
+#             multipliers['space'] = 3.0
+#             multipliers['noise'] = 2.5
+#             if breed_info['Size'] in ['Large', 'Giant']:
+#                 multipliers['space'] = 4.0
+                
+#         # 運動需求權重調整
 #         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
 #         if exercise_needs == 'VERY HIGH':
 #             if user_prefs.exercise_time < 90:
@@ -1432,40 +1459,62 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #         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.experience_level == 'beginner':
+#             if breed_info.get('Care Level', 'MODERATE').upper() == 'HIGH':
+#                 multipliers['experience'] = 4.0
+#             else:
+#                 multipliers['experience'] = 3.0
+                
 #         # 噪音敏感度調整
 #         if user_prefs.noise_tolerance == 'low':
-#             multipliers['noise'] = multipliers.get('noise', 1.0) * 2.5
+#             multipliers['noise'] = multipliers.get('noise', 1.0) * 3.0
+            
+#         # 有小孩的情況特別注重經驗需求
+#         if user_prefs.has_children and user_prefs.children_age == 'toddler':
+#             multipliers['experience'] = multipliers.get('experience', 1.0) * 2.0
             
-#         # 應用乘數
+#         # 應用權重調整
 #         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
-                
-#         # 運動時間極端不匹配的情況
+#             if breed_info.get('Care Level') == 'HIGH':
+#                 if breed_info.get('Exercise Needs') == 'VERY HIGH':
+#                     score *= 0.4
+#                 else:
+#                     score *= 0.6
+                    
+#         # 運動需求極端不匹配
 #         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
+#             score *= 0.4
+#         elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
+#             score *= 0.5
             
+#         # 居住空間極端不匹配
+#         if user_prefs.living_space == 'apartment':
+#             if breed_info['Size'] == 'Giant':
+#                 score *= 0.3
+#             elif breed_info['Size'] == 'Large':
+#                 score *= 0.5
+                
+#         # 噪音敏感度極端不匹配
+#         if user_prefs.noise_tolerance == 'low':
+#             if breed_info.get('Breed') in breed_noise_info:
+#                 if breed_noise_info[breed_info['Breed']]['noise_level'].lower() == 'high':
+#                     score *= 0.4
+                    
+#         # 時間限制的影響
+#         if user_prefs.time_availability == 'limited':
+#             if breed_info.get('Exercise Needs').upper() in ['HIGH', 'VERY HIGH']:
+#                 score *= 0.6
+                
 #         return score
 
 #     # 評估完美匹配條件
@@ -1481,19 +1530,18 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #     # 計算基礎分數
 #     base_score = sum(scores[k] * normalized_weights[k] for k in scores.keys())
     
-#     # 完美匹配獎勵更動態
+#     # 完美匹配獎勵計算
 #     perfect_bonus = 1.0
-#     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
-        
+#     perfect_bonus += 0.15 * perfect_conditions['size_match']
+#     perfect_bonus += 0.15 * perfect_conditions['exercise_match']
+#     perfect_bonus += 0.15 * perfect_conditions['experience_match']
+#     perfect_bonus += 0.05 * perfect_conditions['living_condition_match']
+    
 #     # 品種特性加成
-#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs) * 1.5
+#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs) * 1.2
     
 #     # 計算最終分數
-#     final_score = (base_score * 0.7 + breed_bonus * 0.3) * perfect_bonus
+#     final_score = (base_score * 0.8 + breed_bonus * 0.2) * perfect_bonus
     
 #     # 應用特殊情況調整
 #     final_score = apply_special_case_adjustments(final_score)
@@ -1503,14 +1551,15 @@ 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. 更嚴格的特殊情況處理
+    1. 條件間的相互影響
+    2. 動態權重調整
+    3. 更自然的評分機制
     """
     def evaluate_perfect_conditions():
-        """評估完美條件匹配度，重點優化不同條件組合的評估邏輯"""
+        """
+        評估條件匹配度，考慮條件間的相互關係。
+        返回的不只是單純的匹配分數，而是綜合了各種條件互相影響後的結果。
+        """
         perfect_matches = {
             'size_match': 0,
             'exercise_match': 0,
@@ -1518,210 +1567,216 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
             'living_condition_match': 0
         }
         
-        # 體型與居住空間匹配評估
-        size_living_matrix = {
+        # 居住空間與體型匹配評估
+        size_living_evaluation = {
             'apartment': {
                 'Small': 1.0,
                 'Medium': 0.4,
-                'Large': 0.1,
-                'Giant': 0.05
+                'Large': 0.2,
+                'Giant': 0.1
             },
             'house_small': {
                 'Small': 0.9,
                 'Medium': 1.0,
-                'Large': 0.5,
-                'Giant': 0.3
-            },
-            'house_large': {
-                'Small': 0.7,
-                'Medium': 0.9,
-                'Large': 1.0,
-                'Giant': 0.9
+                'Large': 0.6,
+                'Giant': 0.4
             }
         }
-        perfect_matches['size_match'] = size_living_matrix.get(user_prefs.living_space, {}).get(breed_info['Size'], 0.5)
         
-        # 運動需求匹配評估
+        # 對於大房子，我們不使用固定的匹配矩陣，而是根據其他條件動態評估
+        if user_prefs.living_space == 'house_large':
+            # 大房子的評估更關注其他因素而不是體型限制
+            perfect_matches['size_match'] = 0.8  # 基礎分數較高
+            if breed_info['Size'] in ['Medium', 'Large']:
+                perfect_matches['size_match'] = 0.9
+        else:
+            perfect_matches['size_match'] = size_living_evaluation.get(
+                user_prefs.living_space, {}
+            ).get(breed_info['Size'], 0.5)
+
+        # 運動需求匹配評估，考慮多個相關因素
         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
         exercise_time = user_prefs.exercise_time
-        exercise_type = user_prefs.exercise_type
-        
-        # 建立運動時間範圍對照表
-        exercise_ranges = {
-            'VERY HIGH': {'ideal': (150, 180), 'acceptable': (120, 200)},
-            'HIGH': {'ideal': (120, 150), 'acceptable': (90, 180)},
-            'MODERATE': {'ideal': (60, 120), 'acceptable': (45, 150)},
-            'LOW': {'ideal': (30, 60), 'acceptable': (20, 90)}
-        }
         
-        # 評估運動時間匹配度
-        breed_range = exercise_ranges.get(exercise_needs, exercise_ranges['MODERATE'])
-        if breed_range['ideal'][0] <= exercise_time <= breed_range['ideal'][1]:
-            time_match = 1.0
-        elif breed_range['acceptable'][0] <= exercise_time <= breed_range['acceptable'][1]:
-            time_match = 0.7
-        else:
-            time_match = 0.3
-            
-        # 運動類型匹配評估
-        exercise_type_matrix = {
-            'VERY HIGH': {
-                'light_walks': 0.2,
-                'moderate_activity': 0.5,
-                'active_training': 1.0
-            },
-            'HIGH': {
-                'light_walks': 0.3,
-                'moderate_activity': 0.8,
-                'active_training': 1.0
-            },
-            'MODERATE': {
-                'light_walks': 0.7,
-                'moderate_activity': 1.0,
-                'active_training': 0.8
-            },
-            'LOW': {
-                'light_walks': 1.0,
-                'moderate_activity': 0.7,
-                'active_training': 0.4
+        # 建立運動時間的基礎評估
+        def evaluate_exercise_match():
+            # 根據運動需求級別動態計算理想範圍
+            exercise_ranges = {
+                'VERY HIGH': (120, 180),
+                'HIGH': (90, 150),
+                'MODERATE': (60, 120),
+                'LOW': (30, 90)
             }
+            
+            # 獲取該品種的理想運動範圍
+            ideal_range = exercise_ranges.get(exercise_needs, (60, 120))
+            min_time, max_time = ideal_range
+            
+            # 動態計算匹配度，避免硬性分界
+            if min_time <= exercise_time <= max_time:
+                base_score = 1.0
+            else:
+                # 計算與理想範圍的偏差程度
+                if exercise_time < min_time:
+                    deviation = (min_time - exercise_time) / min_time
+                else:
+                    deviation = (exercise_time - max_time) / max_time
+                base_score = max(0.3, 1 - deviation)
+            
+            return base_score
+        
+        # 結合運動時間與其他條件
+        exercise_base_score = evaluate_exercise_match()
+        
+        # 考慮時間可用性的影響
+        time_availability_impact = {
+            'limited': 0.7,
+            'moderate': 0.9,
+            'flexible': 1.0
         }
         
-        type_match = exercise_type_matrix.get(exercise_needs, {}).get(exercise_type, 0.5)
-        perfect_matches['exercise_match'] = (time_match * 0.7) + (type_match * 0.3)
+        # 考慮使用者經驗對運動安排的影響
+        experience_impact = {
+            'beginner': 0.8,
+            'intermediate': 0.9,
+            'advanced': 1.0
+        }
         
-        # 經驗匹配度評估
+        # 計算最終運動匹配度
+        exercise_modifiers = (
+            time_availability_impact.get(user_prefs.time_availability, 0.9) *
+            experience_impact.get(user_prefs.experience_level, 0.9)
+        )
+        
+        perfect_matches['exercise_match'] = exercise_base_score * exercise_modifiers
+
+        # 經驗匹配評估，考慮品種難度和其他因素
         care_level = breed_info.get('Care Level', 'MODERATE').upper()
-        experience_matrix = {
-            'HIGH': {
-                'beginner': 0.1,
-                'intermediate': 0.6,
-                'advanced': 1.0
-            },
-            'MODERATE': {
-                'beginner': 0.5,
-                'intermediate': 1.0,
-                'advanced': 0.9
-            },
-            'LOW': {
-                'beginner': 1.0,
-                'intermediate': 0.9,
-                'advanced': 0.8
-            }
+        
+        # 基礎經驗匹配評估
+        experience_base = {
+            'HIGH': {'beginner': 0.3, 'intermediate': 0.7, 'advanced': 1.0},
+            'MODERATE': {'beginner': 0.6, 'intermediate': 0.9, 'advanced': 1.0},
+            'LOW': {'beginner': 0.9, 'intermediate': 1.0, 'advanced': 0.9}
         }
-        perfect_matches['experience_match'] = experience_matrix.get(care_level, {}).get(user_prefs.experience_level, 0.5)
         
-        # 生活條件整體匹配評估
-        living_factors = []
+        experience_score = experience_base.get(care_level, experience_base['MODERATE']
+            ).get(user_prefs.experience_level, 0.7)
         
-        # 院子可用性評估
+        # 調整經驗分數基於其他因素
+        if user_prefs.has_children:
+            experience_score *= 0.8 if user_prefs.experience_level == 'beginner' else 0.9
+            
+        perfect_matches['experience_match'] = experience_score
+
+        # 生活條件整體評估
+        living_score = 1.0
+        
+        # 院子影響評估
         if breed_info.get('Exercise Needs', 'MODERATE').upper() in ['HIGH', 'VERY HIGH']:
-            if user_prefs.yard_access == 'no_yard':
-                living_factors.append(0.3)
-            elif user_prefs.yard_access == 'shared_yard':
-                living_factors.append(0.7)
-            else:
-                living_factors.append(1.0)
-                
-        # 時間可用性評估
-        time_availability_scores = {
-            'limited': 0.4,
-            'moderate': 0.7,
-            'flexible': 1.0
-        }
-        living_factors.append(time_availability_scores.get(user_prefs.time_availability, 0.7))
+            yard_impacts = {
+                'no_yard': 0.6,
+                'shared_yard': 0.8,
+                'private_yard': 1.0
+            }
+            living_score *= yard_impacts.get(user_prefs.yard_access, 0.8)
         
-        perfect_matches['living_condition_match'] = sum(living_factors) / len(living_factors) if living_factors else 0.5
+        perfect_matches['living_condition_match'] = living_score
         
         return perfect_matches
 
     def calculate_weights():
-        """計算動態權重，根據使用者條件調整各項評分的重要性"""
+        """
+        計算動態權重，根據條件的極端程度自動調整各項評分的重要性
+        """
+        # 基礎權重設定
         base_weights = {
             'space': 0.20,
             'exercise': 0.20,
             'experience': 0.20,
             'grooming': 0.15,
-            'health': 0.15,
-            'noise': 0.10
+            'noise': 0.15,
+            'health': 0.10
         }
         
-        multipliers = {}
-        
-        # 居住空間權重調整
-        if user_prefs.living_space == 'apartment':
-            multipliers['space'] = 3.0
-            multipliers['noise'] = 2.5
-            if breed_info['Size'] in ['Large', 'Giant']:
-                multipliers['space'] = 4.0
-                
-        # 運動需求權重調整
-        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
+        # 計算條件的極端程度
+        def calculate_extremity():
+            extremities = {}
             
-        # 經驗需求權重調整
-        if user_prefs.experience_level == 'beginner':
-            if breed_info.get('Care Level', 'MODERATE').upper() == 'HIGH':
-                multipliers['experience'] = 4.0
+            # 運動時間極端度
+            if user_prefs.exercise_time < 30:
+                extremities['exercise'] = ('low', 0.8)
+            elif user_prefs.exercise_time > 150:
+                extremities['exercise'] = ('high', 0.8)
             else:
-                multipliers['experience'] = 3.0
+                extremities['exercise'] = ('normal', 0.3)
                 
-        # 噪音敏感度調整
-        if user_prefs.noise_tolerance == 'low':
-            multipliers['noise'] = multipliers.get('noise', 1.0) * 3.0
+            # 居住空間極端度
+            if user_prefs.living_space == 'apartment':
+                extremities['space'] = ('restrictive', 0.9)
+            elif user_prefs.living_space == 'house_large':
+                extremities['space'] = ('relaxed', 0.2)
+            else:
+                extremities['space'] = ('normal', 0.5)
+                
+            return extremities
             
-        # 有小孩的情況特別注重經驗需求
-        if user_prefs.has_children and user_prefs.children_age == 'toddler':
-            multipliers['experience'] = multipliers.get('experience', 1.0) * 2.0
+        extremities = calculate_extremity()
+        
+        # 根據極端程度調整權重
+        weight_adjustments = {}
+        
+        # 空間限制的權重調整
+        if extremities['space'][0] == 'restrictive':
+            weight_adjustments['space'] = 3.0
+            weight_adjustments['noise'] = 2.0
+        elif extremities['space'][0] == 'relaxed':
+            weight_adjustments['space'] = 0.5
+            weight_adjustments['exercise'] = 1.5
+            
+        # 運動需求的權重調整
+        if extremities['exercise'][0] in ['low', 'high']:
+            weight_adjustments['exercise'] = 2.5
             
+        # 經驗需求的權重調整
+        if user_prefs.experience_level == 'beginner':
+            weight_adjustments['experience'] = 2.0
+        
         # 應用權重調整
-        for key, multiplier in multipliers.items():
-            base_weights[key] *= multiplier
+        final_weights = base_weights.copy()
+        for key, adjustment in weight_adjustments.items():
+            final_weights[key] *= adjustment
             
-        return base_weights
+        return final_weights
 
     def apply_special_case_adjustments(score):
-        """處理特殊情況，給予更嚴格的分數調整"""
-        # 極端不匹配情況的嚴格懲罰
+        """
+        處理特殊情況，考慮條件組合產生的效果
+        """
+        # 評估條件組合的嚴重程度
+        severity = 1.0
+        
+        # 空間與運動組合評估
+        if user_prefs.living_space == 'apartment':
+            if breed_info.get('Exercise Needs', 'MODERATE').upper() == 'VERY HIGH':
+                severity *= 0.6
+            elif breed_info['Size'] in ['Large', 'Giant']:
+                severity *= 0.7
+                
+        # 經驗與品種難度組合評估
         if user_prefs.experience_level == 'beginner':
             if breed_info.get('Care Level') == 'HIGH':
-                if breed_info.get('Exercise Needs') == 'VERY HIGH':
-                    score *= 0.4
+                if user_prefs.has_children:
+                    severity *= 0.6
                 else:
-                    score *= 0.6
+                    severity *= 0.7
                     
-        # 運動需求極端不匹配
-        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-        if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 60:
-            score *= 0.4
-        elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
-            score *= 0.5
-            
-        # 居住空間極端不匹配
-        if user_prefs.living_space == 'apartment':
-            if breed_info['Size'] == 'Giant':
-                score *= 0.3
-            elif breed_info['Size'] == 'Large':
-                score *= 0.5
-                
-        # 噪音敏感度極端不匹配
-        if user_prefs.noise_tolerance == 'low':
-            if breed_info.get('Breed') in breed_noise_info:
-                if breed_noise_info[breed_info['Breed']]['noise_level'].lower() == 'high':
-                    score *= 0.4
-                    
-        # 時間限制的影響
+        # 時間限制與需求組合評估
         if user_prefs.time_availability == 'limited':
             if breed_info.get('Exercise Needs').upper() in ['HIGH', 'VERY HIGH']:
-                score *= 0.6
+                severity *= 0.8
                 
-        return score
+        return score * severity
 
     # 評估完美匹配條件
     perfect_conditions = evaluate_perfect_conditions()
@@ -1736,20 +1791,18 @@ 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
     perfect_bonus += 0.15 * perfect_conditions['size_match']
     perfect_bonus += 0.15 * perfect_conditions['exercise_match']
     perfect_bonus += 0.15 * perfect_conditions['experience_match']
     perfect_bonus += 0.05 * perfect_conditions['living_condition_match']
     
-    # 品種特性加成
-    breed_bonus = calculate_breed_bonus(breed_info, user_prefs) * 1.2
+    # 品種特性加成（使用原有的 calculate_breed_bonus 函數）
+    breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-    # 計算最終分數
+    # 計算最終分數並應用特殊情況調整
     final_score = (base_score * 0.8 + breed_bonus * 0.2) * perfect_bonus
-    
-    # 應用特殊情況調整
     final_score = apply_special_case_adjustments(final_score)
     
     return min(1.0, final_score)
@@ -1757,7 +1810,6 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
 
 def amplify_score_extreme(score: float) -> float:
     """
-    改進的分數轉換函數：實現更高的頂部分數
     - 完美匹配可達到95-99%
     - 優秀匹配在90-95%
     - 良好匹配在85-90%