Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1161,53 +1161,205 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
     return min(0.2, adaptability_score)
 
 
+# def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
+#     """
+#     改進的品種相容性評分系統
+#     通過更細緻的特徵評估和動態權重調整，自然產生分數差異
+#     """
+#     # 評估關鍵特徵的匹配度，使用更極端的調整係數
+#     def evaluate_key_features():
+#         # 空間適配性評估
+#         space_multiplier = 1.0
+#         if user_prefs.living_space == 'apartment':
+#             if breed_info['Size'] == 'Giant':
+#                 space_multiplier = 0.3  # 嚴重不適合
+#             elif breed_info['Size'] == 'Large':
+#                 space_multiplier = 0.4  # 明顯不適合
+#             elif breed_info['Size'] == 'Small':
+#                 space_multiplier = 1.4  # 明顯優勢
+        
+#         # 運動需求評估
+#         exercise_multiplier = 1.0
+#         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+#         if exercise_needs == 'VERY HIGH':
+#             if user_prefs.exercise_time < 60:
+#                 exercise_multiplier = 0.3  # 嚴重不足
+#             elif user_prefs.exercise_time > 150:
+#                 exercise_multiplier = 1.5  # 完美匹配
+#         elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
+#             exercise_multiplier = 0.5  # 運動過度
+
+#         return space_multiplier, exercise_multiplier
+
+#     # 計算經驗匹配度
+#     def evaluate_experience():
+#         exp_multiplier = 1.0
+#         care_level = breed_info.get('Care Level', 'MODERATE')
+        
+#         if care_level == 'High':
+#             if user_prefs.experience_level == 'beginner':
+#                 exp_multiplier = 0.4
+#             elif user_prefs.experience_level == 'advanced':
+#                 exp_multiplier = 1.3
+#         elif care_level == 'Low':
+#             if user_prefs.experience_level == 'advanced':
+#                 exp_multiplier = 0.9  # 略微降低評分，因為可能不夠有挑戰性
+                
+#         return exp_multiplier
+
+#     # 取得特徵調整係數
+#     space_mult, exercise_mult = evaluate_key_features()
+#     exp_mult = evaluate_experience()
+
+#     # 調整基礎分數
+#     adjusted_scores = {
+#         'space': scores['space'] * space_mult,
+#         'exercise': scores['exercise'] * exercise_mult,
+#         'experience': scores['experience'] * exp_mult,
+#         'grooming': scores['grooming'],
+#         'health': scores['health'],
+#         'noise': scores['noise']
+#     }
+
+#     # 計算加權平均，關鍵特徵佔更大權重
+#     weights = {
+#         'space': 0.35,
+#         'exercise': 0.30,
+#         'experience': 0.20,
+#         'grooming': 0.15,
+#         'health': 0.10,
+#         'noise': 0.10
+#     }
+
+#     # 動態調整權重
+#     if user_prefs.has_children:
+#         if user_prefs.children_age == 'toddler':
+#             weights['noise'] *= 1.5     # 幼童對噪音更敏感
+#             weights['experience'] *= 1.3 # 需要更有經驗的飼主
+        
+#     if user_prefs.living_space == 'apartment':
+#         weights['space'] *= 1.4        # 公寓空間限制更重要
+#         weights['noise'] *= 1.3        # 噪音問題更重要
+
+#     # 運動時間極端情況
+#     if user_prefs.exercise_time < 30:
+#         weights['exercise'] *= 1.5     # 運動時間極少時加重權重
+#     elif user_prefs.exercise_time > 150:
+#         weights['exercise'] *= 1.3     # 運動時間充足時略微加重
+
+#     # 正規化權重
+#     total_weight = sum(weights.values())
+#     normalized_weights = {k: v/total_weight for k, v in weights.items()}
+
+#     # 計算最終分數
+#     final_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
+
+#     # 品種特性加成
+#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+    
+#     # 整合最終分數，保持在0-1範圍內
+#     return min(1.0, max(0.0, (final_score * 0.85) + (breed_bonus * 0.15)))
+    
+
+# def amplify_score_extreme(score: float) -> float:
+#     """
+#     改進的分數轉換函數，提供更大的分數區間和更明顯的差異
+    
+#     轉換邏輯：
+#     - 極差匹配 (0.0-0.2) -> 50-60%
+#     - 較差匹配 (0.2-0.4) -> 60-70%
+#     - 中等匹配 (0.4-0.6) -> 70-82%
+#     - 良好匹配 (0.6-0.8) -> 82-90%
+#     - 優秀匹配 (0.8-1.0) -> 90-98%
+#     """
+#     if score < 0.2:
+#         # 極差匹配：更低的起始分數
+#         return 0.50 + (score / 0.2) * 0.10
+#     elif score < 0.4:
+#         # 較差匹配：緩慢增長
+#         position = (score - 0.2) / 0.2
+#         return 0.60 + position * 0.10
+#     elif score < 0.6:
+#         # 中等匹配：較大的分數增長
+#         position = (score - 0.4) / 0.2
+#         return 0.70 + position * 0.12
+#     elif score < 0.8:
+#         # 良好匹配：快速增長
+#         position = (score - 0.6) / 0.2
+#         return 0.82 + position * 0.08
+#     else:
+#         # 優秀匹配：達到更高分數
+#         position = (score - 0.8) / 0.2
+#         return 0.90 + position * 0.08
+
+
 def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
-    """
-    改進的品種相容性評分系統
-    通過更細緻的特徵評估和動態權重調整，自然產生分數差異
-    """
-    # 評估關鍵特徵的匹配度，使用更極端的調整係數
+    """改進的品種相容性評分系統"""
+    
     def evaluate_key_features():
-        # 空間適配性評估
+        # 空間適配性評估 - 更極端的調整
         space_multiplier = 1.0
         if user_prefs.living_space == 'apartment':
             if breed_info['Size'] == 'Giant':
-                space_multiplier = 0.3  # 嚴重不適合
+                space_multiplier = 0.2  # 更嚴重的懲罰
             elif breed_info['Size'] == 'Large':
-                space_multiplier = 0.4  # 明顯不適合
+                space_multiplier = 0.3
+            elif breed_info['Size'] == 'Medium':
+                space_multiplier = 0.7
             elif breed_info['Size'] == 'Small':
-                space_multiplier = 1.4  # 明顯優勢
-        
-        # 運動需求評估
+                space_multiplier = 1.6  # 更大的獎勵
+                
+        # 運動需求評估 - 更細緻的匹配
         exercise_multiplier = 1.0
         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+        
+        # 運動時間差異計算
+        time_diff_ratio = abs(user_prefs.exercise_time - get_ideal_exercise_time(exercise_needs)) / 60.0
+        
         if exercise_needs == 'VERY HIGH':
-            if user_prefs.exercise_time < 60:
-                exercise_multiplier = 0.3  # 嚴重不足
+            if user_prefs.exercise_time < 90:
+                exercise_multiplier = max(0.2, 1.0 - time_diff_ratio)
             elif user_prefs.exercise_time > 150:
-                exercise_multiplier = 1.5  # 完美匹配
-        elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
-            exercise_multiplier = 0.5  # 運動過度
+                exercise_multiplier = min(2.0, 1.0 + time_diff_ratio/2)
+        elif exercise_needs == 'HIGH':
+            if user_prefs.exercise_time < 60:
+                exercise_multiplier = max(0.3, 1.0 - time_diff_ratio)
+            elif user_prefs.exercise_time > 120:
+                exercise_multiplier = min(1.8, 1.0 + time_diff_ratio/2)
+        elif exercise_needs == 'LOW':
+            if user_prefs.exercise_time > 120:
+                exercise_multiplier = max(0.4, 1.0 - time_diff_ratio/2)
 
         return space_multiplier, exercise_multiplier
 
-    # 計算經驗匹配度
+    def get_ideal_exercise_time(exercise_needs: str) -> int:
+        """獲取理想運動時間"""
+        return {
+            'VERY HIGH': 150,
+            'HIGH': 120,
+            'MODERATE HIGH': 90,
+            'MODERATE': 60,
+            'MODERATE LOW': 45,
+            'LOW': 30
+        }.get(exercise_needs, 60)
+
+    # 經驗匹配度評估 - 更強的影響力
     def evaluate_experience():
         exp_multiplier = 1.0
         care_level = breed_info.get('Care Level', 'MODERATE')
         
         if care_level == 'High':
             if user_prefs.experience_level == 'beginner':
-                exp_multiplier = 0.4
+                exp_multiplier = 0.3  # 更嚴重的懲罰
             elif user_prefs.experience_level == 'advanced':
-                exp_multiplier = 1.3
+                exp_multiplier = 1.5  # 更大的獎勵
         elif care_level == 'Low':
             if user_prefs.experience_level == 'advanced':
-                exp_multiplier = 0.9  # 略微降低評分，因為可能不夠有挑戰性
+                exp_multiplier = 0.8
                 
         return exp_multiplier
 
-    # 取得特徵調整係數
+    # 計算調整係數
     space_mult, exercise_mult = evaluate_key_features()
     exp_mult = evaluate_experience()
 
@@ -1217,77 +1369,90 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         'exercise': scores['exercise'] * exercise_mult,
         'experience': scores['experience'] * exp_mult,
         'grooming': scores['grooming'],
-        'health': scores['health'],
+        'health': scores['health'] * (1.5 if user_prefs.health_sensitivity == 'high' else 1.0),
         'noise': scores['noise']
     }
 
-    # 計算加權平均，關鍵特徵佔更大權重
+    # 基礎權重
     weights = {
-        'space': 0.35,
-        'exercise': 0.30,
-        'experience': 0.20,
+        'space': 0.25,
+        'exercise': 0.25,
+        'experience': 0.15,
         'grooming': 0.15,
         'health': 0.10,
         'noise': 0.10
     }
 
-    # 動態調整權重
+    # 動態權重調整 - 更強的條件反應
     if user_prefs.has_children:
         if user_prefs.children_age == 'toddler':
-            weights['noise'] *= 1.5     # 幼童對噪音更敏感
-            weights['experience'] *= 1.3 # 需要更有經驗的飼主
-        
+            weights['noise'] *= 2.0  # 更強的噪音影響
+            weights['experience'] *= 1.5
+            weights['health'] *= 1.3
+        elif user_prefs.children_age == 'school_age':
+            weights['noise'] *= 1.5
+            weights['experience'] *= 1.3
+
     if user_prefs.living_space == 'apartment':
-        weights['space'] *= 1.4        # 公寓空間限制更重要
-        weights['noise'] *= 1.3        # 噪音問題更重要
+        weights['space'] *= 1.8  # 更強的空間限制
+        weights['noise'] *= 1.6
 
     # 運動時間極端情況
     if user_prefs.exercise_time < 30:
-        weights['exercise'] *= 1.5     # 運動時間極少時加重權重
+        weights['exercise'] *= 2.0
     elif user_prefs.exercise_time > 150:
-        weights['exercise'] *= 1.3     # 運動時間充足時略微加重
+        weights['exercise'] *= 1.5
 
     # 正規化權重
     total_weight = sum(weights.values())
     normalized_weights = {k: v/total_weight for k, v in weights.items()}
 
-    # 計算最終分數
-    final_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
-
+    # 計算基礎分數
+    base_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
+    
     # 品種特性加成
     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-    # 整合最終分數，保持在0-1範圍內
-    return min(1.0, max(0.0, (final_score * 0.85) + (breed_bonus * 0.15)))
+    # 動態整合係數
+    bonus_weight = min(0.25, max(0.15, breed_bonus))  # 讓優秀特性有更大影響
+    
+    # 完美匹配加成
+    if all(score >= 0.8 for score in adjusted_scores.values()):
+        base_score *= 1.2
     
+    # 極端不匹配懲罰
+    if any(score <= 0.3 for score in adjusted_scores.values()):
+        base_score *= 0.6
+
+    return min(1.0, max(0.0, (base_score * (1.0 - bonus_weight)) + (breed_bonus * bonus_weight)))
+
 
 def amplify_score_extreme(score: float) -> float:
     """
-    改進的分數轉換函數，提供更大的分數區間和更明顯的差異
+    改進的分數轉換函數，提供更動態的分數範圍
     
-    轉換邏輯：
-    - 極差匹配 (0.0-0.2) -> 50-60%
-    - 較差匹配 (0.2-0.4) -> 60-70%
-    - 中等匹配 (0.4-0.6) -> 70-82%
-    - 良好匹配 (0.6-0.8) -> 82-90%
-    - 優秀匹配 (0.8-1.0) -> 90-98%
+    動態轉換邏輯：
+    - 極差匹配 (0.0-0.2) -> 45-58%
+    - 較差匹配 (0.2-0.4) -> 58-72%
+    - 中等匹配 (0.4-0.6) -> 72-85%
+    - 良好匹配 (0.6-0.8) -> 85-92%
+    - 優秀匹配 (0.8-0.9) -> 92-96%
+    - 完美匹配 (0.9-1.0) -> 96-99%
     """
     if score < 0.2:
-        # 極差匹配：更低的起始分數
-        return 0.50 + (score / 0.2) * 0.10
+        return 0.45 + (score / 0.2) * 0.13
     elif score < 0.4:
-        # 較差匹配：緩慢增長
         position = (score - 0.2) / 0.2
-        return 0.60 + position * 0.10
+        return 0.58 + position * 0.14
     elif score < 0.6:
-        # 中等匹配：較大的分數增長
         position = (score - 0.4) / 0.2
-        return 0.70 + position * 0.12
+        return 0.72 + position * 0.13
     elif score < 0.8:
-        # 良好匹配：快速增長
         position = (score - 0.6) / 0.2
-        return 0.82 + position * 0.08
+        return 0.85 + position * 0.07
+    elif score < 0.9:
+        position = (score - 0.8) / 0.1
+        return 0.92 + position * 0.04
     else:
-        # 優秀匹配：達到更高分數
-        position = (score - 0.8) / 0.2
-        return 0.90 + position * 0.08
+        position = (score - 0.9) / 0.1
+        return 0.96 + position * 0.03