Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1510,193 +1510,124 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 
 def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
     """
-    改進的品種相容性評分系統，著重於：
-    1. 強化參數變化的影響力
-    2. 提高品種差異化
-    3. 更精確的條件匹配評估
+    改進的品種相容性評分系統
+    通過更細緻的特徵評估和動態權重調整，自然產生分數差異
     """
-    # 1. 基礎特徵評估 - 更極端的調整
-    def evaluate_feature_score(feature: str) -> float:
-        score = scores[feature]
+    # 評估關鍵特徵的匹配度，使用更極端的調整係數
+    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  # 明顯優勢
         
-        if feature == 'exercise':
-            exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-            exercise_time = user_prefs.exercise_time
-            
-            if exercise_needs == 'VERY HIGH':
-                if exercise_time < 120:
-                    return score * 0.4  # 嚴重懲罰運動不足
-                elif exercise_time > 150:
-                    return min(1.0, score * 1.5)  # 顯著獎勵充足運動
-            elif exercise_needs == 'LOW' and exercise_time > 120:
-                return score * 0.6  # 懲罰過度運動
-                
-        elif feature == 'space':
-            size = breed_info['Size']
-            if user_prefs.living_space == 'apartment':
-                if size in ['Large', 'Giant']:
-                    return score * 0.3  # 更嚴格的空間限制
-                elif size == 'Small':
-                    return min(1.0, score * 1.4)  # 更高的小型犬獎勵
-                    
-        elif feature == 'experience':
-            care_level = breed_info.get('Care Level', 'MODERATE')
-            if care_level == 'High' and user_prefs.experience_level == 'beginner':
-                return score * 0.4
-            elif care_level == 'Low' and user_prefs.experience_level == 'advanced':
-                return score * 0.8  # 略微降低過度資格
+        # 運動需求評估
+        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 score
+        return exp_multiplier
+
+    # 取得特徵調整係數
+    space_mult, exercise_mult = evaluate_key_features()
+    exp_mult = evaluate_experience()
 
-    # 2. 計算調整後的分數
+    # 調整基礎分數
     adjusted_scores = {
-        feature: evaluate_feature_score(feature)
-        for feature in scores.keys()
+        'space': scores['space'] * space_mult,
+        'exercise': scores['exercise'] * exercise_mult,
+        'experience': scores['experience'] * exp_mult,
+        'grooming': scores['grooming'],
+        'health': scores['health'],
+        'noise': scores['noise']
     }
 
-    # 3. 動態權重分配 - 根據條件強化關鍵特徵
-    def calculate_feature_weight(feature: str) -> float:
-        base_weights = {
-            'space': 0.35,
-            'exercise': 0.30,
-            'experience': 0.20,
-            'grooming': 0.15,
-            'health': 0.10,
-            'noise': 0.10
-        }
-        
-        weight = base_weights[feature]
-        
-        # 條件相關的權重調整
-        if feature == 'space' and user_prefs.living_space == 'apartment':
-            weight *= 1.6  # 加強空間限制的影響
-            
-        elif feature == 'exercise':
-            if user_prefs.exercise_time > 150:
-                weight *= 1.4
-            elif user_prefs.exercise_time < 60:
-                weight *= 1.3
-                
-        elif feature == 'experience':
-            if user_prefs.experience_level in ['beginner', 'advanced']:
-                weight *= 1.3  # 強化極端經驗等級的影響
-                
-        return weight
+    # 計算加權平均，關鍵特徵佔更大權重
+    weights = {
+        'space': 0.35,
+        'exercise': 0.30,
+        'experience': 0.20,
+        'grooming': 0.15,
+        'health': 0.10,
+        'noise': 0.10
+    }
 
-    # 4. 計算加權分數
-    weights = {feature: calculate_feature_weight(feature) 
-              for feature in scores.keys()}
+    # 動態調整權重
+    if user_prefs.living_space == 'apartment':
+        weights['space'] *= 1.5
+        weights['noise'] *= 1.3
     
+    if abs(user_prefs.exercise_time - 120) > 60:  # 運動時間極端情況
+        weights['exercise'] *= 1.4
+
     # 正規化權重
     total_weight = sum(weights.values())
     normalized_weights = {k: v/total_weight for k, v in weights.items()}
-    
-    # 5. 計算基礎分數 - 分離主要和次要特徵
-    primary_features = {'space', 'exercise', 'experience'}
-    secondary_features = set(scores.keys()) - primary_features
-    
-    primary_score = sum(adjusted_scores[f] * normalized_weights[f] 
-                       for f in primary_features)
-    secondary_score = sum(adjusted_scores[f] * normalized_weights[f] 
-                         for f in secondary_features)
-    
-    # 6. 特殊條件評估
-    condition_multiplier = 1.0
-    
-    # 空間條件
-    if user_prefs.living_space == 'apartment':
-        if breed_info['Size'] in ['Large', 'Giant']:
-            condition_multiplier *= 0.7
-        elif breed_info['Size'] == 'Small':
-            condition_multiplier *= 1.2
-            
-    # 運動條件
-    exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-    if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 120:
-        condition_multiplier *= 0.8
-    elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
-        condition_multiplier *= 0.85
-        
-    # 7. 計算最終分數
-    base_score = (primary_score * 0.7 + secondary_score * 0.3)
+
+    # 計算最終分數
+    final_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
+
+    # 品種特性加成
     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-    final_score = (base_score * condition_multiplier * 0.8) + (breed_bonus * 0.2)
-    
-    return max(0.0, min(1.0, final_score))
+    # 整合最終分數，保持在0-1範圍內
+    return min(1.0, max(0.0, (final_score * 0.85) + (breed_bonus * 0.15)))
     
 
 def amplify_score_extreme(score: float) -> float:
     """
-    優化的分數映射函數
-    
-    主要改進：
-    1. 更細緻的分數區間劃分，讓分數轉換更平滑
-    2. 根據不同分數段使用不同的轉換曲線
-    3. 確保極端分數能得到更極端的映射
-    
-    分數區間的設計邏輯：
-    - 極差匹配 (0.0-0.2): 60-63% - 快速的線性增長
-    - 差匹配 (0.2-0.4): 63-68% - 緩慢的增長
-    - 中等匹配 (0.4-0.6): 68-75% - 穩定的線性增長
-    - 良好匹配 (0.6-0.75): 75-85% - 加速增長
-    - 優秀匹配 (0.75-0.9): 85-92% - 減速增長
-    - 完美匹配 (0.9-1.0): 92-95% - 非常緩慢的增長
+    改進的分數轉換函數
+    提供更大的分數範圍和更明顯的差異
+    
+    轉換邏輯：
+    - 極差匹配 (0.0-0.3) -> 60-68%
+    - 較差匹配 (0.3-0.5) -> 68-75%
+    - 中等匹配 (0.5-0.7) -> 75-85%
+    - 良好匹配 (0.7-0.85) -> 85-92%
+    - 優秀匹配 (0.85-1.0) -> 92-95%
     """
-    ranges = {
-        'very_poor': {
-            'range': (0.0, 0.2),
-            'out_min': 0.60,
-            'out_max': 0.63,
-            'curve': 1.0    # 線性
-        },
-        'poor': {
-            'range': (0.2, 0.4),
-            'out_min': 0.63,
-            'out_max': 0.68,
-            'curve': 1.2    # 稍微非線性
-        },
-        'mediocre': {
-            'range': (0.4, 0.6),
-            'out_min': 0.68,
-            'out_max': 0.75,
-            'curve': 1.0    # 線性
-        },
-        'good': {
-            'range': (0.6, 0.75),
-            'out_min': 0.75,
-            'out_max': 0.85,
-            'curve': 0.8    # 加速增長
-        },
-        'excellent': {
-            'range': (0.75, 0.9),
-            'out_min': 0.85,
-            'out_max': 0.92,
-            'curve': 1.2    # 減速增長
-        },
-        'perfect': {
-            'range': (0.9, 1.0),
-            'out_min': 0.92,
-            'out_max': 0.95,
-            'curve': 1.5    # 強烈的減速
-        }
-    }
-
-    # 找出分數所屬區間並進行映射
-    for config in ranges.values():
-        range_min, range_max = config['range']
-        if range_min <= score <= range_max:
-            # 計算區間內的相對位置（0-1）
-            position = (score - range_min) / (range_max - range_min)
-            
-            # 應用非線性曲線來調整增長速度
-            position = pow(position, config['curve'])
-            
-            # 映射到輸出範圍
-            result = config['out_min'] + (config['out_max'] - config['out_min']) * position
-            
-            # 確保結果精確到小數點後三位
-            return round(result, 3)
-    
-    # 處理超出範圍的情況
-    return 0.60 if score < 0.0 else 0.95
+    if score < 0.3:
+        # 極差匹配：快速線性增長
+        return 0.60 + (score / 0.3) * 0.08
+    elif score < 0.5:
+        # 較差匹配：緩慢增長
+        position = (score - 0.3) / 0.2
+        return 0.68 + position * 0.07
+    elif score < 0.7:
+        # 中等匹配：穩定線性增長
+        position = (score - 0.5) / 0.2
+        return 0.75 + position * 0.10
+    elif score < 0.85:
+        # 良好匹配：加速增長
+        position = (score - 0.7) / 0.15
+        return 0.85 + position * 0.07
+    else:
+        # 優秀匹配：最後衝刺
+        position = (score - 0.85) / 0.15
+        return 0.92 + position * 0.03