Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1297,15 +1297,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,
@@ -1313,8 +1311,81 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #             '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,
@@ -1324,118 +1395,91 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #             '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)
-#             }
+#             space_score = space_utilization.get(user_prefs.living_space, 
+#                                               space_utilization['house_small'])[breed_info['Size']]
             
-#             # 獲取該品種的理想運動範圍
-#             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
-#         }
-        
-#         # 考慮使用者經驗對運動安排的影響
-#         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,
@@ -1445,49 +1489,60 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #             '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():
@@ -1496,31 +1551,38 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #         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
 
@@ -1537,18 +1599,20 @@ 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']
+#     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)
@@ -1562,183 +1626,205 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
     4. 條件組合的嚴格評估
     """
     def evaluate_perfect_conditions():
-        """評估條件匹配度，特別強化運動類型與專業程度的評估"""
+        """
+        評估條件匹配度，特別強化：
+        1. 運動類型與時間的綜合評估
+        2. 專業技能需求評估
+        3. ���種特性評估
+        """
         perfect_matches = {
             'size_match': 0,
             'exercise_match': 0,
             'experience_match': 0,
-            'living_condition_match': 0
+            'living_condition_match': 0,
+            'breed_trait_match': 0  # 新增品種特性匹配度
         }
         
-        # 運動類型與需求的精確匹配
-        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)
+        # 第一部分：運動需求評估
+        def evaluate_exercise_compatibility():
+            exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+            exercise_time = user_prefs.exercise_time
+            exercise_type = user_prefs.exercise_type
+            temperament = breed_info.get('Temperament', '').lower()
+            
+            # 定義品種運動特性
+            exercise_patterns = {
+                'sprint_type': {  # 短跑型，如 Whippet
+                    'keywords': ['fast', 'speed', 'agile', 'sprint'],
+                    'ideal_time': (30, 90),
+                    'ideal_type': 'active_training',
+                    'time_penalties': {
+                        'over': 0.7,    # 運動時間過長的懲罰
+                        'under': 0.6    # 運動時間不足的懲罰
+                    }
+                },
+                'endurance_type': {  # 耐力型，如 Border Collie
+                    'keywords': ['herding', 'working', 'energetic', 'tireless'],
+                    'ideal_time': (90, 180),
+                    'ideal_type': 'moderate_activity',
+                    'time_penalties': {
+                        'over': 0.9,    # 耐力型對超時較寬容
+                        'under': 0.5    # 但對運動不足較敏感
+                    }
+                },
+                'moderate_type': {  # 一般型
+                    'keywords': ['playful', 'active', 'friendly'],
+                    'ideal_time': (60, 120),
+                    'ideal_type': 'moderate_activity',
+                    'time_penalties': {
+                        'over': 0.8,
+                        'under': 0.7
+                    }
                 }
             }
-        }
-        
-        # 計算運動匹配度
-        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]
+    
+            # 判斷品種的運動類型
+            breed_type = 'moderate_type'  # 預設值
+            for pattern_type, pattern in exercise_patterns.items():
+                if any(keyword in temperament for keyword in pattern['keywords']):
+                    breed_type = pattern_type
+                    break
+    
+            pattern = exercise_patterns[breed_type]
+            min_time, max_time = pattern['ideal_time']
+    
+            # 計算時間匹配度
+            if min_time <= exercise_time <= max_time:
+                time_score = 1.0
+            elif exercise_time < min_time:
+                time_score = pattern['time_penalties']['under']
             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
+                time_score = pattern['time_penalties']['over']
+    
+            # 運動類型匹配度
+            type_scores = {
+                'light_walks': 0.7,
+                'moderate_activity': 0.9,
+                'active_training': 1.0
+            }
+            type_score = type_scores.get(exercise_type, 0.7)
+    
+            # 特殊情況處理
+            if breed_type == 'sprint_type' and exercise_time > 120:
+                if exercise_type != 'active_training':
+                    type_score *= 0.6  # 衝刺型品種不適合長時間中低強度運動
+    
+            return (time_score * 0.6) + (type_score * 0.4)
+    
+        # 第二部分：專業技能需求評估
+        def evaluate_expertise_requirements():
+            care_level = breed_info.get('Care Level', 'MODERATE').upper()
+            temperament = breed_info.get('Temperament', '').lower()
             
-        perfect_matches['exercise_match'] = (time_score * 0.6) + (type_score * 0.4)
-        
-        # 體型與空間的實際利用評估
-        space_utilization = {
-            'apartment': {
-                'Small': 1.0,
-                'Medium': 0.4,
-                '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.95
+            # 定義專業技能要求
+            expertise_requirements = {
+                'training_complexity': {
+                    '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': 0.95, 'advanced': 0.9}
+                },
+                'special_traits': {
+                    'working': 0.2,    # 工作犬需要額外技能
+                    'herding': 0.2,    # 牧羊犬需要特殊訓練
+                    'intelligent': 0.15,# 高智商犬種需要心智刺激
+                    'independent': 0.15,# 獨立性強的需要特殊處理
+                    'protective': 0.1   # 護衛犬需要適當訓練
+                }
             }
-        }
-        
-        # 增加活動空間需求評估
-        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:
-            space_score = space_utilization.get(user_prefs.living_space, 
-                                              space_utilization['house_small'])[breed_info['Size']]
+    
+            # 基礎分數
+            base_score = expertise_requirements['training_complexity'][care_level][user_prefs.experience_level]
+    
+            # 特殊特徵評估
+            trait_penalty = 0
+            for trait, penalty in expertise_requirements['special_traits'].items():
+                if trait in temperament:
+                    if user_prefs.experience_level == 'beginner':
+                        trait_penalty += penalty
+                    elif user_prefs.experience_level == 'advanced':
+                        trait_penalty -= penalty * 0.5  # 專家反而因應對特殊特徵而加分
+    
+            return max(0.2, min(1.0, base_score - trait_penalty))
+    
+        # 第三部分：生活環境評估
+        def evaluate_living_conditions():
+            size = breed_info['Size']
+            exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
             
-        perfect_matches['size_match'] = space_score
-        
-        # 經驗需求的專業評估
-        care_level = breed_info.get('Care Level', 'MODERATE').upper()
-        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         # 對專家稍微降低簡單品種的分數
+            # 空間需求矩陣
+            space_requirements = {
+                'apartment': {
+                    'Small': 1.0, 'Medium': 0.4, 'Large': 0.2, 'Giant': 0.1
+                },
+                'house_small': {
+                    'Small': 0.9, 'Medium': 1.0, 'Large': 0.5, 'Giant': 0.3
+                },
+                'house_large': {
+                    'Small': 0.8, 'Medium': 0.9, 'Large': 1.0, 'Giant': 1.0
+                }
             }
-        }
-        
-        experience_score = experience_matrix[care_level][user_prefs.experience_level]
-        
-        # 根據進階特徵調整分數
-        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.5,         # 更嚴格的懲罰
-                'shared_yard': 0.7,
+            
+            # 基礎空間分數
+            space_score = space_requirements.get(user_prefs.living_space, 
+                                               space_requirements['house_small'])[size]
+    
+            # 活動空間需求調整
+            if exercise_needs in ['HIGH', 'VERY HIGH']:
+                if user_prefs.living_space != 'house_large':
+                    space_score *= 0.8
+    
+            # 院子可用性評估
+            yard_scores = {
+                'no_yard': 0.7,
+                'shared_yard': 0.85,
                 'private_yard': 1.0
             }
-            living_score *= yard_impacts.get(user_prefs.yard_access, 0.7)
+            space_score *= yard_scores.get(user_prefs.yard_access, 0.8)
+    
+            return space_score
+    
+        # 第四部分：品種特性評估（新增）
+        def evaluate_breed_traits():
+            temperament = breed_info.get('Temperament', '').lower()
+            description = breed_info.get('Description', '').lower()
             
-        # 時間可用性評估
-        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
-        
+            trait_scores = []
+            
+            # 評估性格特徵
+            if user_prefs.has_children:
+                if 'good with children' in description:
+                    trait_scores.append(1.0)
+                elif 'patient' in temperament or 'gentle' in temperament:
+                    trait_scores.append(0.8)
+                else:
+                    trait_scores.append(0.5)
+    
+            # 評估適應性
+            adaptability_keywords = ['adaptable', 'versatile', 'flexible']
+            if any(keyword in temperament for keyword in adaptability_keywords):
+                trait_scores.append(1.0)
+            else:
+                trait_scores.append(0.7)
+    
+            return sum(trait_scores) / len(trait_scores) if trait_scores else 0.7
+    
+        # 計算各項匹配分數
+        perfect_matches['exercise_match'] = evaluate_exercise_compatibility()
+        perfect_matches['experience_match'] = evaluate_expertise_requirements()
+        perfect_matches['living_condition_match'] = evaluate_living_conditions()
+        perfect_matches['size_match'] = evaluate_living_conditions()  # 共用生活環境評估
+        perfect_matches['breed_trait_match'] = evaluate_breed_traits()
+    
         return perfect_matches
 
     def calculate_weights():
-        """計算動態權重，強化條件極端情況的影響"""
+        """
+        計算動態權重，特別關注：
+        1. 條件極端度對權重的影響
+        2. 多重條件組合的權重調整
+        3. 品種特性對權重分配的影響
+        """
+        # 基礎權重設定
         base_weights = {
             'space': 0.20,
             'exercise': 0.20,
@@ -1748,102 +1834,211 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
             'health': 0.10
         }
         
-        # 計算條件極端度
-        def calculate_condition_extremity():
+        def analyze_condition_extremity():
+            """評估各條件的極端程度及其影響"""
             extremities = {}
             
-            # 運動時間極端度評估
-            if user_prefs.exercise_time < 30:
-                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'] = ('very_high', 0.9)
-            elif user_prefs.exercise_time > 120:
-                extremities['exercise'] = ('high', 0.7)
-            else:
-                extremities['exercise'] = ('moderate', 0.3)
-                
-            # 空間限制極端度評估
-            if user_prefs.living_space == 'apartment':
-                extremities['space'] = ('very_restricted', 0.9)
-            elif user_prefs.living_space == 'house_small':
-                extremities['space'] = ('restricted', 0.6)
-            else:
-                extremities['space'] = ('spacious', 0.3)
-                
-            return extremities
-            
-        extremities = calculate_condition_extremity()
-        
-        # 權重調整
-        weight_adjustments = {}
-        
-        # 空間權重調整
-        if extremities['space'][0] == 'very_restricted':
-            weight_adjustments['space'] = 3.0
-            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 ['very_low', 'very_high']:
-            weight_adjustments['exercise'] = 3.0
-        elif extremities['exercise'][0] in ['low', 'high']:
-            weight_adjustments['exercise'] = 2.0
+            # 運動時間極端度分析
+            def analyze_exercise_extremity():
+                if user_prefs.exercise_time <= 30:
+                    return ('extremely_low', 0.9)
+                elif user_prefs.exercise_time <= 60:
+                    return ('low', 0.7)
+                elif user_prefs.exercise_time >= 180:
+                    return ('extremely_high', 0.9)
+                elif user_prefs.exercise_time >= 120:
+                    return ('high', 0.7)
+                return ('moderate', 0.4)
+    
+            # 空間限制極端度分析
+            def analyze_space_extremity():
+                space_extremity = {
+                    'apartment': ('highly_restricted', 0.9),
+                    'house_small': ('restricted', 0.6),
+                    'house_large': ('spacious', 0.4)
+                }
+                return space_extremity.get(user_prefs.living_space, ('moderate', 0.5))
+    
+            # 經驗水平極端度分析
+            def analyze_experience_extremity():
+                experience_extremity = {
+                    'beginner': ('low', 0.8),
+                    'intermediate': ('moderate', 0.5),
+                    'advanced': ('high', 0.7)
+                }
+                return experience_extremity.get(user_prefs.experience_level, ('moderate', 0.5))
+    
+            # 整合各項極端度評估
+            extremities['exercise'] = analyze_exercise_extremity()
+            extremities['space'] = analyze_space_extremity()
+            extremities['experience'] = analyze_experience_extremity()
             
-        # 經驗需求權重調整
-        if user_prefs.experience_level == 'beginner':
-            weight_adjustments['experience'] = 2.5
-        elif user_prefs.experience_level == 'advanced':
-            weight_adjustments['experience'] = 2.0
+            return extremities
+    
+        def calculate_weight_adjustments(extremities):
+            """根據條件極端度計算權重調整"""
+            adjustments = {}
             
+            # 空間權重調整邏輯
+            if extremities['space'][0] == 'highly_restricted':
+                adjustments['space'] = 2.5
+                adjustments['noise'] = 2.0
+            elif extremities['space'][0] == 'restricted':
+                adjustments['space'] = 1.8
+                adjustments['noise'] = 1.5
+            elif extremities['space'][0] == 'spacious':
+                adjustments['space'] = 0.8    # 降低空間權重
+                adjustments['exercise'] = 1.4  # 提升運動重要性
+                
+            # 運動需求權重調整
+            if extremities['exercise'][0] in ['extremely_low', 'extremely_high']:
+                adjustments['exercise'] = 2.5
+            elif extremities['exercise'][0] in ['low', 'high']:
+                adjustments['exercise'] = 1.8
+                
+            # 經驗需求權重調整
+            if extremities['experience'][0] == 'low':
+                adjustments['experience'] = 2.2
+                if breed_info.get('Care Level') == 'HIGH':
+                    adjustments['experience'] = 2.5
+            elif extremities['experience'][0] == 'high':
+                adjustments['experience'] = 1.8
+                
+            # 綜合條件影響
+            def adjust_for_combinations():
+                # 公寓 + 高運動需求
+                if (extremities['space'][0] == 'highly_restricted' and 
+                    extremities['exercise'][0] in ['high', 'extremely_high']):
+                    adjustments['space'] = adjustments.get('space', 1.0) * 1.3
+                    adjustments['exercise'] = adjustments.get('exercise', 1.0) * 1.3
+                    
+                # 新手 + 大空間 + 高運動量
+                if (extremities['experience'][0] == 'low' and 
+                    extremities['space'][0] == 'spacious' and
+                    extremities['exercise'][0] in ['high', 'extremely_high']):
+                    adjustments['experience'] = adjustments.get('experience', 1.0) * 1.4
+                    
+                # 空間充足時降低其權重
+                if extremities['space'][0] == 'spacious':
+                    for key in ['grooming', 'health', 'noise']:
+                        if key not in adjustments:
+                            adjustments[key] = 1.2
+                            
+            adjust_for_combinations()
+            return adjustments
+    
+        # 獲取條件極端度
+        extremities = analyze_condition_extremity()
+        
+        # 計算權重調整
+        weight_adjustments = calculate_weight_adjustments(extremities)
+        
         # 應用權重調整
         final_weights = base_weights.copy()
         for key, adjustment in weight_adjustments.items():
-            final_weights[key] *= adjustment
-            
+            if key in final_weights:
+                final_weights[key] *= adjustment
+                
         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
-            if breed_info['Size'] in ['Large', 'Giant']:
-                severity *= 0.5
+        """
+        處理特殊情況的分數調整，著重：
+        1. 條件組合的協同效應
+        2. 品種特性的特殊要求
+        3. 極端情況的嚴格處理
+        """
+        severity_multiplier = 1.0
+        
+        def evaluate_spatial_exercise_combination():
+            """評估空間與運動需求的組合影響"""
+            multiplier = 1.0
+            
+            if user_prefs.living_space == 'apartment':
+                if breed_info.get('Exercise Needs', 'MODERATE').upper() == 'VERY HIGH':
+                    multiplier *= 0.5
+                elif breed_info.get('Exercise Needs') == 'HIGH':
+                    multiplier *= 0.6
                 
-        # 經驗與品種難度組合的嚴格評估
-        if user_prefs.experience_level == 'beginner':
-            if breed_info.get('Care Level') == 'HIGH':
-                if user_prefs.has_children:
-                    severity *= 0.5
-                else:
-                    severity *= 0.6
+                # 大型犬在公寓的額外懲罰
+                if breed_info['Size'] in ['Large', 'Giant']:
+                    multiplier *= 0.5
+            
+            return multiplier
+        
+        def evaluate_experience_combination():
+            """評估經驗需求的複合影響"""
+            multiplier = 1.0
+            temperament = breed_info.get('Temperament', '').lower()
+            care_level = breed_info.get('Care Level', 'MODERATE')
+            
+            # 新手飼主的特殊考量
+            if user_prefs.experience_level == 'beginner':
+                # 高難度品種的嚴格限制
+                if care_level == 'HIGH':
+                    if user_prefs.has_children:
+                        multiplier *= 0.5
+                    else:
+                        multiplier *= 0.6
+                        
+                # 特殊性格特徵的影響
+                challenging_traits = ['independent', 'dominant', 'protective', 'strong-willed']
+                trait_count = sum(1 for trait in challenging_traits if trait in temperament)
+                if trait_count > 0:
+                    multiplier *= (0.8 ** trait_count)
                     
-        # 時間限制與需求組合的嚴格評估
-        if user_prefs.time_availability == 'limited':
-            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
+            # 進階飼主的特殊考量
+            elif user_prefs.experience_level == 'advanced':
+                if care_level == 'LOW' and breed_info.get('Exercise Needs') == 'LOW':
+                    multiplier *= 0.9  # 對專家來說可能過於簡單
+                    
+            return multiplier
+        
+        def evaluate_breed_specific_requirements():
+            """評估品種特定的要求"""
+            multiplier = 1.0
+            exercise_time = user_prefs.exercise_time
+            exercise_type = user_prefs.exercise_type
+            
+            # 特定品種的運動模式評估
+            if 'sprint' in breed_info.get('Temperament', '').lower():
+                if exercise_time > 120 and exercise_type != 'active_training':
+                    multiplier *= 0.7  # 衝刺型品種不適合長時間中低強度運動
+                    
+            # 工作犬種的特殊需求
+            if any(trait in breed_info.get('Temperament', '').lower() 
+                   for trait in ['working', 'herding']):
+                if exercise_time < 90 or exercise_type == 'light_walks':
+                    multiplier *= 0.7
+                    
+            return multiplier
+        
+        def evaluate_environmental_impact():
+            """評估環境因素的影響"""
+            multiplier = 1.0
+            
+            # 時間限制的影響
+            if user_prefs.time_availability == 'limited':
+                if breed_info.get('Exercise Needs').upper() in ['VERY HIGH', 'HIGH']:
+                    multiplier *= 0.7
+                    
+            # 噪音敏感度的影響
+            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':
+                        multiplier *= 0.6
+                        
+            return multiplier
+    
+        # 整合所有特殊情況的評估
+        severity_multiplier *= evaluate_spatial_exercise_combination()
+        severity_multiplier *= evaluate_experience_combination()
+        severity_multiplier *= evaluate_breed_specific_requirements()
+        severity_multiplier *= evaluate_environmental_impact()
+        
+        # 確保最終分數在合理範圍內
+        final_score = score * severity_multiplier
+        return max(0.2, min(1.0, final_score))
 
     # 評估完美匹配條件
     perfect_conditions = evaluate_perfect_conditions()
@@ -1851,30 +2046,32 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
     # 計算動態權重
     weights = calculate_weights()
     
-    # 正規化權重
+    # 正規化權重確保總和為1
     total_weight = sum(weights.values())
     normalized_weights = {k: v/total_weight for k, v in weights.items()}
     
     # 計算基礎分數
     base_score = sum(scores[k] * normalized_weights[k] for k in scores.keys())
     
-    # 完美匹配獎勵計算（降低獎勵影響）
+    # 計算完美匹配獎勵（降低獎勵影響以避免過高分數）
     perfect_bonus = 1.0
-    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']
+    perfect_bonus += 0.10 * perfect_conditions['size_match']      # 降低單項獎勵
+    perfect_bonus += 0.10 * perfect_conditions['exercise_match']
+    perfect_bonus += 0.10 * perfect_conditions['experience_match']
+    perfect_bonus += 0.05 * perfect_conditions['living_condition_match']
+    perfect_bonus += 0.05 * perfect_conditions['breed_trait_match']  # 新增品種特性獎勵
     
-    # 品種特性加成
-    breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+    # 計算品種特性加成（使用更嚴格的係數）
+    breed_bonus = calculate_breed_bonus(breed_info, user_prefs) * 0.15  # 降低品種加成的影響
     
-    # 計算最終分數
-    final_score = (base_score * 0.85 + breed_bonus * 0.15) * perfect_bonus
+    # 計算初步分數
+    initial_score = (base_score * 0.85 + breed_bonus * 0.15) * perfect_bonus
     
     # 應用特殊情況調整
-    final_score = apply_special_case_adjustments(final_score)
+    final_score = apply_special_case_adjustments(initial_score)
     
-    return min(1.0, final_score)
+    # 確保最終分數在有效範圍內
+    return min(1.0, max(0.3, final_score))
     
 
 def amplify_score_extreme(score: float) -> float: