Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1509,199 +1509,194 @@ 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. 多層次的條件影響
-    4. 動態閾值調整
     """
-    # 關鍵特徵評估閾值
-    feature_thresholds = {
-        'space': {
-            'apartment': {'Small': 0.9, 'Medium': 0.6, 'Large': 0.3, 'Giant': 0.2},
-            'house_small': {'Small': 0.8, 'Medium': 0.8, 'Large': 0.6, 'Giant': 0.4},
-            'house_large': {'Small': 0.7, 'Medium': 0.85, 'Large': 0.9, 'Giant': 0.9}
-        },
-        'exercise': {
-            'VERY HIGH': {'min': 120, 'optimal': 180, 'factor': 1.5},
-            'HIGH': {'min': 90, 'optimal': 120, 'factor': 1.3},
-            'MODERATE': {'min': 45, 'optimal': 90, 'factor': 1.1},
-            'LOW': {'min': 20, 'optimal': 45, 'factor': 0.9}
-        },
-        'experience': {
-            'beginner': {'High': 0.4, 'Moderate': 0.7, 'Low': 0.9},
-            'intermediate': {'High': 0.7, 'Moderate': 0.85, 'Low': 0.95},
-            'advanced': {'High': 0.9, 'Moderate': 0.95, 'Low': 1.0}
-        }
-    }
-
-    # 評估空間適配性
-    def evaluate_space_compatibility():
-        size = breed_info['Size']
-        base_threshold = feature_thresholds['space'][user_prefs.living_space][size]
-        space_score = scores['space']
+    改進的品種相容性評分系統，著重於：
+    1. 強化參數變化的影響力
+    2. 提高品種差異化
+    3. 更精確的條件匹配評估
+    """
+    # 1. 基礎特徵評估 - 更極端的調整
+    def evaluate_feature_score(feature: str) -> float:
+        score = scores[feature]
         
-        # 根據空間類型調整評分
-        if user_prefs.living_space == 'apartment' and size in ['Large', 'Giant']:
-            space_score *= 0.5
-        elif user_prefs.living_space == 'house_large' and size in ['Large', 'Giant']:
-            space_score *= 1.2
+        if feature == 'exercise':
+            exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+            exercise_time = user_prefs.exercise_time
             
-        return min(1.0, space_score * base_threshold)
-
-    # 評估運動需求匹配度
-    def evaluate_exercise_compatibility():
-        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-        config = feature_thresholds['exercise'][exercise_needs]
-        
-        if user_prefs.exercise_time < config['min']:
-            return scores['exercise'] * 0.6
-        elif user_prefs.exercise_time >= config['optimal']:
-            return min(1.0, scores['exercise'] * config['factor'])
-        else:
-            ratio = (user_prefs.exercise_time - config['min']) / (config['optimal'] - config['min'])
-            return scores['exercise'] * (0.6 + ratio * 0.4)
-
-    # 評估經驗需求匹配度
-    def evaluate_experience_compatibility():
-        care_level = breed_info.get('Care Level', 'Moderate')
-        base_score = feature_thresholds['experience'][user_prefs.experience_level][care_level]
-        return min(1.0, scores['experience'] * base_score)
+            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  # 略微降低過度資格
+                
+        return score
 
-    # 計算調整後的分數
+    # 2. 計算調整後的分數
     adjusted_scores = {
-        'space': evaluate_space_compatibility(),
-        'exercise': evaluate_exercise_compatibility(),
-        'experience': evaluate_experience_compatibility(),
-        'grooming': scores['grooming'],
-        'health': scores['health'],
-        'noise': scores['noise']
-    }
-
-    # 基礎權重設定
-    base_weights = {
-        'space': 0.35,
-        'exercise': 0.30,
-        'experience': 0.20,
-        'grooming': 0.15,
-        'health': 0.10,
-        'noise': 0.10
+        feature: evaluate_feature_score(feature)
+        for feature in scores.keys()
     }
 
-    # 動態權重調整
-    def calculate_dynamic_weights():
-        weights = base_weights.copy()
+    # 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
+        }
         
-        # 空間權重調整
-        if user_prefs.living_space == 'apartment':
-            weights['space'] *= 1.4
-            weights['noise'] *= 1.3
+        weight = base_weights[feature]
         
-        # 運動權重調整
-        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-        if exercise_needs in ['VERY HIGH', 'HIGH']:
-            weights['exercise'] *= 1.3
-            
-        # 經驗權重調整
-        if user_prefs.experience_level == 'beginner':
-            weights['experience'] *= 1.4
+        # 條件相關的權重調整
+        if feature == 'space' and user_prefs.living_space == 'apartment':
+            weight *= 1.6  # 加強空間限制的影響
             
-        # 重新正規化
-        total = sum(weights.values())
-        return {k: v/total for k, v in weights.items()}
-
-    # 計算最終分數
-    weights = calculate_dynamic_weights()
-    weighted_scores = {param: score * weights[param] 
-                      for param, score in adjusted_scores.items()}
-    
-    # 分開計算主要和次要參數
-    primary_params = {'space', 'exercise', 'experience'}
-    primary_score = sum(weighted_scores[p] for p in primary_params)
-    secondary_score = sum(weighted_scores[p] for p in weighted_scores if p not in primary_params)
-
-    # 計算基礎分數
-    base_score = (primary_score * 0.7 + secondary_score * 0.3)
+        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
 
-    # 特殊條件加成或懲罰
-    bonus = 0.0
+    # 4. 計算加權分數
+    weights = {feature: calculate_feature_weight(feature) 
+              for feature in scores.keys()}
     
-    # 完美匹配加成
-    if all(adjusted_scores[p] > 0.8 for p in primary_params):
-        bonus += 0.1
+    # 正規化權重
+    total_weight = sum(weights.values())
+    normalized_weights = {k: v/total_weight for k, v in weights.items()}
     
-    # 極端不適配懲罰
-    if any(adjusted_scores[p] < 0.4 for p in primary_params):
-        bonus -= 0.15
-
-    # 整合品種特性加成
+    # 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)
     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-    # 計算最終分數
-    final_score = (base_score + bonus) * 0.8 + breed_bonus * 0.2
-
+    final_score = (base_score * condition_multiplier * 0.8) + (breed_bonus * 0.2)
+    
     return max(0.0, min(1.0, final_score))
     
 
 def amplify_score_extreme(score: float) -> float:
-    """   
-    改進：
-    1. 更細緻的分數區間劃分
-    2. 非線性的分數轉換
-    3. 更合理的分數分布
+    """
+    優化的分數映射函數
+    
+    主要改進：
+    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% - 非常緩慢的增長
     """
     ranges = {
-        'poor': {
-            'range': (0.0, 0.3),
+        '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  # 加強懲罰效果
+            'curve': 1.2    # 稍微非線性
         },
-        'below_average': {
-            'range': (0.3, 0.5),
+        'mediocre': {
+            'range': (0.4, 0.6),
             'out_min': 0.68,
             'out_max': 0.75,
-            'curve': 1.1
-        },
-        'average': {
-            'range': (0.5, 0.65),
-            'out_min': 0.75,
-            'out_max': 0.82,
-            'curve': 1.0
+            'curve': 1.0    # 線性
         },
         'good': {
-            'range': (0.65, 0.8),
-            'out_min': 0.82,
-            'out_max': 0.88,
-            'curve': 1.1
+            'range': (0.6, 0.75),
+            'out_min': 0.75,
+            'out_max': 0.85,
+            'curve': 0.8    # 加速增長
         },
         'excellent': {
-            'range': (0.8, 0.9),
-            'out_min': 0.88,
+            'range': (0.75, 0.9),
+            'out_min': 0.85,
             'out_max': 0.92,
-            'curve': 1.2
+            'curve': 1.2    # 減速增長
         },
         'perfect': {
             'range': (0.9, 1.0),
             'out_min': 0.92,
             'out_max': 0.95,
-            'curve': 1.3
+            '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