Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -632,21 +632,26 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
 
         def calculate_exercise_score(breed_needs: str, exercise_time: int, exercise_type: str) -> float:
             """
-            精確評估品種運動需求與使用者運動條件的匹配度
-            1. 擴大分數範圍到 0.1-1.0
-            2. 加強運動類型影響
-            3. 考慮運動強度與時間的綜合效果
-            4. 更細緻的時間匹配評估
+            計算品種運動需求與使用者運動條件的匹配度。此函數特別著重：
+            1. 不同品種的運動耐受度差異
+            2. 運動時間與類型的匹配度
+            3. 極端運動量的嚴格限制
+            
+            Parameters:
+            breed_needs: 品種的運動需求等級
+            exercise_time: 使用者計劃的運動時間（分鐘）
+            exercise_type: 運動類型（輕度/中度/高度）
+            
+            Returns:
+            float: 0.1到1.0之間的匹配分數
             """
+            # 定義每個運動需求等級的具體參數
             exercise_levels = {
                 'VERY HIGH': {
-                    'min': 120,
-                    'ideal': 150,
-                    'max': 180,
-                    'intensity': 'high',
-                    'sessions': 'multiple',
-                    'preferred_types': ['active_training', 'intensive_exercise'],
-                    'type_weights': {
+                    'min': 120,          # 最低需求
+                    'ideal': 150,        # 理想運動量
+                    'max': 180,          # 最大建議量
+                    'type_weights': {    # 不同運動類型的權重
                         'active_training': 1.0,
                         'moderate_activity': 0.6,
                         'light_walks': 0.3
@@ -656,61 +661,26 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     'min': 90,
                     'ideal': 120,
                     'max': 150,
-                    'intensity': 'moderate_high',
-                    'sessions': 'multiple',
-                    'preferred_types': ['active_training', 'moderate_activity'],
                     'type_weights': {
                         'active_training': 0.9,
                         'moderate_activity': 0.8,
                         'light_walks': 0.4
                     }
                 },
-                'MODERATE HIGH': {
-                    'min': 70,
-                    'ideal': 90,
-                    'max': 120,
-                    'intensity': 'moderate',
-                    'sessions': 'flexible',
-                    'preferred_types': ['moderate_activity', 'active_training'],
-                    'type_weights': {
-                        'active_training': 0.8,
-                        'moderate_activity': 0.9,
-                        'light_walks': 0.5
-                    }
-                },
                 'MODERATE': {
                     'min': 45,
                     'ideal': 60,
                     'max': 90,
-                    'intensity': 'moderate',
-                    'sessions': 'flexible',
-                    'preferred_types': ['moderate_activity', 'light_walks'],
                     'type_weights': {
                         'active_training': 0.7,
                         'moderate_activity': 1.0,
                         'light_walks': 0.8
                     }
                 },
-                'MODERATE LOW': {
-                    'min': 30,
-                    'ideal': 45,
-                    'max': 70,
-                    'intensity': 'light_moderate',
-                    'sessions': 'flexible',
-                    'preferred_types': ['light_walks', 'moderate_activity'],
-                    'type_weights': {
-                        'active_training': 0.6,
-                        'moderate_activity': 0.9,
-                        'light_walks': 1.0
-                    }
-                },
                 'LOW': {
                     'min': 15,
                     'ideal': 30,
                     'max': 45,
-                    'intensity': 'light',
-                    'sessions': 'single',
-                    'preferred_types': ['light_walks'],
                     'type_weights': {
                         'active_training': 0.5,
                         'moderate_activity': 0.8,
@@ -719,51 +689,70 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                 }
             }
         
+            # 獲取品種的運動參數
             breed_level = exercise_levels.get(breed_needs.upper(), exercise_levels['MODERATE'])
             
-            # 時間匹配度評估（基礎分數）
+            # 計算時間匹配度
             def calculate_time_score():
-                if exercise_time >= breed_level['ideal']:
-                    if exercise_time > breed_level['max']:
-                        excess = (exercise_time - breed_level['max']) / breed_level['max']
-                        bonus = min(0.15, excess * 0.3)
-                        return min(1.0, 1.0 + bonus)
-                    return 1.0  # 理想範圍內給予滿分
-                elif exercise_time >= breed_level['min']:
-                    # 在最小值和理想值之間使用更陡峭的曲線
+                """計算運動時間的匹配度，特別處理過度運動的情況"""
+                if exercise_time < breed_level['min']:
+                    # 運動不足的嚴格懲罰
+                    deficit_ratio = exercise_time / breed_level['min']
+                    return max(0.1, deficit_ratio * 0.4)
+                
+                elif exercise_time <= breed_level['ideal']:
+                    # 理想範圍內的漸進提升
                     progress = (exercise_time - breed_level['min']) / (breed_level['ideal'] - breed_level['min'])
-                    return 0.5 + (progress * 0.5)
+                    return 0.6 + (progress * 0.4)
+                
+                elif exercise_time <= breed_level['max']:
+                    # 理想到最大範圍的平緩下降
+                    excess_ratio = (exercise_time - breed_level['ideal']) / (breed_level['max'] - breed_level['ideal'])
+                    return 1.0 - (excess_ratio * 0.2)
+                
                 else:
-                    # 低於最小值時給予更嚴厲的懲罰
-                    deficit_ratio = exercise_time / breed_level['min']
-                    return max(0.1, deficit_ratio * 0.5)
+                    # 過度運動的顯著懲罰
+                    excess = (exercise_time - breed_level['max']) / breed_level['max']
+                    # 低運動需求品種的過度運動懲罰更嚴重
+                    penalty_factor = 1.5 if breed_needs.upper() == 'LOW' else 1.0
+                    return max(0.1, 0.8 - (excess * 0.5 * penalty_factor))
         
-            # 運動類型匹配度評估
+            # 計算運動類型匹配度
             def calculate_type_score():
-                type_weight = breed_level['type_weights'].get(exercise_type, 0.5)
-                
-                # 根據運動需求等級調整類型權重
-                if breed_needs.upper() in ['VERY HIGH', 'HIGH']:
-                    if exercise_type == 'light_walks':
-                        type_weight *= 0.5  # 高需求品種做輕度運動的懲罰
-                elif breed_needs.upper() == 'LOW':
-                    if exercise_type == 'active_training':
-                        type_weight *= 0.7  # 低需求品種做高強度運動的輕微懲罰
+                """評估運動類型的適合度，考慮品種特性"""
+                base_type_score = breed_level['type_weights'].get(exercise_type, 0.5)
                 
-                return type_weight
+                # 特殊情況處理
+                if breed_needs.upper() == 'LOW' and exercise_type == 'active_training':
+                    # 低運動需求品種不適合高強度運動
+                    base_type_score *= 0.5
+                elif breed_needs.upper() == 'VERY HIGH' and exercise_type == 'light_walks':
+                    # 高運動需求品種需要更多強度
+                    base_type_score *= 0.6
+                    
+                return base_type_score
         
             # 計算最終分數
             time_score = calculate_time_score()
             type_score = calculate_type_score()
             
-            # 綜合評分，運動時間佔70%，類型佔30%
-            final_score = (time_score * 0.7) + (type_score * 0.3)
-            
-            # 特殊情況調整
-            if exercise_time < breed_level['min'] * 0.5:  # 運動時間嚴重不足
+            # 根據運動需求等級調整權重
+            if breed_needs.upper() == 'LOW':
+                # 低運動需求品種更重視運動類型的合適性
+                final_score = (time_score * 0.6) + (type_score * 0.4)
+            elif breed_needs.upper() == 'VERY HIGH':
+                # 高運動需求品種更重視運動時間的充足性
+                final_score = (time_score * 0.7) + (type_score * 0.3)
+            else:
+                final_score = (time_score * 0.65) + (type_score * 0.35)
+        
+            # 極端情況的最終調整
+            if breed_needs.upper() == 'LOW' and exercise_time > breed_level['max'] * 2:
+                # 低運動需求品種的過度運動顯著降分
+                final_score *= 0.6
+            elif breed_needs.upper() == 'VERY HIGH' and exercise_time < breed_level['min'] * 0.5:
+                # 高運動需求品種運動嚴重不足降分
                 final_score *= 0.5
-            elif exercise_time > breed_level['max'] * 1.5:  # 運動時間過多
-                final_score *= 0.7
         
             return max(0.1, min(1.0, final_score))
 
@@ -1583,41 +1572,132 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
             return max(0.2, min(1.0, base_score - trait_penalty))
     
         # 第三部分：生活環境評估
-        def evaluate_living_conditions():
+        # def evaluate_living_conditions():
+        #     size = breed_info['Size']
+        #     exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+            
+        #     # 空間需求矩陣
+        #     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
+        #         }
+        #     }
+            
+        #     # 基礎空間分數
+        #     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
+        #     }
+        #     space_score *= yard_scores.get(user_prefs.yard_access, 0.8)
+    
+        #     return space_score
+
+        def evaluate_living_conditions() -> float:
+            """
+            評估生活環境適配性，特別加強：
+            1. 降低對大型犬的過度懲罰
+            2. 增加品種特性評估
+            3. 提升對適應性的重視度
+            """
             size = breed_info['Size']
             exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-            
-            # 空間需求矩陣
+            temperament = breed_info.get('Temperament', '').lower()
+            description = breed_info.get('Description', '').lower()
+        
+            # 重新定義空間需求矩陣，降低對大型犬的懲罰
             space_requirements = {
                 'apartment': {
-                    'Small': 1.0, 'Medium': 0.4, 'Large': 0.2, 'Giant': 0.1
+                    'Small': 1.0,
+                    'Medium': 0.7,    # 從0.4提升到0.7
+                    'Large': 0.6,     # 從0.2提升到0.6
+                    'Giant': 0.5      # 從0.1提升到0.5
                 },
                 'house_small': {
-                    'Small': 0.9, 'Medium': 1.0, 'Large': 0.5, 'Giant': 0.3
+                    'Small': 0.9,
+                    'Medium': 1.0,
+                    'Large': 0.8,     # 從0.5提升到0.8
+                    'Giant': 0.7      # 從0.3提升到0.7
                 },
                 'house_large': {
-                    'Small': 0.8, 'Medium': 0.9, 'Large': 1.0, 'Giant': 1.0
+                    'Small': 0.8,
+                    'Medium': 0.9,
+                    'Large': 1.0,
+                    'Giant': 1.0
                 }
             }
-            
+        
             # 基礎空間分數
-            space_score = space_requirements.get(user_prefs.living_space, 
-                                               space_requirements['house_small'])[size]
-    
-            # 活動空間需求調整
+            space_score = space_requirements.get(
+                user_prefs.living_space,
+                space_requirements['house_small']
+            )[size]
+        
+            # 品種適應性評估
+            adaptability_bonus = 0
+            adaptable_traits = ['adaptable', 'calm', 'quiet', 'gentle', 'laid-back']
+            challenging_traits = ['hyperactive', 'restless', 'requires space']
+        
+            # 計算適應性加分
+            if user_prefs.living_space == 'apartment':
+                for trait in adaptable_traits:
+                    if trait in temperament or trait in description:
+                        adaptability_bonus += 0.1
+                        
+                # 特別處理大型犬的適應性
+                if size in ['Large', 'Giant']:
+                    apartment_friendly_traits = ['calm', 'gentle', 'quiet']
+                    matched_traits = sum(1 for trait in apartment_friendly_traits 
+                                       if trait in temperament or trait in description)
+                    if matched_traits > 0:
+                        adaptability_bonus += 0.15 * matched_traits
+        
+            # 活動空間需求調整，更寬容的評估
             if exercise_needs in ['HIGH', 'VERY HIGH']:
                 if user_prefs.living_space != 'house_large':
-                    space_score *= 0.8
-    
-            # 院子可用性評估
+                    space_score *= 0.9  # 從0.8提升到0.9，降低懲罰
+            
+            # 院子可用性評估，提供更合理的獎勵
             yard_scores = {
-                'no_yard': 0.7,
-                'shared_yard': 0.85,
+                'no_yard': 0.85,      # 從0.7提升到0.85
+                'shared_yard': 0.92,  # 從0.85提升到0.92
                 'private_yard': 1.0
             }
-            space_score *= yard_scores.get(user_prefs.yard_access, 0.8)
-    
-            return space_score
+            yard_multiplier = yard_scores.get(user_prefs.yard_access, 0.85)
+            
+            # 根據體型調整院子重要性
+            if size in ['Large', 'Giant']:
+                yard_importance = 1.2
+            elif size == 'Medium':
+                yard_importance = 1.1
+            else:
+                yard_importance = 1.0
+        
+            # 計算最終分數
+            final_score = space_score * (1 + adaptability_bonus)
+            
+            # 應用院子影響
+            if user_prefs.yard_access != 'no_yard':
+                yard_bonus = (yard_multiplier - 1) * yard_importance
+                final_score = min(1.0, final_score + yard_bonus)
+        
+            # 確保分數在合理範圍內，但提供更高的基礎分數
+            return max(0.4, min(1.0, final_score))
     
         # 第四部分：品種特性評估
         def evaluate_breed_traits():
@@ -1653,63 +1733,135 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
     
         return perfect_matches
 
-    def calculate_weights():
+    def calculate_weights() -> dict:
         """
-        1. 條件極端度對權重的影響
-        2. 多重條件組合的權重調整
-        3. 品種特性對權重分配的影響
+        動態計算評分權重，特別關注：
+        1. 極端情況的權重調整
+        2. 使用者條件的協同效應
+        3. 品種特性的影響
+        
+        Returns:
+            dict: 包含各評分項目權重的字典
         """
-        # 基礎權重設定
+        # 定義基礎權重 - 提供更合理的起始分配
         base_weights = {
-            'space': 0.20,
-            'exercise': 0.20,
-            'experience': 0.20,
-            'grooming': 0.15,
-            'noise': 0.15,
-            'health': 0.10
+            'space': 0.25,        # 提升空間權重，因為這是最基本的需求
+            'exercise': 0.25,     # 運動需求同樣重要
+            'experience': 0.20,   # 保持經驗的重要性
+            'grooming': 0.10,     # 稍微降低美容需求的權重
+            'noise': 0.10,        # 維持噪音評估的權重
+            'health': 0.10        # 維持健康評估的權重
         }
-        
-        def analyze_condition_extremity():
-            """評估各條件的極端程度及其影響"""
+    
+        def analyze_condition_extremity() -> dict:
+            """
+            評估使用者條件的極端程度，這影響權重的動態調整。
+            根據條件的極端程度返回相應的調整建議。
+            """
             extremities = {}
-            
-            # 運動時間極端度分析
-            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.exercise_time <= 30:
+                extremities['exercise'] = ('extremely_low', 0.8)
+            elif user_prefs.exercise_time <= 60:
+                extremities['exercise'] = ('low', 0.6)
+            elif user_prefs.exercise_time >= 180:
+                extremities['exercise'] = ('extremely_high', 0.8)
+            elif user_prefs.exercise_time >= 120:
+                extremities['exercise'] = ('high', 0.6)
+            else:
+                extremities['exercise'] = ('moderate', 0.3)
+    
+            # 空間限制評估 - 更合理的空間評估
+            space_extremity = {
+                'apartment': ('restricted', 0.7),    # 從0.9降低到0.7，減少限制
+                'house_small': ('moderate', 0.5),
+                'house_large': ('spacious', 0.3)
+            }
+            extremities['space'] = space_extremity.get(user_prefs.living_space, ('moderate', 0.5))
+    
+            # 經驗水平評估 - 保持原有的評估邏輯
+            experience_extremity = {
+                'beginner': ('low', 0.7),
+                'intermediate': ('moderate', 0.4),
+                'advanced': ('high', 0.6)
+            }
+            extremities['experience'] = experience_extremity.get(user_prefs.experience_level, ('moderate', 0.5))
+    
             return extremities
     
+        def calculate_weight_adjustments(extremities: dict) -> dict:
+            """
+            根據極端程度計算權重調整，特別注意條件組合的影響。
+            """
+            adjustments = {}
+            temperament = breed_info.get('Temperament', '').lower()
+            is_working_dog = any(trait in temperament 
+                               for trait in ['herding', 'working', 'intelligent', 'tireless'])
+    
+            # 空間權重調整 - 更平衡的調整方式
+            if extremities['space'][0] == 'restricted':
+                if extremities['exercise'][0] in ['high', 'extremely_high']:
+                    adjustments['space'] = 1.5       # 從1.8降低到1.5
+                    adjustments['exercise'] = 1.8    # 從2.5降低到1.8
+                else:
+                    adjustments['space'] = 1.6       # 從2.5降低到1.6
+                    adjustments['noise'] = 1.5       # 保持合理的噪音權重
+    
+            # 運動需求權重調整 - 更合理的運動評估
+            if extremities['exercise'][0] in ['extremely_high', 'extremely_low']:
+                base_adjustment = 1.8                # 從2.5降低到1.8
+                if extremities['exercise'][0] == 'extremely_high':
+                    if is_working_dog:
+                        base_adjustment = 2.0        # 從3.0降低到2.0
+                adjustments['exercise'] = base_adjustment
+    
+            # 經驗需求權重調整 - 維持原有的評估邏輯
+            if extremities['experience'][0] == 'low':
+                adjustments['experience'] = 1.8
+                if breed_info.get('Care Level') == 'HIGH':
+                    adjustments['experience'] = 2.0
+            elif extremities['experience'][0] == 'high':
+                if is_working_dog:
+                    adjustments['experience'] = 1.8  # 從2.5降低到1.8
+    
+            # 特殊組合的處理
+            def adjust_for_combinations():
+                if (extremities['space'][0] == 'restricted' and 
+                    extremities['exercise'][0] in ['high', 'extremely_high']):
+                    # 適度降低極端組合的影響
+                    adjustments['space'] = adjustments.get('space', 1.0) * 1.2
+                    adjustments['exercise'] = adjustments.get('exercise', 1.0) * 1.2
+    
+                # 理想組合的獎勵
+                if (extremities['experience'][0] == 'high' and
+                    extremities['space'][0] == 'spacious' and
+                    extremities['exercise'][0] in ['high', 'extremely_high'] and
+                    is_working_dog):
+                    adjustments['exercise'] = adjustments.get('exercise', 1.0) * 1.3
+                    adjustments['experience'] = adjustments.get('experience', 1.0) * 1.3
+    
+            adjust_for_combinations()
+            return adjustments
+    
+        # 獲取條件極端度
+        extremities = analyze_condition_extremity()
+    
+        # 計算權重調整
+        weight_adjustments = calculate_weight_adjustments(extremities)
+    
+        # 應用權重調整，確保總和為1
+        final_weights = base_weights.copy()
+        for key, adjustment in weight_adjustments.items():
+            if key in final_weights:
+                final_weights[key] *= adjustment
+    
+        # 正規化權重
+        total_weight = sum(final_weights.values())
+        normalized_weights = {k: v/total_weight for k, v in final_weights.items()}
+    
+        return normalized_weights
+    
         def calculate_weight_adjustments(extremities):
             """
             1. 高運動量時對耐力型犬種的偏好
@@ -1812,150 +1964,264 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
                 
         return final_weights
 
-    def apply_special_case_adjustments(score):
+    def apply_special_case_adjustments(score: float) -> float:
         """
+        處理特殊情況和極端案例的評分調整。這個函數特別關注：
         1. 條件組合的協同效應
-        2. 品種特性的特殊要求
-        3. 極端情況的處理
+        2. 品種特性的獨特需求
+        3. 極端情況的合理處理
+        
+        這個函數就像是一個細心的裁判，會考慮到各種特殊情況，
+        並根據具體場景做出合理的評分調整。
+        
+        Parameters:
+            score: 初始評分
+        Returns:
+            float: 調整後的評分（0.2-1.0之間）
         """
         severity_multiplier = 1.0
-        
-        def evaluate_spatial_exercise_combination():
+    
+        def evaluate_spatial_exercise_combination() -> float:
             """
-            評估空間與運動需求的組合影響
-            修改重點：移除對高運動需求的懲罰,只保留體型相關評估
+            評估空間與運動需求的組合效應。
+            
+            這個函數不再過分懲罰大型犬，而是更多地考慮品種的實際特性。
+            就像評估一個運動員是否適合在特定場地訓練一樣，我們需要考慮
+            場地大小和運動需求的整體匹配度。
             """
             multiplier = 1.0
             
             if user_prefs.living_space == 'apartment':
-                # 移除運動需求相關的懲罰
+                temperament = breed_info.get('Temperament', '').lower()
+                description = breed_info.get('Description', '').lower()
+                
+                # 檢查品種是否有利於公寓生活的特徵
+                apartment_friendly = any(trait in temperament or trait in description
+                                      for trait in ['calm', 'adaptable', 'quiet'])
                 
-                # 只保留體型的基本評估,但降低懲罰程度
+                # 大型犬的特殊處理
                 if breed_info['Size'] in ['Large', 'Giant']:
-                    multiplier *= 0.7  # 從0.5提升到0.7,因為大型犬確實需要考慮空間限制
+                    if apartment_friendly:
+                        multiplier *= 0.85  # 從0.7提升到0.85，降低懲罰
+                    else:
+                        multiplier *= 0.75  # 從0.5提升到0.75
+                
+                # 檢查運動需求的匹配度
+                exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+                exercise_time = user_prefs.exercise_time
+                
+                if exercise_needs in ['HIGH', 'VERY HIGH']:
+                    if exercise_time >= 120:  # 高運動量可以部分補償空間限制
+                        multiplier *= 1.1
             
             return multiplier
-        
-        def evaluate_experience_combination():
-            """評估經驗需求的複合影響"""
+    
+        def evaluate_experience_combination() -> float:
+            """
+            評估經驗需求的複合影響。
+            
+            這個函數就像是評估一個工作崗位與應聘者經驗的匹配度，
+            需要綜合考慮工作難度和應聘者能力。
+            """
             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
+                        multiplier *= 0.7  # 從0.5提升到0.7
                     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)
-                    
-            # 進階飼主的特殊考量
-            elif user_prefs.experience_level == 'advanced':
-                if care_level == 'LOW' and breed_info.get('Exercise Needs') == 'LOW':
-                    multiplier *= 0.9  # 對專家來說可能過於簡單
-                    
+                        multiplier *= 0.8  # 從0.6提升到0.8
+                
+                # 性格特徵影響，降低懲罰程度
+                challenging_traits = {
+                    'stubborn': -0.10,      # 從-0.15降低
+                    'independent': -0.08,    # 從-0.12降低
+                    'dominant': -0.08,       # 從-0.12降低
+                    'protective': -0.06,     # 從-0.10降低
+                    'aggressive': -0.15      # 保持較高懲罰因安全考慮
+                }
+                
+                for trait, penalty in challenging_traits.items():
+                    if trait in temperament:
+                        multiplier *= (1 + penalty)
+            
             return multiplier
-        
-        def evaluate_breed_specific_requirements():
-            """評估品種特定的要求，加強運動需求的判斷"""
+    
+        def evaluate_breed_specific_requirements() -> float:
+            """
+            評估品種特定需求。
+            
+            這個函數就像是為每個品種量身定制評估標準，
+            考慮其獨特的特性和需求。
+            """
             multiplier = 1.0
             exercise_time = user_prefs.exercise_time
             exercise_type = user_prefs.exercise_type
             
-            # 檢查品種的基本特性
+            # 檢查品種特性
             temperament = breed_info.get('Temperament', '').lower()
             description = breed_info.get('Description', '').lower()
             exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
             
-            # 加強運動需求的匹配判斷
+            # 運動需求匹配度評估，更合理的標準
             if exercise_needs == 'LOW':
-                if exercise_time > 90:  # 如果用戶運動時間過長
-                    multiplier *= 0.5   # 給予更強的懲罰
+                if exercise_time > 120:
+                    multiplier *= 0.85  # 從0.5提升到0.85
             elif exercise_needs == 'VERY HIGH':
-                if exercise_time < 60:  # 如果用戶運動時間過短
-                    multiplier *= 0.5
-                    
+                if exercise_time < 60:
+                    multiplier *= 0.7   # 從0.5提升到0.7
+            
+            # 特殊品種類型的考慮
             if 'sprint' in temperament:
                 if exercise_time > 120 and exercise_type != 'active_training':
-                    multiplier *= 0.7
+                    multiplier *= 0.85  # 從0.7提升到0.85
                     
             if any(trait in temperament 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
+                    multiplier *= 0.8   # 從0.7提升到0.8
             
-            # 時間限制的影響
-            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()
+        # 計算各項調整
+        space_exercise_mult = evaluate_spatial_exercise_combination()
+        experience_mult = evaluate_experience_combination()
+        breed_specific_mult = evaluate_breed_specific_requirements()
         
-        # 確保最終分數在合理範圍內
+        # 整合所有調整因素
+        severity_multiplier *= space_exercise_mult
+        severity_multiplier *= experience_mult
+        severity_multiplier *= breed_specific_mult
+        
+        # 應用最終調整，確保分數在合理範圍內
         final_score = score * severity_multiplier
         return max(0.2, min(1.0, final_score))
 
     def calculate_base_score(scores: dict, weights: dict) -> float:
         """
-        計算基礎分數，更寬容地處理極端組合
-        """
-        # 進一步降低關鍵指標閾值，使系統更包容極端組合
-        critical_thresholds = {
-        'space': 0.45,     # 進一步降低閾值
-        'exercise': 0.45,
-        'experience': 0.55,
-        'noise': 0.55
-        }
+        計算基礎評分分數，採用更靈活的評分機制。
         
-        critical_failures = []
-        for metric, threshold in critical_thresholds.items():
-            if scores[metric] < threshold:
-                critical_failures.append((metric, scores[metric]))
+        這個函數使用了改進後的評分邏輯，主要關注：
+        1. 降低關鍵指標的最低門檻，使系統更包容
+        2. 引入非線性評分曲線，讓分數分布更合理
+        3. 優化多重條件失敗的處理方式
+        4. 加強對品種特性的考慮
         
-        base_score = sum(scores[k] * weights[k] for k in scores.keys())
+        Parameters:
+            scores: 包含各項評���的字典
+            weights: 包含各項權重的字典
         
+        Returns:
+            float: 0.2到1.0之間的基礎分數
+        """
+        # 重新定義關鍵指標閾值，提供更寬容的評分標準
+        critical_thresholds = {
+            'space': 0.4,       # 從0.45降低到0.4
+            'exercise': 0.4,    # 從0.45降低到0.4
+            'experience': 0.5,  # 從0.55降低到0.5
+            'noise': 0.5        # 保持不變，因為噪音確實是重要考慮因素
+        }
+    
+        # 評估關鍵指標失敗情況
+        def evaluate_critical_failures() -> list:
+            """
+            評估關鍵指標的失敗情況，但採用更寬容的標準。
+            根據品種特性動態調整失敗判定。
+            """
+            failures = []
+            temperament = breed_info.get('Temperament', '').lower()
+            
+            for metric, threshold in critical_thresholds.items():
+                if scores[metric] < threshold:
+                    # 特殊情況處理：適應性強的品種可以有更低的空間要求
+                    if metric == 'space' and any(trait in temperament 
+                       for trait in ['adaptable', 'calm', 'apartment']):
+                        if scores[metric] >= threshold - 0.1:
+                            continue
+                            
+                    # 運動需求的特殊處理
+                    elif metric == 'exercise':
+                        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+                        if exercise_needs == 'LOW' and scores[metric] >= threshold - 0.1:
+                            continue
+                            
+                    failures.append((metric, scores[metric]))
+            
+            return failures
+    
+        # 計算基礎分數
+        def calculate_weighted_score() -> float:
+            """
+            計算加權分數，使用非線性函數使分數分布更合理。
+            """
+            weighted_scores = []
+            for key, score in scores.items():
+                if key in weights:
+                    # 使用sigmoid函數使分數曲線更平滑
+                    adjusted_score = 1 / (1 + math.exp(-10 * (score - 0.5)))
+                    weighted_scores.append(adjusted_score * weights[key])
+            
+            return sum(weighted_scores)
+    
+        # 處理臨界失敗情況
+        critical_failures = evaluate_critical_failures()
+        base_score = calculate_weighted_score()
+    
         if critical_failures:
+            # 分離空間和運動相關的懲罰
             space_exercise_penalty = 0
             other_penalty = 0
             
             for metric, score in critical_failures:
                 if metric in ['space', 'exercise']:
-                    space_exercise_penalty += (critical_thresholds[metric] - score) * 0.15  # 降低懲罰
+                    # 降低空間和運動失敗的懲罰程度
+                    penalty = (critical_thresholds[metric] - score) * 0.12  # 從0.15降低到0.12
+                    space_exercise_penalty += penalty
                 else:
-                    other_penalty += (critical_thresholds[metric] - score) * 0.3
-            
+                    # 其他失敗的懲罰保持較高
+                    penalty = (critical_thresholds[metric] - score) * 0.25  # 從0.3降低到0.25
+                    other_penalty += penalty
+    
+            # 計算總懲罰，但使用更溫和的方式
             total_penalty = (space_exercise_penalty + other_penalty) / 2
             base_score *= (1 - total_penalty)
-            
+    
+            # 多重失敗的處理更寬容
             if len(critical_failures) > 1:
-                base_score *= (0.98 ** (len(critical_failures) - 1))  # 進一步降低多重失敗懲罰
-        
-        return base_score
+                # 從0.98提升到0.99，降低多重失敗的疊加懲罰
+                base_score *= (0.99 ** (len(critical_failures) - 1))
+    
+        # 品種特性加分
+        def apply_breed_bonus() -> float:
+            """
+            根據品種特性提供額外加分，
+            特別是對於在特定環境下表現良好的品種。
+            """
+            bonus = 0
+            temperament = breed_info.get('Temperament', '').lower()
+            description = breed_info.get('Description', '').lower()
+            
+            # 適應性加分
+            adaptability_traits = ['adaptable', 'versatile', 'easy-going']
+            if any(trait in temperament for trait in adaptability_traits):
+                bonus += 0.05
+                
+            # 公寓適應性加分
+            if user_prefs.living_space == 'apartment':
+                apartment_traits = ['calm', 'quiet', 'good for apartments']
+                if any(trait in temperament or trait in description for trait in apartment_traits):
+                    bonus += 0.05
+                    
+            return min(0.1, bonus)  # 限制最大加分
+    
+        # 應用品種特性加分
+        breed_bonus = apply_breed_bonus()
+        base_score = min(1.0, base_score * (1 + breed_bonus))
+    
+        # 確保最終分數在合理範圍內
+        return max(0.2, min(1.0, base_score))
 
   
     def evaluate_condition_interactions(scores: dict) -> float:
@@ -2056,27 +2322,148 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
     return min(max_possible_score, max(min_possible_score, final_score))
 
 def amplify_score_extreme(score: float) -> float:
-    """優化分數分布，提供更高的分數範圍"""
+    """
+    優化分數分布，提供更有意義的評分範圍。
+    
+    這個函數就像是一個分數校準器，它的作用類似於相機的色彩校準，
+    讓原始的分數分布能更好地反映實際的匹配程度。比如，一個90分的匹配
+    應該確實代表一個非常好的搭配，而不是一個僅僅"還可以"的選擇。
+    
+    我們使用分段函數和平滑曲線來實現這個目標：
+    - 90-100分代表極佳匹配（映射到96-100）
+    - 80-90分代表優秀匹配（映射到90-96）
+    - 70-80分代表良好匹配（映射到82-90）
+    - 50-70分代表可接受匹配（映射到75-82）
+    - 50分以下代表較差匹配（映射到70-75）
+    
+    Parameters:
+        score: 原始評分（0-1之間的浮點數）
+    
+    Returns:
+        float: 調整後的評分（0-1之間的浮點數）
+    """
     def smooth_curve(x: float, steepness: float = 12) -> float:
+        """
+        創建平滑的S型曲線用於分數轉換。
+        
+        這個函數使用sigmoid函數來產生平滑的轉換曲線，避免分數在
+        不同區間之間產生突兀的跳變。就像是在照片編輯中，我們會使用
+        漸變而不是突變來調整色調。
+        
+        Parameters:
+            x: 輸入值（0-1之間）
+            steepness: 曲線的陡峭程度，越大曲線越陡
+            
+        Returns:
+            float: 轉換後的值（0-1之間）
+        """
         import math
         return 1 / (1 + math.exp(-steepness * (x - 0.5)))
 
-    if score >= 0.9:
-        position = (score - 0.9) / 0.1
-        return 0.96 + (position * 0.04)  # 90-100的原始分映射到96-100
+    def apply_range_mapping(score: float) -> float:
+        """
+        將分數映射到新的範圍，並保持平滑過渡。
         
-    elif score >= 0.8:
-        position = (score - 0.8) / 0.1
-        return 0.90 + (position * 0.06)  # 80-90的原始分映射到90-96
+        這個函數負責將原始分數轉換到新的分數範圍。就像是將溫度從
+        攝氏度轉換到華氏度，但要保持溫度變化的連續性。
         
-    elif score >= 0.7:
-        position = (score - 0.7) / 0.1
-        return 0.82 + (position * 0.08)  # 70-80的原始分映射到82-90
+        Parameters:
+            score: 原始分數
+            
+        Returns:
+            float: 映射後的分數
+        """
+        # 極佳匹配區間（90-100）
+        if score >= 0.90:
+            # 計算在當前區間內的相對位置
+            position = (score - 0.90) / 0.10
+            # 映射到96-100的範圍
+            return 0.96 + (position * 0.04)
+            
+        # 優秀匹配區間（80-90）
+        elif score >= 0.80:
+            position = (score - 0.80) / 0.10
+            # 使用平滑曲線進行轉換
+            transition = smooth_curve(position)
+            return 0.90 + (transition * 0.06)
+            
+        # 良好匹配區間（70-80）
+        elif score >= 0.70:
+            position = (score - 0.70) / 0.10
+            # 加入輕微的非線性轉換
+            return 0.82 + (math.pow(position, 0.9) * 0.08)
+            
+        # 可接受匹配區間（50-70）
+        elif score >= 0.50:
+            position = (score - 0.50) / 0.20
+            # 使用更平緩的曲線
+            return 0.75 + (smooth_curve(position) * 0.07)
+            
+        # 較差匹配區間（50以下）
+        else:
+            position = score / 0.50
+            # 確保即使是較低分數也能得到基本分數
+            return 0.70 + (smooth_curve(position) * 0.05)
+
+    def apply_context_bonus(score: float) -> float:
+        """
+        根據具體情況添加額外的分數調整。
         
-    elif score >= 0.5:
-        position = (score - 0.5) / 0.2
-        return 0.75 + (smooth_curve(position) * 0.07)  # 50-70的原始分映射到75-82
+        這個函數考慮特定的場景來微調分數，就像是考試時會根據題目
+        的難度來調整給分標準。
         
-    else:
-        position = score / 0.5
-        return 0.70 + (smooth_curve(position) * 0.05)  # 50以下的原始分映射到70-75
+        Parameters:
+            score: 當前分數
+            
+        Returns:
+            float: 調整後的分數
+        """
+        bonus = 0
+        
+        # 特殊場景加分
+        temperament = breed_info.get('Temperament', '').lower()
+        if user_prefs.living_space == 'apartment':
+            if 'adaptable' in temperament and score > 0.85:
+                bonus += 0.02
+                
+        # 運動需求匹配度加分
+        if breed_info.get('Exercise Needs', 'MODERATE').upper() == 'LOW':
+            if user_prefs.exercise_time <= 60 and score > 0.85:
+                bonus += 0.01
+                
+        return min(1.0, score + bonus)
+
+    # 應用基本的範圍映射
+    adjusted_score = apply_range_mapping(score)
+    
+    # 應用情境相關的調整
+    final_score = apply_context_bonus(adjusted_score)
+    
+    # 確保分數在有效範圍內
+    return round(min(1.0, max(0.0, final_score)), 4)
+
+# def amplify_score_extreme(score: float) -> float:
+#     """優化分數分布，提供更高的分數範圍"""
+#     def smooth_curve(x: float, steepness: float = 12) -> float:
+#         import math
+#         return 1 / (1 + math.exp(-steepness * (x - 0.5)))
+
+#     if score >= 0.9:
+#         position = (score - 0.9) / 0.1
+#         return 0.96 + (position * 0.04)  # 90-100的原始分映射到96-100
+        
+#     elif score >= 0.8:
+#         position = (score - 0.8) / 0.1
+#         return 0.90 + (position * 0.06)  # 80-90的原始分映射到90-96
+        
+#     elif score >= 0.7:
+#         position = (score - 0.7) / 0.1
+#         return 0.82 + (position * 0.08)  # 70-80的原始分映射到82-90
+        
+#     elif score >= 0.5:
+#         position = (score - 0.5) / 0.2
+#         return 0.75 + (smooth_curve(position) * 0.07)  # 50-70的原始分映射到75-82
+        
+#     else:
+#         position = score / 0.5
+#         return 0.70 + (smooth_curve(position) * 0.05)  # 50以下的原始分映射到70-75