Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -2185,14 +2185,14 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
 
     def calculate_base_score(scores: dict, weights: dict) -> float:
         """
-        計算基礎分數,降低懲罰力度,允許某些維度有較低分數
+        計算基礎分數，更寬容地處理極端組合
         """
-        # 調整關鍵指標閾值,降低要求
+        # 進一步降低關鍵指標閾值，使系統更包容極端組合
         critical_thresholds = {
-            'space': 0.6,    # 從0.7降低到0.6
-            'exercise': 0.6,  # 從0.7降低到0.6
-            'experience': 0.6,# 從0.7降低到0.6
-            'noise': 0.6     # 從0.65降低到0.6
+            'space': 0.5,     
+            'exercise': 0.5,  
+            'experience': 0.6,# 重要的安全考量
+            'noise': 0.6      # 影響生活品質
         }
         
         critical_failures = []
@@ -2203,37 +2203,46 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         # 計算基礎加權分數
         base_score = sum(scores[k] * weights[k] for k in scores.keys())
         
-        # 降低懲罰程度
+        # 降低懲罰程度，特別是對空間和運動的組合
         if critical_failures:
-            # 降低最嚴重不足的懲罰影響
-            worst_failure = min(score for _, score in critical_failures)
-            penalty = (critical_thresholds['space'] - worst_failure) * 0.4  # 從0.6降到0.4
-            base_score *= (1 - penalty)
+            # 分開處理不同類型的失敗
+            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.2
+                else:
+                    # 其他失敗維持原有懲罰程度
+                    other_penalty += (critical_thresholds[metric] - score) * 0.4
+            
+            # 應用懲罰時更有彈性
+            total_penalty = (space_exercise_penalty + other_penalty) / 2
+            base_score *= (1 - total_penalty)
             
-            # 降低多重失敗的懲罰
+            # 進一步降低多重失敗的懲罰
             if len(critical_failures) > 1:
-                base_score *= (0.95 ** (len(critical_failures) - 1))  # 從0.9提升到0.95
+                base_score *= (0.97 ** (len(critical_failures) - 1))  
         
         return base_score
 
   
     def evaluate_condition_interactions(scores: dict) -> float:
         """
-        評估不同條件間的相互影響,移除對空間與運動組合的懲罰
+        評估不同條件間的相互影響，更寬容地處理極端組合
         """
         interaction_penalty = 1.0
         
-        # 經驗等級與其他因素的互動
+        # 只保留最基本的經驗相關評估
         if user_prefs.experience_level == 'beginner':
             if breed_info.get('Care Level') == 'HIGH':
-                interaction_penalty *= 0.9  
-            if breed_info.get('Exercise Needs', 'MODERATE').upper() == 'VERY HIGH':
-                interaction_penalty *= 0.9  
+                interaction_penalty *= 0.95  
         
-        # 運動時間與類型的基本互動
+        # 運動時間與類型的基本互動也降低懲罰程度
         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
         if exercise_needs == 'VERY HIGH' and user_prefs.exercise_type == 'light_walks':
-            interaction_penalty *= 0.9  
+            interaction_penalty *= 0.95  
                 
         return interaction_penalty
 
@@ -2315,51 +2324,85 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
     min_possible_score = 0.3
     
     return min(max_possible_score, max(min_possible_score, final_score))
-    
+
 
 def amplify_score_extreme(score: float) -> float:
     """
-    - 完美匹配可達到95-99%
-    - 優秀匹配在90-95%
-    - 良好匹配在85-90%
-    - 一般匹配在75-85%
-    - 較差匹配在65-75%
-    - 極差匹配在50-65%
+    優化分數分布：
+    - 提高高分的區別度
+    - 維持低分的合理性
     """
-    def smooth_curve(x: float, steepness: float = 12) -> float:
-        """使用sigmoid curve"""
-        import math
-        return 1 / (1 + math.exp(-steepness * (x - 0.5)))
-
     if score >= 0.9:
-        # 完美匹配：95-99%
+        # 完美匹配：92-99%
         position = (score - 0.9) / 0.1
-        return 0.95 + (position * 0.04)
+        return 0.92 + (position * 0.07)
         
     elif score >= 0.8:
-        # 優秀匹配：90-95%
+        # 優秀匹配：85-92%
         position = (score - 0.8) / 0.1
-        return 0.90 + (position * 0.05)
+        return 0.85 + (position * 0.07)
         
     elif score >= 0.7:
-        # 良好匹配：85-90%
+        # 良好匹配：78-85%
         position = (score - 0.7) / 0.1
-        return 0.85 + (position * 0.05)
+        return 0.78 + (position * 0.07)
         
     elif score >= 0.5:
-        # 一般匹配：75-85%
+        # 一般匹配：70-78%
         position = (score - 0.5) / 0.2
-        base = 0.75
-        return base + (smooth_curve(position) * 0.10)
+        base = 0.70
+        return base + (smooth_curve(position) * 0.08)
         
-    elif score >= 0.3:
-        # 較差匹配：65-75%
-        position = (score - 0.3) / 0.2
-        base = 0.65
+    else:
+        # 較差匹配：60-70%
+        position = score / 0.5
+        base = 0.60
         return base + (smooth_curve(position) * 0.10)
         
-    else:
-        # 極差匹配：50-65%
-        position = score / 0.3
-        base = 0.50
-        return base + (smooth_curve(position) * 0.15)
+
+# def amplify_score_extreme(score: float) -> float:
+#     """
+#     - 完美匹配可達到95-99%
+#     - 優秀匹配在90-95%
+#     - 良好匹配在85-90%
+#     - 一般匹配在75-85%
+#     - 較差匹配在65-75%
+#     - 極差匹配在50-65%
+#     """
+#     def smooth_curve(x: float, steepness: float = 12) -> float:
+#         """使用sigmoid curve"""
+#         import math
+#         return 1 / (1 + math.exp(-steepness * (x - 0.5)))
+
+#     if score >= 0.9:
+#         # 完美匹配：95-99%
+#         position = (score - 0.9) / 0.1
+#         return 0.95 + (position * 0.04)
+        
+#     elif score >= 0.8:
+#         # 優秀匹配：90-95%
+#         position = (score - 0.8) / 0.1
+#         return 0.90 + (position * 0.05)
+        
+#     elif score >= 0.7:
+#         # 良好匹配：85-90%
+#         position = (score - 0.7) / 0.1
+#         return 0.85 + (position * 0.05)
+        
+#     elif score >= 0.5:
+#         # 一般匹配：75-85%
+#         position = (score - 0.5) / 0.2
+#         base = 0.75
+#         return base + (smooth_curve(position) * 0.10)
+        
+#     elif score >= 0.3:
+#         # 較差匹配：65-75%
+#         position = (score - 0.3) / 0.2
+#         base = 0.65
+#         return base + (smooth_curve(position) * 0.10)
+        
+#     else:
+#         # 極差匹配：50-65%
+#         position = score / 0.3
+#         base = 0.50
+#         return base + (smooth_curve(position) * 0.15)