Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1509,38 +1509,75 @@ 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. 動態閾值調整
     """
-    改進的品種相容性評分系統，提供更明顯的分數差異和更準確的品種匹配
-    
-    主要改進：
-    1. 提高關鍵參數權重
-    2. 加強條件權重調整
-    3. 更嚴格的不適配懲罰
-    4. 非線性分數調整
-    """
-    # 關鍵不適配參數檢查 - 加強懲罰機制
-    critical_params = {
+    # 關鍵特徵評估閾值
+    feature_thresholds = {
         'space': {
-            'threshold': 0.35,
-            'conditions': lambda p: True,
-            'penalty': 0.3
+            '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}
         },
-        'noise': {
-            'threshold': 0.35,
-            'conditions': lambda p: p.living_space == 'apartment',
-            'penalty': 0.35
+        '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': {
-            'threshold': 0.35,
-            'conditions': lambda p: p.experience_level == 'beginner',
-            'penalty': 0.35
+            '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}
         }
     }
 
-    # 檢查關鍵不適配
-    for param, config in critical_params.items():
-        if scores[param] < config['threshold'] and config['conditions'](user_prefs):
-            return config['penalty']
+    # 評估空間適配性
+    def evaluate_space_compatibility():
+        size = breed_info['Size']
+        base_threshold = feature_thresholds['space'][user_prefs.living_space][size]
+        space_score = scores['space']
+        
+        # 根據空間類型調整評分
+        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
+            
+        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)
+
+    # 計算調整後的分數
+    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 = {
@@ -1552,135 +1589,119 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         'noise': 0.10
     }
 
-    # 計算各項指標的調整後分數
-    adjusted_scores = {}
-    for param, score in scores.items():
-        # 基礎分數調整：優秀匹配得到更高分數
-        if score > 0.8:
-            adjusted_scores[param] = min(1.0, score * 1.3)  # 優秀匹配額外加分
-        elif score < 0.4:
-            adjusted_scores[param] = score * 0.7  # 較差匹配更大懲罰
-        else:
-            adjusted_scores[param] = score
-
-    # 權重動態調整
-    adjusted_weights = {}
-    for param, weight in base_weights.items():
-        multiplier = 1.0
+    # 動態權重調整
+    def calculate_dynamic_weights():
+        weights = base_weights.copy()
         
-        # 空間適配性調整
-        if param == 'space':
-            if user_prefs.living_space == 'apartment':
-                if breed_info['Size'] in ['Large', 'Giant']:
-                    multiplier *= 0.5  # 大型犬在公寓極不適合
-                elif breed_info['Size'] == 'Small':
-                    multiplier *= 1.4  # 小型犬在公寓更合適
-            elif user_prefs.living_space == 'house_large':
-                if breed_info['Size'] in ['Large', 'Giant']:
-                    multiplier *= 1.3  # 大型犬在大房子更合適
-
-        # 運動需求調整
-        elif param == 'exercise':
-            exercise_needs = breed_info.get('Exercise Needs', 'Moderate').upper()
-            if exercise_needs == 'VERY HIGH':
-                if user_prefs.exercise_time > 150:
-                    multiplier *= 1.4  # 高運動量需求與高運動時間匹配
-                elif user_prefs.exercise_time < 60:
-                    multiplier *= 0.6  # 運動時間嚴重不足
-            elif exercise_needs == 'LOW' and user_prefs.exercise_time > 120:
-                multiplier *= 0.8  # 過度運動對低運動需求品種不利
-
-        # 經驗需求調整
-        elif param == 'experience':
-            if breed_info.get('Care Level') == 'High':
-                if user_prefs.experience_level == 'beginner':
-                    multiplier *= 0.6
-                elif user_prefs.experience_level == 'advanced':
-                    multiplier *= 1.3
-
-        adjusted_weights[param] = weight * multiplier
-
-    # 重新正規化權重
-    total_weight = sum(adjusted_weights.values())
-    normalized_weights = {k: v/total_weight for k, v in adjusted_weights.items()}
-
-    # 計算加權分數
-    weighted_scores = {}
-    for param, weight in normalized_weights.items():
-        weighted_scores[param] = adjusted_scores[param] * weight
+        # 空間權重調整
+        if user_prefs.living_space == 'apartment':
+            weights['space'] *= 1.4
+            weights['noise'] *= 1.3
+        
+        # 運動權重調整
+        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
+            
+        # 重新正規化
+        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) / sum(normalized_weights[p] for p in primary_params)
-    secondary_score = sum(weighted_scores[p] for p in weighted_scores if p not in primary_params) / \
-                     sum(normalized_weights[p] for p in normalized_weights if p not in primary_params)
+    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)
+    # 計算基礎分數
+    base_score = (primary_score * 0.7 + secondary_score * 0.3)
 
-    # 計算完美匹配加成
-    perfect_match_bonus = 0.0
+    # 特殊條件加成或懲罰
+    bonus = 0.0
+    
+    # 完美匹配加成
     if all(adjusted_scores[p] > 0.8 for p in primary_params):
-        perfect_match_bonus = 0.1
-
-    # 計算最終分數
-    final_score = base_score + perfect_match_bonus
+        bonus += 0.1
+    
+    # 極端不適配懲罰
+    if any(adjusted_scores[p] < 0.4 for p in primary_params):
+        bonus -= 0.15
 
-    # 品種特性加成
+    # 整合品種特性加成
     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-    # 整合最終分數
-    final_score = (final_score * 0.8) + (breed_bonus * 0.2)
+    # 計算最終分數
+    final_score = (base_score + bonus) * 0.8 + breed_bonus * 0.2
 
-    return final_score
+    return max(0.0, min(1.0, final_score))
+    
 
 def amplify_score_extreme(score: float) -> float:
+    """   
+    改進：
+    1. 更細緻的分數區間劃分
+    2. 非線性的分數轉換
+    3. 更合理的分數分布
     """
-    將原始分數（0-1範圍）映射到最終評分範圍（60-95%）
-    
-    分數映射邏輯：
-    - 0-0.3: 60-70% (較差匹配)
-    - 0.3-0.6: 70-80% (中等匹配)
-    - 0.6-0.8: 80-90% (良好匹配)
-    - 0.8-1.0: 90-95% (優秀匹配)
-    
-    每個區間使用線性映射，確保相同輸入產生相同輸出
-    """
-    # 定義分數區間和對應的輸出範圍
     ranges = {
         'poor': {
             'range': (0.0, 0.3),
-            'out_min': 0.6,
-            'out_max': 0.7
+            'out_min': 0.60,
+            'out_max': 0.68,
+            'curve': 1.2  # 加強懲罰效果
+        },
+        'below_average': {
+            'range': (0.3, 0.5),
+            'out_min': 0.68,
+            'out_max': 0.75,
+            'curve': 1.1
         },
-        'mediocre': {
-            'range': (0.3, 0.6),
-            'out_min': 0.7,
-            'out_max': 0.8
+        'average': {
+            'range': (0.5, 0.65),
+            'out_min': 0.75,
+            'out_max': 0.82,
+            'curve': 1.0
         },
         'good': {
-            'range': (0.6, 0.8),
-            'out_min': 0.8,
-            'out_max': 0.9
+            'range': (0.65, 0.8),
+            'out_min': 0.82,
+            'out_max': 0.88,
+            'curve': 1.1
         },
         'excellent': {
-            'range': (0.8, 1.0),
-            'out_min': 0.9,
-            'out_max': 0.95
+            'range': (0.8, 0.9),
+            'out_min': 0.88,
+            'out_max': 0.92,
+            'curve': 1.2
+        },
+        'perfect': {
+            'range': (0.9, 1.0),
+            'out_min': 0.92,
+            'out_max': 0.95,
+            'curve': 1.3
         }
     }
     
-    # 找出分數所屬區間並進行映射
     for config in ranges.values():
         range_min, range_max = config['range']
         if range_min <= score <= range_max:
+            # 計算在區間內的相對位置
             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, 1)
+            return round(result, 3)
     
-    # 處理超出範圍的情況
-    return 0.6 if score < 0.0 else 0.95
+    return 0.60 if score < 0.0 else 0.95