Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1297,14 +1297,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,
@@ -1312,210 +1313,216 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #             '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
+            
+#         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 user_prefs.has_children and user_prefs.children_age == 'toddler':
-#             multipliers['experience'] = multipliers.get('experience', 1.0) * 2.0
+#         # 運動需求的權重調整
+#         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
-                    
-#         # 運動需求極端不匹配
-#         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
+#                     severity *= 0.7
                     
-#         # 時間限制的影響
+#         # 時間限制與需求組合評估
 #         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()
@@ -1530,20 +1537,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.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)
@@ -1551,15 +1556,13 @@ 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. 空間利用的實際效果
+    4. 條件組合的嚴格評估
     """
     def evaluate_perfect_conditions():
-        """
-        評估條件匹配度，考慮條件間的相互關係。
-        返回的不只是單純的匹配分數，而是綜合了各種條件互相影響後的結果。
-        """
+        """評估條件匹配度，特別強化運動類型與專業程度的評估"""
         perfect_matches = {
             'size_match': 0,
             'exercise_match': 0,
@@ -1567,8 +1570,81 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
             'living_condition_match': 0
         }
         
-        # 居住空間與體型匹配評估
-        size_living_evaluation = {
+        # 運動類型與需求的精確匹配
+        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+        exercise_time = user_prefs.exercise_time
+        exercise_type = user_prefs.exercise_type
+        
+        # 定義品種的理想運動模式
+        breed_exercise_preferences = {
+            'VERY HIGH': {
+                'ideal_type': 'active_training',
+                'acceptable_types': ['moderate_activity'],
+                'time_ranges': {
+                    'ideal': (120, 180),
+                    'acceptable': (90, 200)
+                }
+            },
+            'HIGH': {
+                'ideal_type': 'moderate_activity',
+                'acceptable_types': ['active_training', 'light_walks'],
+                'time_ranges': {
+                    'ideal': (90, 150),
+                    'acceptable': (60, 180)
+                }
+            },
+            'MODERATE': {
+                'ideal_type': 'moderate_activity',
+                'acceptable_types': ['light_walks', 'active_training'],
+                'time_ranges': {
+                    'ideal': (45, 90),
+                    'acceptable': (30, 120)
+                }
+            },
+            'LOW': {
+                'ideal_type': 'light_walks',
+                'acceptable_types': ['moderate_activity'],
+                'time_ranges': {
+                    'ideal': (30, 60),
+                    'acceptable': (15, 90)
+                }
+            }
+        }
+        
+        # 計算運動匹配度
+        exercise_profile = breed_exercise_preferences.get(exercise_needs, 
+                                                       breed_exercise_preferences['MODERATE'])
+        
+        # 時間匹配度計算
+        time_ranges = exercise_profile['time_ranges']
+        if time_ranges['ideal'][0] <= exercise_time <= time_ranges['ideal'][1]:
+            time_score = 1.0
+        elif time_ranges['acceptable'][0] <= exercise_time <= time_ranges['acceptable'][1]:
+            # 計算與理想範圍的距離
+            if exercise_time < time_ranges['ideal'][0]:
+                deviation = (time_ranges['ideal'][0] - exercise_time) / time_ranges['ideal'][0]
+            else:
+                deviation = (exercise_time - time_ranges['ideal'][1]) / time_ranges['ideal'][1]
+            time_score = max(0.4, 1 - (deviation * 0.6))
+        else:
+            time_score = 0.3
+        
+        # 運動類型匹配度計算
+        if exercise_type == exercise_profile['ideal_type']:
+            type_score = 1.0
+        elif exercise_type in exercise_profile['acceptable_types']:
+            type_score = 0.7
+        else:
+            type_score = 0.4
+            
+        # 若運動時間過長但強度不足，額外降低分數
+        if exercise_time > time_ranges['acceptable'][1] and exercise_type != exercise_profile['ideal_type']:
+            type_score *= 0.7
+            
+        perfect_matches['exercise_match'] = (time_score * 0.6) + (type_score * 0.4)
+        
+        # 體型與空間的實際利用評估
+        space_utilization = {
             'apartment': {
                 'Small': 1.0,
                 'Medium': 0.4,
@@ -1578,118 +1654,91 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
             'house_small': {
                 'Small': 0.9,
                 'Medium': 1.0,
-                'Large': 0.6,
-                'Giant': 0.4
+                'Large': 0.5,
+                'Giant': 0.3
+            },
+            'house_large': {
+                'Small': 0.7,
+                'Medium': 0.9,
+                'Large': 1.0,
+                'Giant': 0.95
             }
         }
         
-        # 對於大房子，我們不使用固定的匹配矩陣，而是根據其他條件動態評估
-        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
+        # 增加活動空間需求評估
+        space_needs = 'high' if exercise_needs in ['VERY HIGH', 'HIGH'] else 'moderate'
+        if space_needs == 'high' and user_prefs.living_space != 'house_large':
+            space_score = space_utilization[user_prefs.living_space][breed_info['Size']] * 0.8
         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
-        
-        # 建立運動時間的基礎評估
-        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
+            space_score = space_utilization.get(user_prefs.living_space, 
+                                              space_utilization['house_small'])[breed_info['Size']]
             
-            # 動態計算匹配度，避免硬性分界
-            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
-        }
-        
-        # 考慮使用者經驗對運動安排的影響
-        experience_impact = {
-            'beginner': 0.8,
-            'intermediate': 0.9,
-            'advanced': 1.0
-        }
+        perfect_matches['size_match'] = space_score
         
-        # 計算最終運動匹配度
-        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_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}
+        temperament = breed_info.get('Temperament', '').lower()
+        
+        # 定義進階特徵
+        advanced_traits = ['working', 'independent', 'dominant', 'protective']
+        advanced_trait_count = sum(1 for trait in advanced_traits if trait in temperament)
+        
+        # 經驗匹配度計算
+        experience_matrix = {
+            'HIGH': {
+                'beginner': 0.2,        # 更嚴格的新手限制
+                'intermediate': 0.6,
+                'advanced': 1.0
+            },
+            'MODERATE': {
+                'beginner': 0.5,
+                'intermediate': 0.9,
+                'advanced': 0.95
+            },
+            'LOW': {
+                'beginner': 0.9,
+                'intermediate': 0.85,
+                'advanced': 0.8         # 對專家稍微降低簡單品種的分數
+            }
         }
         
-        experience_score = experience_base.get(care_level, experience_base['MODERATE']
-            ).get(user_prefs.experience_level, 0.7)
+        experience_score = experience_matrix[care_level][user_prefs.experience_level]
         
-        # 調整經驗分數基於其他因素
-        if user_prefs.has_children:
-            experience_score *= 0.8 if user_prefs.experience_level == 'beginner' else 0.9
-            
+        # 根據進階特徵調整分數
+        if advanced_trait_count > 0:
+            if user_prefs.experience_level == 'beginner':
+                experience_score *= (0.8 ** advanced_trait_count)
+            elif user_prefs.experience_level == 'advanced':
+                experience_score *= (1.1 ** min(advanced_trait_count, 2))
+                
         perfect_matches['experience_match'] = experience_score
-
+        
         # 生活條件整體評估
         living_score = 1.0
         
-        # 院子影響評估
+        # 院子影響的嚴格評估
         if breed_info.get('Exercise Needs', 'MODERATE').upper() in ['HIGH', 'VERY HIGH']:
             yard_impacts = {
-                'no_yard': 0.6,
-                'shared_yard': 0.8,
+                'no_yard': 0.5,         # 更嚴格的懲罰
+                'shared_yard': 0.7,
                 'private_yard': 1.0
             }
-            living_score *= yard_impacts.get(user_prefs.yard_access, 0.8)
+            living_score *= yard_impacts.get(user_prefs.yard_access, 0.7)
+            
+        # 時間可用性評估
+        time_impacts = {
+            'limited': 0.6,             # 更嚴格的時間限制影響
+            'moderate': 0.8,
+            'flexible': 1.0
+        }
+        living_score *= time_impacts.get(user_prefs.time_availability, 0.8)
         
         perfect_matches['living_condition_match'] = living_score
         
         return perfect_matches
 
     def calculate_weights():
-        """
-        計算動態權重，根據條件的極端程度自動調整各項評分的重要性
-        """
-        # 基礎權重設定
+        """計算動態權重，強化條件極端情況的影響"""
         base_weights = {
             'space': 0.20,
             'exercise': 0.20,
@@ -1699,49 +1748,60 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
             'health': 0.10
         }
         
-        # 計算條件的極端程度
-        def calculate_extremity():
+        # 計算條件極端度
+        def calculate_condition_extremity():
             extremities = {}
             
-            # 運動時間極端度
+            # 運動時間極端度評估
             if user_prefs.exercise_time < 30:
-                extremities['exercise'] = ('low', 0.8)
+                extremities['exercise'] = ('very_low', 0.9)
+            elif user_prefs.exercise_time < 60:
+                extremities['exercise'] = ('low', 0.7)
             elif user_prefs.exercise_time > 150:
-                extremities['exercise'] = ('high', 0.8)
+                extremities['exercise'] = ('very_high', 0.9)
+            elif user_prefs.exercise_time > 120:
+                extremities['exercise'] = ('high', 0.7)
             else:
-                extremities['exercise'] = ('normal', 0.3)
+                extremities['exercise'] = ('moderate', 0.3)
                 
-            # 居住空間極端度
+            # 空間限制極端度評估
             if user_prefs.living_space == 'apartment':
-                extremities['space'] = ('restrictive', 0.9)
-            elif user_prefs.living_space == 'house_large':
-                extremities['space'] = ('relaxed', 0.2)
+                extremities['space'] = ('very_restricted', 0.9)
+            elif user_prefs.living_space == 'house_small':
+                extremities['space'] = ('restricted', 0.6)
             else:
-                extremities['space'] = ('normal', 0.5)
+                extremities['space'] = ('spacious', 0.3)
                 
             return extremities
             
-        extremities = calculate_extremity()
+        extremities = calculate_condition_extremity()
         
-        # 根據極端程度調整權重
+        # 權重調整
         weight_adjustments = {}
         
-        # 空間限制的權重調整
-        if extremities['space'][0] == 'restrictive':
+        # 空間權重調整
+        if extremities['space'][0] == 'very_restricted':
             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
+            weight_adjustments['noise'] = 2.5
+        elif extremities['space'][0] == 'restricted':
+            weight_adjustments['space'] = 2.0
+            weight_adjustments['noise'] = 1.8
+        elif extremities['space'][0] == 'spacious':
+            weight_adjustments['space'] = 0.7    # 大空間時降低空間權重
+            weight_adjustments['exercise'] = 1.5  # 提升運動重要性
             
-        # 運動需求的權重調整
-        if extremities['exercise'][0] in ['low', 'high']:
-            weight_adjustments['exercise'] = 2.5
+        # 運動需求權重調整
+        if extremities['exercise'][0] in ['very_low', 'very_high']:
+            weight_adjustments['exercise'] = 3.0
+        elif extremities['exercise'][0] in ['low', 'high']:
+            weight_adjustments['exercise'] = 2.0
             
-        # 經驗需求的權重調整
+        # 經驗需求權重調整
         if user_prefs.experience_level == 'beginner':
+            weight_adjustments['experience'] = 2.5
+        elif user_prefs.experience_level == 'advanced':
             weight_adjustments['experience'] = 2.0
-        
+            
         # 應用權重調整
         final_weights = base_weights.copy()
         for key, adjustment in weight_adjustments.items():
@@ -1750,31 +1810,38 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         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.5   # 更嚴重的懲罰
+            elif breed_info.get('Exercise Needs') == 'HIGH':
                 severity *= 0.6
-            elif breed_info['Size'] in ['Large', 'Giant']:
-                severity *= 0.7
+            if breed_info['Size'] in ['Large', 'Giant']:
+                severity *= 0.5
                 
-        # 經驗與品種難度組合評估
+        # 經驗與品種難度組合的嚴格評估
         if user_prefs.experience_level == 'beginner':
             if breed_info.get('Care Level') == 'HIGH':
                 if user_prefs.has_children:
-                    severity *= 0.6
+                    severity *= 0.5
                 else:
-                    severity *= 0.7
+                    severity *= 0.6
                     
-        # 時間限制與需求組合評估
+        # 時間限制與需求組合的嚴格評估
         if user_prefs.time_availability == 'limited':
-            if breed_info.get('Exercise Needs').upper() in ['HIGH', 'VERY HIGH']:
-                severity *= 0.8
+            if breed_info.get('Exercise Needs').upper() in ['VERY HIGH', 'HIGH']:
+                severity *= 0.6
+                
+        # 運動類型不匹配的懲罰
+        if user_prefs.exercise_time > 120:
+            exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+            if exercise_needs == 'LOW':
+                severity *= 0.7
+            elif exercise_needs == 'VERY HIGH' and user_prefs.exercise_type == 'light_walks':
+                severity *= 0.6
                 
         return score * severity
 
@@ -1791,18 +1858,20 @@ 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']
+    perfect_bonus += 0.12 * perfect_conditions['size_match']
+    perfect_bonus += 0.12 * perfect_conditions['exercise_match']
+    perfect_bonus += 0.12 * perfect_conditions['experience_match']
+    perfect_bonus += 0.04 * perfect_conditions['living_condition_match']
     
-    # 品種特性加成（使用原有的 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 = (base_score * 0.85 + breed_bonus * 0.15) * perfect_bonus
+    
+    # 應用特殊情況調整
     final_score = apply_special_case_adjustments(final_score)
     
     return min(1.0, final_score)