Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -143,6 +143,7 @@ def calculate_breed_bonus(breed_info: dict, user_prefs: UserPreferences) -> floa
     """
     bonus = 0.0
     temperament = breed_info.get('Temperament', '').lower()
+    description = breed_info.get('Description', '').lower()
     
     # 壽命評估 - 重新設計以反映更實際的考量
     try:
@@ -206,6 +207,47 @@ def calculate_breed_bonus(breed_info: dict, user_prefs: UserPreferences) -> floa
     
     bonus += max(-0.25, min(0.25, personality_score))
 
+      exercise_match = calculate_exercise_match(
+        breed_info.get('Exercise_Needs', 'MODERATE'),
+        user_prefs.exercise_time,
+        user_prefs.exercise_type
+    )
+    bonus += exercise_match
+    
+    # 運動類型特性評估
+    exercise_traits = {
+        'active_training': {
+            'athletic': 0.10,
+            'energetic': 0.08,
+            'working': 0.08,
+            'intelligent': 0.06
+        },
+        'moderate_activity': {
+            'adaptable': 0.08,
+            'balanced': 0.06,
+            'versatile': 0.06,
+            'steady': 0.04
+        },
+        'light_walks': {
+            'calm': 0.08,
+            'gentle': 0.06,
+            'easy-going': 0.06,
+            'patient': 0.04
+        }
+    }
+    
+    # 計算運動類型特性匹配度
+    if user_prefs.exercise_type in exercise_traits:
+        trait_score = 0
+        matched_traits = 0
+        for trait, value in exercise_traits[user_prefs.exercise_type].items():
+            if trait in temperament:
+                trait_score += value
+                matched_traits += 1
+        if matched_traits > 0:
+            bonus += min(0.15, trait_score * (1 + (matched_traits - 1) * 0.1))
+    
+
     # 適應性評估 - 根據具體環境給予更細緻的評分
     adaptability_bonus = 0.0
     if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
@@ -779,8 +821,20 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return min(0.95, max(0.15, current_score))
             
 
-        # def calculate_exercise_score(breed_needs: str, user_time: int) -> float:
-        #     """運動需求計算"""
+        # def calculate_exercise_score(breed_needs: str, exercise_time: int) -> float:
+        #     """
+        #     優化的運動需求評分系統
+            
+        #     Parameters:
+        #     breed_needs: str - 品種的運動需求等級
+        #     exercise_time: int - 使用者可提供的運動時間（分鐘）
+            
+        #     改進：
+        #     1. 更細緻的運動需求評估
+        #     2. 更合理的時間匹配計算
+        #     3. 避免極端評分
+        #     """
+        #     # 基礎運動需求評估
         #     exercise_needs = {
         #         'VERY HIGH': {'min': 120, 'ideal': 150, 'max': 180},
         #         'HIGH': {'min': 90, 'ideal': 120, 'max': 150},
@@ -791,57 +845,115 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             
         #     breed_need = exercise_needs.get(breed_needs.strip().upper(), exercise_needs['MODERATE'])
             
-        #     # 計算匹配度
-        #     if user_time >= breed_need['ideal']:
-        #         if user_time > breed_need['max']:
-        #             return 0.9  # 稍微降分，因為可能過度運動
-        #         return 1.0
-        #     elif user_time >= breed_need['min']:
-        #         return 0.8 + (user_time - breed_need['min']) / (breed_need['ideal'] - breed_need['min']) * 0.2
+        #     # 基礎時間匹配度計算
+        #     if exercise_time >= breed_need['ideal']:
+        #         if exercise_time > breed_need['max']:
+        #             # 運動時間過長，稍微降低分數
+        #             time_score = 0.9
+        #         else:
+        #             time_score = 1.0
+        #     elif exercise_time >= breed_need['min']:
+        #         # 在最小需求和理想需求之間，線性計算分數
+        #         time_score = 0.7 + (exercise_time - breed_need['min']) / (breed_need['ideal'] - breed_need['min']) * 0.3
         #     else:
-        #         return max(0.3, 0.8 * (user_time / breed_need['min']))
+        #         # 運動時間不足，但仍根據比例給予分數
+        #         time_score = max(0.3, 0.7 * (exercise_time / breed_need['min']))
+            
+        #     # 確保分數在合理範圍內
+        #     return min(1.0, max(0.3, time_score))
 
 
-        def calculate_exercise_score(breed_needs: str, exercise_time: int) -> float:
+        def calculate_exercise_match(breed_needs: str, exercise_time: int, exercise_type: str) -> float:
             """
-            優化的運動需求評分系統
+            精確評估品種運動需求與使用者運動條件的匹配度
             
             Parameters:
-            breed_needs: str - 品種的運動需求等級
-            exercise_time: int - 使用者可提供的運動時間（分鐘）
+            breed_needs: 品種的運動���求等級
+            exercise_time: 使用者能提供的運動時間（分鐘）
+            exercise_type: 使用者偏好的運動類型
             
-            改進：
-            1. 更細緻的運動需求評估
-            2. 更合理的時間匹配計算
-            3. 避免極端評分
+            Returns:
+            float: -0.2 到 0.2 之間的匹配分數
             """
-            # 基礎運動需求評估
-            exercise_needs = {
-                'VERY HIGH': {'min': 120, 'ideal': 150, 'max': 180},
-                'HIGH': {'min': 90, 'ideal': 120, 'max': 150},
-                'MODERATE': {'min': 45, 'ideal': 60, 'max': 90},
-                'LOW': {'min': 20, 'ideal': 30, 'max': 45},
-                'VARIES': {'min': 30, 'ideal': 60, 'max': 90}
+            # 定義更細緻的運動需求等級
+            exercise_levels = {
+                'VERY HIGH': {
+                    'min': 120,
+                    'ideal': 150,
+                    'max': 180,
+                    'intensity': 'high',
+                    'sessions': 'multiple',
+                    'preferred_types': ['active_training', 'intensive_exercise']
+                },
+                'HIGH': {
+                    'min': 90,
+                    'ideal': 120,
+                    'max': 150,
+                    'intensity': 'moderate_high',
+                    'sessions': 'multiple',
+                    'preferred_types': ['active_training', 'moderate_activity']
+                },
+                'MODERATE HIGH': {
+                    'min': 70,
+                    'ideal': 90,
+                    'max': 120,
+                    'intensity': 'moderate',
+                    'sessions': 'flexible',
+                    'preferred_types': ['moderate_activity', 'active_training']
+                },
+                'MODERATE': {
+                    'min': 45,
+                    'ideal': 60,
+                    'max': 90,
+                    'intensity': 'moderate',
+                    'sessions': 'flexible',
+                    'preferred_types': ['moderate_activity', 'light_walks']
+                },
+                'MODERATE LOW': {
+                    'min': 30,
+                    'ideal': 45,
+                    'max': 70,
+                    'intensity': 'light_moderate',
+                    'sessions': 'flexible',
+                    'preferred_types': ['light_walks', 'moderate_activity']
+                },
+                'LOW': {
+                    'min': 15,
+                    'ideal': 30,
+                    'max': 45,
+                    'intensity': 'light',
+                    'sessions': 'single',
+                    'preferred_types': ['light_walks']
+                }
             }
             
-            breed_need = exercise_needs.get(breed_needs.strip().upper(), exercise_needs['MODERATE'])
+            # 獲取品種的運動需求配置
+            breed_level = exercise_levels.get(breed_needs.upper(), exercise_levels['MODERATE'])
             
-            # 基礎時間匹配度計算
-            if exercise_time >= breed_need['ideal']:
-                if exercise_time > breed_need['max']:
-                    # 運動時間過長，稍微降低分數
-                    time_score = 0.9
+            # 計算時間匹配度（使用更平滑的評分曲線）
+            if exercise_time >= breed_level['ideal']:
+                if exercise_time > breed_level['max']:
+                    # 運動時間過長，適度降分
+                    time_score = 0.15 - (0.05 * (exercise_time - breed_level['max']) / 30)
                 else:
-                    time_score = 1.0
-            elif exercise_time >= breed_need['min']:
+                    time_score = 0.15
+            elif exercise_time >= breed_level['min']:
                 # 在最小需求和理想需求之間，線性計算分數
-                time_score = 0.7 + (exercise_time - breed_need['min']) / (breed_need['ideal'] - breed_need['min']) * 0.3
+                time_ratio = (exercise_time - breed_level['min']) / (breed_level['ideal'] - breed_level['min'])
+                time_score = 0.05 + (time_ratio * 0.10)
             else:
-                # 運動時間不足，但仍根據比例給予分數
-                time_score = max(0.3, 0.7 * (exercise_time / breed_need['min']))
+                # 運動時間不足，根據差距程度扣分
+                time_ratio = max(0, exercise_time / breed_level['min'])
+                time_score = -0.15 * (1 - time_ratio)
+            
+            # 運動類型匹配度評估
+            type_score = 0.0
+            if exercise_type in breed_level['preferred_types']:
+                type_score = 0.05
+                if exercise_type == breed_level['preferred_types'][0]:
+                    type_score = 0.08  # 最佳匹配類型給予更高分數
             
-            # 確保分數在合理範圍內
-            return min(1.0, max(0.3, time_score))
+            return max(-0.2, min(0.2, time_score + type_score))
 
 
         def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
@@ -1462,67 +1574,75 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
     return min(0.2, adaptability_score)
 
 
-def calculate_final_weighted_score(
-    scores: dict,
-    user_prefs: UserPreferences,
-    breed_info: dict,
-    adaptability_bonus: float
-) -> float:
+def calculate_dynamic_weights(user_prefs: UserPreferences, breed_info: dict) -> dict:
     """
-    優化的最終分數計算系統，強化條件變化的影響力
+    根據使用者條件動態計算權重
+    這個系統會根據具體情況調整各個評分項目的重要性
     """
-    # 基礎權重 - 更極端的差異
-    base_weights = {
-        'space': 0.35,        # 極度重視空間匹配
-        'exercise': 0.25,     # 重視運動需求
+    weights = {
+        'space': 0.25,      # 降低基礎空間權重
+        'exercise': 0.20,
         'grooming': 0.15,
         'experience': 0.15,
-        'health': 0.07,
-        'noise': 0.03
+        'health': 0.15,
+        'noise': 0.10
     }
-
-    # 條件特殊化評分
-    special_conditions = 0.0
     
-    # 極端條件判定
+    # 運動時間對權重的影響
+    if user_prefs.exercise_time > 150:
+        weights['exercise'] *= 1.4
+        weights['space'] *= 0.8
+    elif user_prefs.exercise_time < 30:
+        weights['exercise'] *= 0.8
+        weights['health'] *= 1.2
+        
+    # 居住環境對權重的影響
     if user_prefs.living_space == 'apartment':
-        if breed_info['Size'] == 'Large':
-            special_conditions -= 0.35  # 大型犬在公寓極度不適合
-        elif breed_info['Size'] == 'Small':
-            special_conditions += 0.15  # 小型犬在公寓加分
-            
-    # 運動需求極端匹配
-    exercise_needs = breed_info.get('Exercise_Needs', 'MODERATE').upper()
-    if user_prefs.exercise_time > 120:  # 高運動量
-        if exercise_needs in ['VERY HIGH', 'HIGH']:
-            special_conditions += 0.20
-        elif exercise_needs == 'LOW':
-            special_conditions -= 0.25
-    elif user_prefs.exercise_time < 45:  # 低運動量
-        if exercise_needs in ['VERY HIGH', 'HIGH']:
-            special_conditions -= 0.25
-        elif exercise_needs == 'LOW':
-            special_conditions += 0.15
-
-    # 經驗等級極端匹配
+        weights['noise'] *= 1.3
+        weights['space'] *= 1.2
+    elif user_prefs.living_space == 'house_large':
+        weights['exercise'] *= 1.2
+        weights['space'] *= 0.8
+        
+    # 經驗等級對權重的影響
     if user_prefs.experience_level == 'beginner':
-        if breed_info.get('Care_Level') == 'HIGH':
-            special_conditions -= 0.30
-    elif user_prefs.experience_level == 'advanced':
-        if breed_info.get('Care_Level') == 'LOW':
-            special_conditions -= 0.20
+        weights['experience'] *= 1.3
+        weights['health'] *= 1.2
+    
+    # 有孩童時的權重調整
+    if user_prefs.has_children:
+        if user_prefs.children_age == 'toddler':
+            weights['temperament'] = 0.20  # 新增性格權重
+            weights['space'] *= 0.8
+    
+    # 重新正規化權重
+    total = sum(weights.values())
+    return {k: v/total for k, v in weights.items()}
+
 
-    # 計算加權基礎分數
-    weighted_base = sum(score * base_weights[category] for category, score in scores.items())
+def calculate_final_weighted_score(
+    scores: dict,
+    user_prefs: UserPreferences,
+    breed_info: dict,
+    adaptability_bonus: float
+) -> float:
+    """
+    整合動態權重的最終分數計算系統
+    """
+    # 第一步：計算動態權重
+    weights = calculate_dynamic_weights(user_prefs, breed_info)  # 內部函數
+    
+    # 第二步：計算基礎加權分數
+    weighted_base = sum(score * weights[category] for category, score in scores.items())
     
-    # 品種特性加成
+    # 第三步：計算品種特性加成
     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-    # 最終分數計算
-    raw_score = (weighted_base * 0.65) + (breed_bonus * 0.20) + (adaptability_bonus * 0.10) + (special_conditions * 0.05)
-
-    # 分數轉換 - 使用S型曲線
-    return amplify_score_extreme(raw_score)
+    # 第四步：最終分數計算
+    final_score = (weighted_base * 0.70) + (breed_bonus * 0.20) + (adaptability_bonus * 0.10)
+    
+    # 第五步：分數轉換
+    return amplify_score_extreme(final_score)
     
 
 def amplify_score_extreme(score: float) -> float: