Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1073,258 +1073,202 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
 
         # 1. 計算基礎分數
         try:
-            space_score = calculate_space_score(
-                breed_info['Size'], 
-                user_prefs.living_space,
-                user_prefs.space_for_play,
-                breed_info.get('Exercise Needs', 'Moderate')
-            )
-            print(f"空間分數計算結果: {space_score}")
-        except Exception as e:
-            print(f"空間分數計算錯誤: {str(e)}")
-            raise
-
-        try:
-            exercise_score = calculate_exercise_score(
-                breed_info.get('Exercise Needs', 'Moderate'),
-                user_prefs.exercise_time
-            )
-            print(f"運動分數計算結果: {exercise_score}")
-        except Exception as e:
-            print(f"運動分數計算錯誤: {str(e)}")
-            raise
-
-        try:
-            grooming_score = calculate_grooming_score(
-                breed_info.get('Grooming Needs', 'Moderate'),
-                user_prefs.grooming_commitment.lower(),
-                breed_info['Size']
-            )
-            print(f"美容分數計算結果: {grooming_score}")
-        except Exception as e:
-            print(f"美容分數計算錯誤: {str(e)}")
-            raise
-
-        try:
-            experience_score = calculate_experience_score(
-                breed_info.get('Care Level', 'Moderate'),
-                user_prefs.experience_level,
-                breed_info.get('Temperament', '')
+            print("\n=== 開始計算品種相容性分數 ===")
+            print(f"處理品種: {breed_info.get('Breed', 'Unknown')}")
+            print(f"品種信息: {breed_info}")
+            print(f"使用者偏好: {vars(user_prefs)}")
+    
+            # 計算所有基礎分數並整合到字典中
+            scores = {
+                'space': calculate_space_score(
+                    breed_info['Size'], 
+                    user_prefs.living_space,
+                    user_prefs.yard_access != 'no_yard',
+                    breed_info.get('Exercise Needs', 'Moderate')
+                ),
+                'exercise': calculate_exercise_score(
+                    breed_info.get('Exercise Needs', 'Moderate'),
+                    user_prefs.exercise_time
+                ),
+                'grooming': calculate_grooming_score(
+                    breed_info.get('Grooming Needs', 'Moderate'),
+                    user_prefs.grooming_commitment.lower(),
+                    breed_info['Size']
+                ),
+                'experience': calculate_experience_score(
+                    breed_info.get('Care Level', 'Moderate'),
+                    user_prefs.experience_level,
+                    breed_info.get('Temperament', '')
+                ),
+                'health': calculate_health_score(
+                    breed_info.get('Breed', ''),
+                    user_prefs
+                ),
+                'noise': calculate_noise_score(
+                    breed_info.get('Breed', ''),
+                    user_prefs
+                )
+            }
+    
+            # 檢查關鍵不適配情況
+            critical_issues = check_critical_matches(scores, user_prefs)
+            if critical_issues['has_critical']:
+                return apply_critical_penalty(scores, critical_issues)
+    
+            # 計算環境適應性加成
+            adaptability_bonus = calculate_environmental_fit(breed_info, user_prefs)
+            
+            # 計算最終加權分數
+            final_score = calculate_final_weighted_score(
+                scores=scores,
+                user_prefs=user_prefs,
+                breed_info=breed_info,
+                adaptability_bonus=adaptability_bonus
             )
-            print(f"經驗分數計算結果: {experience_score}")
-        except Exception as e:
-            print(f"經驗分數計算錯誤: {str(e)}")
-            raise
-
-        try:
-            # 修正：加入 user_prefs 參數
-            health_score = calculate_health_score(breed_info.get('Breed', ''), user_prefs)
-            print(f"健康分數計算結果: {health_score}")
+    
+            # 更新最終結果
+            scores.update({
+                'overall': final_score,
+                'adaptability_bonus': adaptability_bonus
+            })
+    
+            return scores
+    
         except Exception as e:
-            print(f"健康分數計算錯誤: {str(e)}")
-            raise
+            print(f"\n!!!!! 發生嚴重錯誤 !!!!!")
+            print(f"錯誤類型: {type(e).__name__}")
+            print(f"錯誤訊息: {str(e)}")
+            print(f"完整錯誤追蹤:")
+            print(traceback.format_exc())
+            return {k: 0.6 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}
 
-        try:
-            noise_score = calculate_noise_score(
-                breed_info.get('Breed', ''), 
-                user_prefs
-            )
-            print(f"噪音分數計算結果: {noise_score}")
-        except Exception as e:
-            print(f"噪音分數計算錯誤: {str(e)}")
-            raise
+def check_critical_matches(scores: dict, user_prefs: UserPreferences) -> dict:
+    """評估是否存在極端不適配的情況"""
+    critical_issues = {
+        'has_critical': False,
+        'reasons': []
+    }
 
-        # 整合所有分數到字典中
-        scores = {
-            'space': space_score,
-            'exercise': exercise_score,
-            'grooming': grooming_score,
-            'experience': experience_score,
-            'health': health_score,
-            'noise': noise_score
-        }
+    # 檢查極端不適配情況
+    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')
 
-        print("\n=== 所有基礎分數 ===")
-        for category, score in scores.items():
-            print(f"{category}: {score}")
+    return critical_issues
 
+def apply_critical_penalty(scores: dict, critical_issues: dict) -> dict:
+    """當發現關鍵不適配時，調整分數"""
+    penalized_scores = scores.copy()
+    penalty_factor = 0.6
+    
+    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
+    
+    return penalized_scores
 
-        # 首先處理極端情況
-        def check_critical_issues(scores: dict, breed_info: dict) -> float:
-            """
-            檢查關鍵問題並計算懲罰係數
-            """
-            penalty = 1.0
-            
-            # 檢查經驗分數 - 如果太低表示品種太難駕馭
-            if scores['experience'] < 0.3:
-                penalty *= 0.8
-            
-            # 檢查空間分數 - 特別是對公寓的情況
-            if user_prefs.living_space == 'apartment' and scores['space'] < 0.4:
-                penalty *= 0.85
+def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -> float:
+    """計算品種與環境的適應性加成"""
+    adaptability_score = 0.0
+    description = breed_info.get('Description', '').lower()
+    temperament = breed_info.get('Temperament', '').lower()
+    
+    # 環境適應性評估
+    if user_prefs.living_space == 'apartment':
+        if 'adaptable' in temperament or 'apartment' in description:
+            adaptability_score += 0.1
+        if breed_info.get('Size') == 'Small':
+            adaptability_score += 0.05
+    elif user_prefs.living_space == 'house_large':
+        if 'active' in temperament or 'energetic' in description:
+            adaptability_score += 0.1
             
-            # 檢查健康分數 - 健康問題是重要考量
-            if scores['health'] < 0.4:
-                penalty *= 0.9
-                
-            return penalty
+    # 氣候適應性
+    if user_prefs.climate in description or user_prefs.climate in temperament:
+        adaptability_score += 0.05
+        
+    return min(0.2, adaptability_score)
 
-        # # 計算權重和加權分數
-        # def calculate_weighted_score(scores: dict) -> float:
-        #     """
-        #     使用動態權重計算加權分數
-        #     """
-        #     base_weights = {
-        #         'space': 0.28,      
-        #         'exercise': 0.18,   
-        #         'grooming': 0.12,   
-        #         'experience': 0.22, 
-        #         'health': 0.12,     
-        #         'noise': 0.08      
-        #     }
-            
-        #     # 根據居住環境調整權重
-        #     if user_prefs.living_space == 'apartment':
-        #         base_weights['space'] *= 1.2
-        #         base_weights['noise'] *= 1.2
-            
-        #     # 根據經驗等級調整權重
-        #     if user_prefs.experience_level == 'beginner':
-        #         base_weights['experience'] *= 1.3
-            
-        #     # 重新正規化權重
-        #     total_weight = sum(base_weights.values())
-        #     weights = {k: v/total_weight for k, v in base_weights.items()}
-            
-        #     # 計算加權分數
-        #     return sum(score * weights[category] for category, score in scores.items())
+def calculate_final_weighted_score(scores: dict, user_prefs: UserPreferences, 
+                                 breed_info: dict, adaptability_bonus: float) -> float:
+    """計算最終加權分數"""
+    base_weights = {
+        'space': 0.25,
+        'exercise': 0.20,
+        'grooming': 0.15,
+        'experience': 0.18,
+        'health': 0.12,
+        'noise': 0.10
+    }
 
-        def calculate_weighted_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
-            """
-            計算加權分數的函數
-            
-            Parameters:
-            scores: dict - 包含各項評分的字典
-            user_prefs: UserPreferences - 使用者偏好設定
-            breed_info: dict - 品種資訊
-            
-            Returns:
-            float: 加權後的最終分數
-            """
-            # 基礎權重設定
-            base_weights = {
-                'space': 0.25,      
-                'exercise': 0.20,   
-                'grooming': 0.15,   
-                'experience': 0.18, 
-                'health': 0.12,     
-                'noise': 0.10      
-            }
-            
-            # 根據使用者經驗調整權重
-            if user_prefs.experience_level == 'beginner':
-                base_weights['experience'] *= 1.2
-                base_weights['health'] *= 1.1
-                base_weights['grooming'] *= 0.9
-            elif user_prefs.experience_level == 'advanced':
-                base_weights['exercise'] *= 1.2
-                base_weights['experience'] *= 0.8
-                
-            # 根據居住環境調整權重
-            if user_prefs.living_space == 'apartment':
-                base_weights['noise'] *= 1.3
-                base_weights['space'] *= 1.2
-            elif user_prefs.living_space == 'house_large':
-                base_weights['exercise'] *= 1.2
-                base_weights['space'] *= 0.9
-        
-            # 有孩童時的權重調整
-            if user_prefs.has_children:
-                base_weights['noise'] *= 1.2
-                base_weights['health'] *= 1.1
-                
-            # 重新正規化權重
-            total_weight = sum(base_weights.values())
-            weights = {k: v/total_weight for k, v in base_weights.items()}
-            
-            # 計算加權分數
-            weighted_score = sum(score * weights[category] for category, score in scores.items())
-            
-            # 計算品種特性加成
-            breed_bonus = calculate_breed_characteristic_bonus(breed_info, user_prefs)
-            
-            # 混合基礎分數和特性加成
-            final_score = (weighted_score * 0.85) + (breed_bonus * 0.15)
-            
-            return min(0.95, max(0.55, final_score))
-        
-        def calculate_breed_characteristic_bonus(breed_info: dict, user_prefs: UserPreferences) -> float:
-            """
-            計算品種特性加成，增加品種多樣性
-            """
-            bonus = 0.0
-            temperament = breed_info.get('Temperament', '').lower()
-            description = breed_info.get('Description', '').lower()
-            
-            # 品種類型加成
-            breed_types = {
-                'working': {'keywords': ['working', 'guard', 'protection'], 'bonus': 0.05},
-                'companion': {'keywords': ['companion', 'friendly', 'affectionate'], 'bonus': 0.05},
-                'sporting': {'keywords': ['hunting', 'sporting', 'athletic'], 'bonus': 0.05},
-                'herding': {'keywords': ['herding', 'shepherd', 'cattle'], 'bonus': 0.05}
-            }
-            
-            # 根據使用場景給予特定加成
-            for breed_type, info in breed_types.items():
-                if any(keyword in description or keyword in temperament for keyword in info['keywords']):
-                    if user_prefs.has_children and breed_type == 'companion':
-                        bonus += info['bonus'] * 1.5
-                    elif user_prefs.exercise_type == 'active_training' and breed_type in ['working', 'sporting']:
-                        bonus += info['bonus'] * 1.3
-                    else:
-                        bonus += info['bonus']
-                        
-            # 特殊加成（增加多樣性）
-            if 'rare' in description or 'unique' in description:
-                bonus += 0.03
-            if 'independent' in temperament and user_prefs.experience_level == 'advanced':
-                bonus += 0.04
-                
-            return min(0.15, bonus)  # 限制最大加成
-            
+    # 根據居住環境動態調整權重
+    if user_prefs.living_space == 'apartment':
+        base_weights['space'] *= 1.4
+        base_weights['noise'] *= 1.3
+        base_weights['exercise'] *= 0.8
+    elif user_prefs.living_space == 'house_large':
+        base_weights['exercise'] *= 1.3
+        base_weights['space'] *= 0.9
+        base_weights['noise'] *= 0.8
 
-        # 計算最終分數
-        def calculate_final_score(base_score: float, penalty: float) -> float:
-            """
-            計算並調整最終分數，確保合理的分數分布
-            """
-            # 應用懲罰係數
-            adjusted_score = base_score * penalty
-            
-            # 將分數映射到期望的範圍（0.55-0.95）
-            mapped_score = 0.55 + (adjusted_score * 0.4)
-            
-            # 確保分數在合理範圍內
-            final = max(0.55, min(0.95, mapped_score))
-            
-            return round(final, 4)
+    # 根據經驗等級調整權重
+    if user_prefs.experience_level == 'beginner':
+        base_weights['experience'] *= 1.5
+        base_weights['health'] *= 1.2
+    elif user_prefs.experience_level == 'advanced':
+        base_weights['exercise'] *= 1.2
+        base_weights['experience'] *= 0.8
 
-        # 執行計算流程
-        penalty = check_critical_issues(scores, breed_info)
-        weighted_score = calculate_weighted_score(scores, user_prefs, breed_info)
-        final_score = calculate_final_score(weighted_score, penalty)
+    # 有孩童時的特殊調整
+    if user_prefs.has_children:
+        base_weights['noise'] *= 1.3
+        base_weights['health'] *= 1.2
 
-        # 準備返回結果
-        scores = {k: round(v, 4) for k, v in scores.items()}
-        scores['overall'] = final_score
-        
-        return scores
+    # 重新正規化權重
+    total_weight = sum(base_weights.values())
+    weights = {k: v/total_weight for k, v in base_weights.items()}
 
-    except Exception as e:
-        print(f"\n!!!!! 發生嚴重錯誤 !!!!!")
-        print(f"錯誤類型: {type(e).__name__}")
-        print(f"錯誤訊息: {str(e)}")
-        print(f"完整錯誤追蹤:")
-        print(traceback.format_exc())
-        return {k: 0.6 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}
+    # 計算基礎加權分數
+    weighted_base = sum(score * weights[category] for category, score in scores.items())
+    
+    # 品種特性加成
+    breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+    
+    # 計算最終分數
+    final_score = (weighted_base * 0.75) + (breed_bonus * 0.15) + (adaptability_bonus * 0.10)
+    
+    # 擴大分數範圍
+    amplified_score = amplify_score_range(final_score)
+    
+    return round(amplified_score, 4)
+
+def amplify_score_range(score: float) -> float:
+    """擴大分數範圍，使差異更明顯"""
+    min_score = 0.45
+    max_score = 0.95
+    
+    # 正規化到 0-1 範圍
+    normalized = (score - 0.5) / 0.5
+    
+    # 非線性轉換
+    amplified = math.pow(abs(normalized), 1.5) * math.copysign(1, normalized)
+    
+    # 映射回目標範圍
+    final = min_score + (max_score - min_score) * ((amplified + 1) / 2)
+    
+    return min(max_score, max(min_score, final))