Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1487,58 +1487,6 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
         print(traceback.format_exc())
         return {k: 0.6 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}
 
-def check_critical_matches(scores: dict, user_prefs: UserPreferences) -> dict:
-    """評估是否存在極端不適配的情況"""
-    critical_issues = {
-        'has_critical': False,
-        'reasons': []
-    }
-
-    # 檢查極端不適配情況
-    if scores['space'] < 0.3:
-        critical_issues['has_critical'] = True
-        critical_issues['reasons'].append('space_incompatible')
-    
-    if scores['noise'] < 0.3 and user_prefs.living_space == 'apartment':
-        critical_issues['has_critical'] = True
-        critical_issues['reasons'].append('noise_incompatible')
-    
-    if scores['experience'] < 0.3 and user_prefs.experience_level == 'beginner':
-        critical_issues['has_critical'] = True
-        critical_issues['reasons'].append('too_challenging')
-
-    return critical_issues
-
-def apply_critical_penalty(scores: dict, critical_issues: dict) -> dict:
-    """
-    當發現關鍵不適配時，調整分數
-    
-    首先計算基礎整體分數，然後根據不同的關鍵問題應用懲罰係數
-    """
-    penalized_scores = scores.copy()
-    penalty_factor = 0.6  # 基礎懲罰因子
-    
-    # 先計算基礎整體分數（使用簡單平均）
-    base_overall = sum(scores.values()) / len(scores)
-    penalized_scores['overall'] = base_overall
-    
-    # 根據不同的關鍵問題應用懲罰
-    for reason in critical_issues['reasons']:
-        if reason == 'space_incompatible':
-            penalized_scores['overall'] *= penalty_factor
-            penalized_scores['space'] *= penalty_factor
-        elif reason == 'noise_incompatible':
-            penalized_scores['overall'] *= penalty_factor
-            penalized_scores['noise'] *= penalty_factor
-        elif reason == 'too_challenging':
-            penalized_scores['overall'] *= penalty_factor
-            penalized_scores['experience'] *= penalty_factor
-    
-    # 確保所有分數都在有效範圍內
-    for key in penalized_scores:
-        penalized_scores[key] = max(0.1, min(1.0, penalized_scores[key]))
-    
-    return penalized_scores
 
 def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -> float:
     """計算品種與環境的適應性加成"""
@@ -1563,92 +1511,154 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
     return min(0.2, adaptability_score)
 
 
-def calculate_dynamic_weights(user_prefs: UserPreferences, breed_info: dict) -> dict:
+def calculate_breed_compatibility_score(
+    scores: dict,
+    user_prefs: UserPreferences,
+    breed_info: dict
+) -> float:
     """
-    根據使用者條件動態計算權重
-    這個系統會根據具體情況調整各個評分項目的重要性
+    整合的品種相容性評分系統
+    
+    這個函數整合了：
+    1. 關鍵參數評估
+    2. 動態權重計算
+    3. 環境適應性評估
+    4. 品種特性加成
+    5. 最終分數計算和轉換
     """
-    weights = {
-        'space': 0.25,      # 降低基礎空間權重
-        'exercise': 0.20,
+    # 1. 首先檢查關鍵不適配情況
+    critical_params = {
+        'space': {
+            'threshold': 0.3,
+            'conditions': lambda: True,  # 永遠檢查
+            'penalty': 0.3  # 極低分數
+        },
+        'noise': {
+            'threshold': 0.3,
+            'conditions': lambda p: p.living_space == 'apartment',
+            'penalty': 0.4
+        },
+        'experience': {
+            'threshold': 0.3,
+            'conditions': lambda p: p.experience_level == 'beginner',
+            'penalty': 0.4
+        }
+    }
+
+    # 檢查關鍵參數
+    for param, config in critical_params.items():
+        if scores[param] < config['threshold'] and config['conditions'](user_prefs):
+            return config['penalty']
+
+    # 2. 計算基礎權重
+    base_weights = {
+        'space': 0.35,
+        'exercise': 0.30,
+        'experience': 0.20,
         'grooming': 0.15,
-        'experience': 0.15,
-        'health': 0.15,
+        'health': 0.10,
         'noise': 0.10
     }
-    
-    # 運動時間對權重的影響
-    if user_prefs.exercise_time > 150:
-        weights['exercise'] *= 1.4
-        weights['space'] *= 0.8
-    elif user_prefs.exercise_time < 30:
-        weights['exercise'] *= 0.8
-        weights['health'] *= 1.2
+
+    # 3. 根據具體情況調整權重
+    adjusted_weights = {}
+    for param, weight in base_weights.items():
+        multiplier = 1.0
         
-    # 居住環境對權重的影響
-    if user_prefs.living_space == 'apartment':
-        weights['noise'] *= 1.3
-        weights['space'] *= 1.2
-    elif user_prefs.living_space == 'house_large':
-        weights['exercise'] *= 1.2
-        weights['space'] *= 0.8
+        # 根據具體條件調整權重
+        if param == 'space' and user_prefs.living_space == 'apartment':
+            multiplier *= 1.2
+        elif param == 'exercise' and user_prefs.exercise_time > 150:
+            multiplier *= 1.4
+        # ... 其他調整條件
         
-    # 經驗等級對權重的影響
-    if user_prefs.experience_level == 'beginner':
-        weights['experience'] *= 1.3
-        weights['health'] *= 1.2
-    
-    # 有孩童時的權重調整
-    if user_prefs.has_children:
-        if user_prefs.children_age == 'toddler':
-            weights['temperament'] = 0.20  # 新增性格權重
-            weights['space'] *= 0.8
-    
+        adjusted_weights[param] = weight * multiplier
+
     # 重新正規化權重
-    total = sum(weights.values())
-    return {k: v/total for k, v in weights.items()}
+    total_weight = sum(adjusted_weights.values())
+    normalized_weights = {k: v/total_weight for k, v in adjusted_weights.items()}
 
+    # 4. 計算加權基礎分數
+    base_score = 0
+    for param, weight in normalized_weights.items():
+        score = scores[param]
+        
+        # 非線性調整
+        if score > 0.8:
+            score = min(1.0, score * 1.2)
+        elif score < 0.6:
+            score = score * 0.8
+            
+        base_score += score * weight
 
-def calculate_final_weighted_score(
-    scores: dict,
-    user_prefs: UserPreferences,
-    breed_info: dict,
-    adaptability_bonus: float
-) -> float:
-    """
-    整合動態權重的最終分數計算系統
-    """
-    # 第一步：計算動態權重
-    weights = calculate_dynamic_weights(user_prefs, breed_info)  # 內部函數
-    
-    # 第二步：計算基礎加權分數
-    weighted_base = sum(score * weights[category] for category, score in scores.items())
-    
-    # 第三步：計算品種特性加成
+    # 5. 計算環境適應性加成
+    adaptability_bonus = calculate_environmental_fit(breed_info, user_prefs)
+
+    # 6. 計算品種特性加成
     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
-    
-    # 第四步：最終分數計算
-    final_score = (weighted_base * 0.70) + (breed_bonus * 0.20) + (adaptability_bonus * 0.10)
-    
-    # 第五步：分數轉換
+
+    # 7. 整合最終分數
+    final_score = (base_score * 0.70) + 
+                  (breed_bonus * 0.20) + 
+                  (adaptability_bonus * 0.10)
+
+    # 8. 轉換和限制分數範圍
     return amplify_score_extreme(final_score)
     
 
 def amplify_score_extreme(score: float) -> float:
     """
-    使用S型曲線進行分數轉換，加大差異
+    1. 擴大分數範圍至 0.3-0.95
+    2. 使用分段函數處理不同分數區間
+    3. 加強極端值的影響
+    
+    Args:
+        score: 原始分數 (0-1 範圍)
+    Returns:
+        放大後的分數 (0.3-0.95 範圍)
     """
-    # 基礎範圍
-    base_min = 0.65
-    base_max = 0.95
-    
-    # 正規化
-    normalized = (score - 0.5) / 0.5
-    
-    # S型曲線轉換
-    sigmoid = 1 / (1 + math.exp(-normalized * 4))
+    # 定義分數區間的轉換參數
+    ranges = {
+        'poor': {
+            'range': (0, 0.4),
+            'out_min': 0.3,
+            'out_max': 0.5,
+            'amplification': 1.2  # 加強低分懲罰
+        },
+        'mediocre': {
+            'range': (0.4, 0.6),
+            'out_min': 0.5,
+            'out_max': 0.7,
+            'amplification': 1.0  # 中等分數保持線性
+        },
+        'good': {
+            'range': (0.6, 0.8),
+            'out_min': 0.7,
+            'out_max': 0.85,
+            'amplification': 1.1  # 稍微獎勵好分數
+        },
+        'excellent': {
+            'range': (0.8, 1.0),
+            'out_min': 0.85,
+            'out_max': 0.95,
+            'amplification': 1.3  # 強力獎勵優秀分數
+        }
+    }
     
-    # 映射到目標範圍
-    final = base_min + (base_max - base_min) * sigmoid
+    # 找出分數所屬區間
+    for range_name, config in ranges.items():
+        range_min, range_max = config['range']
+        if range_min <= score <= range_max:
+            # 計算在當前區間的相對位置
+            range_position = (score - range_min) / (range_max - range_min)
+            
+            # 應用放大係數
+            range_position = min(1.0, range_position * config['amplification'])
+            
+            # 轉換到輸出範圍
+            amplified = config['out_min'] + (config['out_max'] - config['out_min']) * range_position
+            
+            return round(max(0.3, min(0.95, amplified)), 4)
     
-    return round(min(base_max, max(base_min, final)), 4)
+    # 如果分數超出範圍，返回最近的有效值
+    return 0.3 if score < 0 else 0.95