Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1642,101 +1642,167 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         
         # 第一部分：運動需求評估
         def evaluate_exercise_compatibility():
+            """
+            評估運動需求的匹配度，特別關注：
+            1. 時間與強度的合理搭配
+            2. 不同品種的運動特性
+            3. 運動類型的適配性
+            
+            這個函數就像是一個體育教練，需要根據每個"運動員"(狗品種)的特點，
+            為他們制定合適的訓練計劃。
+            """
             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()
             description = breed_info.get('Description', '').lower()
-    
-            # 定義更細緻的品種運動特性
+        
+            # 定義更精確的品種運動特性
             breed_exercise_patterns = {
-                'sprint_type': {  # 如 Whippet, Saluki
-                    'identifiers': ['fast', 'speed', 'sprint', 'racing', 'coursing'],
+                'sprint_type': {  # 短跑型犬種，如 Whippet, Saluki
+                    'identifiers': ['fast', 'speed', 'sprint', 'racing', 'coursing', 'sight hound'],
                     'ideal_exercise': {
-                        'active_training': 1.0,    # 適合高強度訓練
-                        'moderate_activity': 0.6,   # 不太適合持續運動
-                        'light_walks': 0.4         # 不適合純散步
+                        'active_training': 1.0,     # 完美匹配高強度訓練
+                        'moderate_activity': 0.5,    # 持續運動不是最佳選擇
+                        'light_walks': 0.3          # 輕度運動效果很差
                     },
                     'time_ranges': {
-                        'ideal': (30, 90),         # 理想運動時間
-                        'acceptable': (20, 120)     # 可接受範圍
-                    }
+                        'ideal': (30, 60),          # 最適合的運動時間範圍
+                        'acceptable': (20, 90),      # 可以接受的時間範圍
+                        'penalty_start': 90         # 開始給予懲罰的時間點
+                    },
+                    'penalty_rate': 0.8            # 超出範圍時的懲罰係數
                 },
-                'endurance_type': {  # 如 Border Collie, German Shepherd
-                    'identifiers': ['herding', 'working', 'tireless', 'energetic', 'stamina'],
+                'endurance_type': {  # 耐力型犬種，如 Border Collie
+                    'identifiers': ['herding', 'working', 'tireless', 'energetic', 'stamina', 'athletic'],
                     'ideal_exercise': {
-                        'active_training': 0.9,    # 適合高強度訓練
-                        'moderate_activity': 1.0,   # 最適合持續運動
-                        'light_walks': 0.5         # 不適合純散步
+                        'active_training': 0.9,     # 高強度訓練很好
+                        'moderate_activity': 1.0,    # 持續運動是最佳選擇
+                        'light_walks': 0.4          # 輕度運動不足
                     },
                     'time_ranges': {
-                        'ideal': (90, 180),        # 理想運動時間
-                        'acceptable': (60, 240)     # 可接受範圍
-                    }
+                        'ideal': (90, 180),         # 需要較長的運動時間
+                        'acceptable': (60, 180),
+                        'penalty_start': 60         # 運動時間過短會受罰
+                    },
+                    'penalty_rate': 0.7
                 },
-                'moderate_type': {  # 如 Labrador, Golden Retriever
-                    'identifiers': ['friendly', 'playful', 'adaptable', 'versatile'],
+                'moderate_type': {  # 一般活動型犬種，如 Labrador
+                    'identifiers': ['friendly', 'playful', 'adaptable', 'versatile', 'companion'],
                     'ideal_exercise': {
                         'active_training': 0.8,
                         'moderate_activity': 1.0,
-                        'light_walks': 0.7
+                        'light_walks': 0.6
                     },
                     'time_ranges': {
                         'ideal': (60, 120),
-                        'acceptable': (45, 180)
-                    }
+                        'acceptable': (45, 150),
+                        'penalty_start': 150
+                    },
+                    'penalty_rate': 0.6
                 }
             }
-    
-            # 判斷品種的運動類型
+        
             def determine_breed_type():
+                """
+                根據品種的描述和性格特徵判斷其運動類型。
+                就像體育教練要��了解運動員的特點才能制定訓練計劃。
+                """
+                # 優先檢查特殊運動類型的標識符
                 for breed_type, pattern in breed_exercise_patterns.items():
                     if any(identifier in temperament or identifier in description 
                           for identifier in pattern['identifiers']):
                         return breed_type
-                return 'moderate_type'  # 預設類型
-    
-            breed_type = determine_breed_type()
-            pattern = breed_exercise_patterns[breed_type]
-    
-            # 計算時間匹配度
-            def calculate_time_match():
+                
+                # 如果沒有特殊標識，根據運動需求級別判斷
+                if exercise_needs in ['VERY HIGH', 'HIGH']:
+                    return 'endurance_type'
+                elif exercise_needs == 'LOW':
+                    return 'moderate_type'
+                
+                return 'moderate_type'
+        
+            def calculate_time_match(pattern):
+                """
+                計算運動時間的匹配度。
+                這就像在判斷運動時間是否符合訓練計劃。
+                """
                 ideal_min, ideal_max = pattern['time_ranges']['ideal']
                 accept_min, accept_max = pattern['time_ranges']['acceptable']
+                penalty_start = pattern['time_ranges']['penalty_start']
                 
+                # 在理想範圍內
                 if ideal_min <= exercise_time <= ideal_max:
                     return 1.0
+                    
+                # 超出可接受範圍的嚴格懲罰
                 elif exercise_time < accept_min:
-                    return max(0.3, 1 - ((accept_min - exercise_time) / accept_min))
+                    deficit = accept_min - exercise_time
+                    return max(0.2, 1 - (deficit / accept_min) * 1.2)
                 elif exercise_time > accept_max:
-                    return max(0.3, 1 - ((exercise_time - accept_max) / accept_max))
+                    excess = exercise_time - penalty_start
+                    penalty = min(0.8, (excess / penalty_start) * pattern['penalty_rate'])
+                    return max(0.2, 1 - penalty)
+                    
+                # 在可接受範圍但不在理想範圍
                 else:
-                    # 在可接受範圍內，但不在理想範圍
                     if exercise_time < ideal_min:
-                        return 0.7 + (0.3 * (exercise_time - accept_min) / (ideal_min - accept_min))
+                        progress = (exercise_time - accept_min) / (ideal_min - accept_min)
+                        return 0.6 + (0.4 * progress)
                     else:
-                        return 0.7 + (0.3 * (accept_max - exercise_time) / (accept_max - ideal_max))
-    
-            # 計算運動類型匹配度
-            type_score = pattern['ideal_exercise'].get(exercise_type, 0.5)
-    
-            # 特殊情況處理
-            def apply_special_adjustments(time_score, type_score):
+                        remaining = (accept_max - exercise_time) / (accept_max - ideal_max)
+                        return 0.6 + (0.4 * remaining)
+        
+            def apply_special_adjustments(time_score, type_score, breed_type, pattern):
+                """
+                處理特殊情況，確保運動方式真正符合品種需求。
+                就像確保訓練計劃不會違背運動員的特點。
+                """
+                # 短跑型品種的特殊處理
                 if breed_type == 'sprint_type':
-                    if exercise_time > pattern['time_ranges']['acceptable'][1]:
-                        return (time_score * 0.5, type_score * 0.6)
-                        
-                if breed_type == 'endurance_type':
-                    if exercise_time < pattern['time_ranges']['ideal'][0]:
-                        return (time_score * 0.6, type_score * 0.7)
+                    if exercise_time > pattern['time_ranges']['penalty_start']:
+                        # 時間過長的嚴重懲罰
+                        time_score *= 0.5
+                        # 如果同時運動類型不適合，更嚴重的懲罰
+                        if exercise_type != 'active_training':
+                            type_score *= 0.4
+                            
+                # 耐力型品種的特殊處理
+                elif breed_type == 'endurance_type':
+                    if exercise_time < pattern['time_ranges']['penalty_start']:
+                        time_score *= 0.6
+                    # 運動強度不足的懲罰
+                    if exercise_type == 'light_walks' and exercise_time > 90:
+                        type_score *= 0.5
                         
-                return (time_score, type_score)
-    
-            time_score = calculate_time_match()
-            time_score, type_score = apply_special_adjustments(time_score, type_score)
-    
-            # 最終運動匹配度計算
-            return (time_score * 0.6) + (type_score * 0.4)
+                return time_score, type_score
+        
+            # 執行評估流程
+            breed_type = determine_breed_type()
+            pattern = breed_exercise_patterns[breed_type]
+            
+            # 計算基礎分數
+            time_score = calculate_time_match(pattern)
+            type_score = pattern['ideal_exercise'].get(exercise_type, 0.5)
+            
+            # 應用特殊調整
+            time_score, type_score = apply_special_adjustments(time_score, type_score, breed_type, pattern)
+            
+            # 根據品種類型決定最終權重
+            if breed_type == 'sprint_type':
+                if exercise_time > pattern['time_ranges']['penalty_start']:
+                    # 超時時更重視運動類型的匹配度
+                    return (time_score * 0.3) + (type_score * 0.7)
+                else:
+                    return (time_score * 0.5) + (type_score * 0.5)
+            elif breed_type == 'endurance_type':
+                if exercise_time < pattern['time_ranges']['penalty_start']:
+                    # 時間不足時更重視時間因素
+                    return (time_score * 0.7) + (type_score * 0.3)
+                else:
+                    return (time_score * 0.6) + (type_score * 0.4)
+            else:
+                return (time_score * 0.5) + (type_score * 0.5)
     
         # 第二部分：專業技能需求評估
         def evaluate_expertise_requirements():