Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -129,39 +129,37 @@ class UserPreferences:
 
 @staticmethod
 def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> float:
-    """
-    計算品種額外加分，考慮多個維度但不包含家庭相容性評分
-    """
+    """計算品種額外加分，強化進階使用者的評分"""
     bonus = 0.0
     temperament = breed_info.get('Temperament', '').lower()
     description = breed_info.get('Description', '').lower()
     
-    # 1. 壽命加分（最高0.05）
+    # 1. 壽命加分（最高0.08）- 提高上限
     try:
         lifespan = breed_info.get('Lifespan', '10-12 years')
         years = [int(x) for x in lifespan.split('-')[0].split()[0:1]]
-        longevity_bonus = min(0.05, (max(years) - 10) * 0.01)
+        longevity_bonus = min(0.08, (max(years) - 10) * 0.015)  # 提高係數
         bonus += longevity_bonus
     except:
         pass
 
-    # 2. 性格特徵加分（最高0.15）
+    # 2. 性格特徵加分（最高0.20）- 提高上限
     positive_traits = {
-        'friendly': 0.05,           
-        'gentle': 0.05,
-        'patient': 0.05,
-        'intelligent': 0.04,
-        'adaptable': 0.04,
-        'affectionate': 0.04,
-        'easy-going': 0.03,         
-        'calm': 0.03                
+        'friendly': 0.06,           
+        'gentle': 0.06,
+        'patient': 0.06,
+        'intelligent': 0.05,
+        'adaptable': 0.05,
+        'affectionate': 0.05,
+        'easy-going': 0.04,         
+        'calm': 0.04                
     }
     
-    # 根據經驗等級調整負面特徵的懲罰程度
+    # 根據經驗等級調整負面特徵的影響
     experience_multiplier = {
         'beginner': 1.3,      
-        'intermediate': 1.0,
-        'advanced': 0.8       
+        'intermediate': 0.8,
+        'advanced': 0.5       # 大幅降低進階使用者的負面特徵懲罰
     }.get(user_prefs.experience_level, 1.0)
     
     negative_traits = {
@@ -174,86 +172,63 @@ def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> fl
     }
     
     personality_score = sum(value for trait, value in positive_traits.items() if trait in temperament)
+    if user_prefs.experience_level == 'advanced':
+        personality_score *= 1.2  # 進階使用者得到更多正面特徵加分
     personality_score += sum(value for trait, value in negative_traits.items() if trait in temperament)
-    bonus += max(-0.15, min(0.15, personality_score))
+    bonus += max(-0.15, min(0.20, personality_score))
 
-    # 3. 適應性加分（最高0.1）
+    # 3. 適應性加分（最高0.15）- 提高上限
     adaptability_bonus = 0.0
     if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
-        adaptability_bonus += 0.05
+        adaptability_bonus += 0.07
     if 'adaptable' in temperament or 'versatile' in temperament:
-        adaptability_bonus += 0.05
+        adaptability_bonus += 0.08
         
-    # 考慮更多環境適應因素
+    # 考慮環境適應因素
     if user_prefs.yard_access == "no_yard":
         if "needs space" in description or "requires yard" in description:
-            adaptability_bonus -= 0.05
+            adaptability_bonus -= 0.05 * experience_multiplier  # 根據經驗調整懲罰
     elif user_prefs.yard_access == "private_yard":
         if "active" in description or "energetic" in description:
-            adaptability_bonus += 0.03
+            adaptability_bonus += 0.05
             
-    # 氣候適應性
-    climate_terms = {
-        'cold': ['thick coat', 'winter', 'cold climate'],
-        'hot': ['short coat', 'warm climate', 'heat tolerant'],
-        'moderate': ['adaptable', 'all climate']
-    }
-    if any(term in description for term in climate_terms[user_prefs.climate]):
-        adaptability_bonus += 0.02
-        
-    bonus += min(0.1, adaptability_bonus)
+    bonus += min(0.15, adaptability_bonus)
 
-    # 4. 專門技能評估（最高0.1）
+    # 4. 專門技能評估（最高0.15）- 提高上限和進階使用者加分
     skill_bonus = 0.0
-    exercise_level = user_prefs.exercise_time / 60.0  # 轉換為小時
+    exercise_level = user_prefs.exercise_time / 60.0
     
     special_abilities = {
-        'working': 0.03 if exercise_level >= 1.5 else 0.01,
-        'herding': 0.03 if exercise_level >= 1.5 else 0.01,
-        'hunting': 0.03 if exercise_level >= 1.5 else 0.01,
-        'tracking': 0.03 if exercise_level >= 1.0 else 0.02,
-        'agility': 0.02 if exercise_level >= 1.0 else 0.01,
-        'sporting': 0.02 if exercise_level >= 1.2 else 0.01  # 新增運動犬種考量
+        'working': 0.05 if exercise_level >= 1.5 else 0.02,
+        'herding': 0.05 if exercise_level >= 1.5 else 0.02,
+        'hunting': 0.05 if exercise_level >= 1.5 else 0.02,
+        'tracking': 0.04 if exercise_level >= 1.0 else 0.02,
+        'agility': 0.04 if exercise_level >= 1.0 else 0.02,
+        'sporting': 0.04 if exercise_level >= 1.2 else 0.02
     }
     
     for ability, value in special_abilities.items():
         if ability in temperament.lower() or ability in description:
-            # 根據使用者經驗和時間可用性調整技能加分
-            time_multiplier = 1.2 if user_prefs.time_availability == 'flexible' else 0.8
+            # 進階使用者在專門技能方面得到更多加分
             if user_prefs.experience_level == 'advanced':
-                skill_bonus += value * 1.2 * time_multiplier
-            elif user_prefs.experience_level == 'beginner':
-                skill_bonus += value * 0.7 * time_multiplier
+                skill_bonus += value * 1.5
+            elif user_prefs.experience_level == 'intermediate':
+                skill_bonus += value * 1.2
             else:
-                skill_bonus += value * time_multiplier
+                skill_bonus += value
                 
-    bonus += min(0.1, skill_bonus)
-
-    # 5. 特殊需求評估（最高0.1/-0.15）
-    special_needs_score = 0.0
+    # 根據時間可用性調整技能加分
+    time_multiplier = {
+        'flexible': 1.2,
+        'moderate': 1.0,
+        'limited': 0.8
+    }.get(user_prefs.time_availability, 1.0)
     
-    # 檢查特殊訓練需求
-    if any(term in description for term in ['requires extensive training', 'needs firm training']):
-        if user_prefs.experience_level == 'beginner':
-            special_needs_score -= 0.08
-        elif user_prefs.experience_level == 'intermediate':
-            special_needs_score -= 0.04
-            
-    # 檢查社交需求
-    if 'social needs' in description or 'requires companionship' in description:
-        if user_prefs.time_availability == 'limited':
-            special_needs_score -= 0.06
-        elif user_prefs.time_availability == 'flexible':
-            special_needs_score += 0.02
-            
-    # 檢查獨立性
-    if 'independent' in temperament:
-        if user_prefs.time_availability == 'limited':
-            special_needs_score += 0.03
-    
-    bonus += max(-0.15, min(0.1, special_needs_score))
+    skill_bonus *= time_multiplier
+    bonus += min(0.15, skill_bonus)
 
-    return min(0.5, max(-0.25, bonus))
+    # 最終分數範圍調整，提高上限
+    return min(0.6, max(-0.20, bonus))
 
 
 @staticmethod
@@ -638,130 +613,99 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
         #     final_score = max(0.2, min(1.0, score + temperament_adjustments))
         #     return final_score
 
-        def calculate_experience_score(care_level: str, user_experience: str, temperament: str, has_children: bool = False) -> float:
+        def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
             """
-            計算使用者經驗與品種需求的匹配分數，加入了更嚴格的評估標準
+            計算使用者經驗與品種需求的匹配分數，強化進階使用者的評分
             """
-            # 即使是進階使用者也不應該完全無視品種難度
+            # 調整基礎分數矩陣，提高 advanced 的基本分數
             base_scores = {
                 "High": {
-                    "beginner": 0.12,
-                    "intermediate": 0.65,
-                    "advanced": 0.85  
-                },
-                "Moderate": {
                     "beginner": 0.35,
                     "intermediate": 0.75,
-                    "advanced": 0.90
+                    "advanced": 0.92    # 提高上限
+                },
+                "Moderate": {
+                    "beginner": 0.45,
+                    "intermediate": 0.82,
+                    "advanced": 0.95
                 },
                 "Low": {
-                    "beginner": 0.65,
+                    "beginner": 0.60,
                     "intermediate": 0.85,
-                    "advanced": 0.92
+                    "advanced": 0.98
                 }
             }
             
-            # 取得基礎分數
             score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
             
-            # 品種難度評估 
-            breed_difficulty_penalty = 0.0
-            difficult_characteristics = {
-                'working': 0.08,
-                'guardian': 0.10,
-                'primitive': 0.12,
-                'independent': 0.08,
-                'strong-willed': 0.07
-            }
-            
-            for trait, penalty in difficult_characteristics.items():
-                if trait in temperament.lower():
-                    # 即使是進階使用者也會受到一定程度的懲罰
-                    if user_experience == "advanced":
-                        breed_difficulty_penalty += penalty * 0.4
-                    elif user_experience == "intermediate":
-                        breed_difficulty_penalty += penalty * 0.7
-                    else:
-                        breed_difficulty_penalty += penalty
-        
-            # 性格特徵評估 
+            # 性格特徵評估
             temperament_lower = temperament.lower()
             temperament_adjustments = 0.0
             
-            if user_experience == "beginner":
-                difficult_traits = {
-                    'stubborn': -0.15,
-                    'independent': -0.12,
-                    'dominant': -0.12,
-                    'protective': -0.10,
-                    'aloof': -0.08
-                }
-                easy_traits = {
-                    'gentle': 0.08,
-                    'friendly': 0.08,
-                    'eager to please': 0.08,
-                    'patient': 0.06
+            if user_experience == "advanced":
+                # 進階使用者的特徵評估
+                advanced_traits = {
+                    'intelligent': 0.08,       # 提高正面特徵加分
+                    'independent': 0.06,
+                    'strong-willed': 0.05,
+                    'energetic': 0.05,
+                    'protective': 0.04,
+                    'dominant': -0.02,         # 降低負面特徵懲罰
+                    'stubborn': -0.02,
+                    'aggressive': -0.05
                 }
                 
-                for trait, penalty in difficult_traits.items():
-                    if trait in temperament_lower:
-                        temperament_adjustments += penalty * 1.2
-                
-                for trait, bonus in easy_traits.items():
+                for trait, adjustment in advanced_traits.items():
                     if trait in temperament_lower:
-                        temperament_adjustments += bonus
+                        temperament_adjustments += adjustment
                         
             elif user_experience == "intermediate":
                 moderate_traits = {
-                    'intelligent': 0.04,
-                    'athletic': 0.03,
-                    'versatile': 0.03,
+                    'intelligent': 0.05,
+                    'adaptable': 0.04,
+                    'easy-going': 0.04,
                     'stubborn': -0.06,
-                    'independent': -0.05
+                    'independent': -0.05,
+                    'dominant': -0.05,
+                    'aggressive': -0.08
                 }
                 
                 for trait, adjustment in moderate_traits.items():
                     if trait in temperament_lower:
                         temperament_adjustments += adjustment
-                        
-            else:  # advanced
-                # 即使是進階使用者，某些特徵也應該被視為挑戰而非優勢
-                advanced_traits = {
-                    'stubborn': 0.02,        
-                    'independent': 0.02,
-                    'intelligent': 0.04,
-                    'protective': -0.02,      
-                    'strong-willed': -0.02
+            
+            else:  # beginner
+                beginner_traits = {
+                    'gentle': 0.05,
+                    'friendly': 0.05,
+                    'easy-going': 0.04,
+                    'stubborn': -0.10,
+                    'independent': -0.08,
+                    'dominant': -0.08,
+                    'aggressive': -0.12
                 }
                 
-                for trait, adjustment in advanced_traits.items():
+                for trait, adjustment in beginner_traits.items():
                     if trait in temperament_lower:
                         temperament_adjustments += adjustment
-        
-            # 如果有小孩，增加額外的安全考量
-            if has_children:
-                safety_penalty = 0.0
-                risky_traits = {
-                    'protective': 0.05,
-                    'territorial': 0.06,
-                    'dominant': 0.07,
-                    'aggressive': 0.10,
-                    'strong-willed': 0.05
+            
+            # 特殊能力評估 - 對進階使用者加分
+            if user_experience == "advanced":
+                special_abilities = {
+                    'working': 0.04,
+                    'hunting': 0.04,
+                    'herding': 0.04,
+                    'guard': 0.03,
+                    'agility': 0.03
                 }
                 
-                for trait, penalty in risky_traits.items():
-                    if trait in temperament_lower:
-                        # 即使是進階使用者，有小孩的情況下也要特別注意
-                        if user_experience == "advanced":
-                            safety_penalty += penalty * 0.7  
-                        else:
-                            safety_penalty += penalty
-                
-                temperament_adjustments -= safety_penalty
-        
-            # 確保最終分數在合理範圍內，且有適當的上限
-            final_score = score - breed_difficulty_penalty + temperament_adjustments
-            return max(0.2, min(0.92, final_score))  
+                for ability, bonus in special_abilities.items():
+                    if ability in temperament_lower:
+                        temperament_adjustments += bonus
+            
+            # 確保最終分數在合理範圍內
+            final_score = max(0.3, min(0.98, score + temperament_adjustments))
+            return final_score
 
         def calculate_health_score(breed_name: str) -> float:
             """計算品種健康分數"""
@@ -939,34 +883,76 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
         # 計算加權總分
         weighted_score = sum(score * weights[category] for category, score in scores.items())
 
-        def amplify_score(score):
-            """
-            優化分數放大函數，確保分數範圍合理且結果一致
-            """
-            # 基礎調整
-            adjusted = (score - 0.35) * 1.8
+        # def amplify_score(score):
+        #     """
+        #     優化分數放大函數，確保分數範圍合理且結果一致
+        #     """
+        #     # 基礎調整
+        #     adjusted = (score - 0.35) * 1.8
             
-            # 使用 3.2 次方使曲線更平滑
-            amplified = pow(adjusted, 3.2) / 5.8 + score
+        #     # 使用 3.2 次方使曲線更平滑
+        #     amplified = pow(adjusted, 3.2) / 5.8 + score
             
-            # 特別處理高分區間，確保不超過95%
-            if amplified > 0.90:
-                # 壓縮高分區間，確保最高到95%
-                amplified = 0.90 + (amplified - 0.90) * 0.5
+        #     # 特別處理高分區間，確保不超過95%
+        #     if amplified > 0.90:
+        #         # 壓縮高分區間，確保最高到95%
+        #         amplified = 0.90 + (amplified - 0.90) * 0.5
             
-            # 確保最終分數在合理範圍內（0.55-0.95）
-            final_score = max(0.55, min(0.95, amplified))
+        #     # 確保最終分數在合理範圍內（0.55-0.95）
+        #     final_score = max(0.55, min(0.95, amplified))
             
-            # 四捨五入到小數點後第三位
-            return round(final_score, 3)
+        #     # 四捨五入到小數點後第三位
+        #     return round(final_score, 3)
         
-        final_score = amplify_score(weighted_score)
+        # final_score = amplify_score(weighted_score)
+
+        # # 四捨五入所有分數
+        # scores = {k: round(v, 4) for k, v in scores.items()}
+        # scores['overall'] = round(final_score, 4)
 
-        # 四捨五入所有分數
-        scores = {k: round(v, 4) for k, v in scores.items()}
-        scores['overall'] = round(final_score, 4)
+        # return scores
 
-        return scores
+        def amplify_score(score):
+            """
+            優化分數放大函數，確保更合理的分數分布和品種間的差異
+            
+            1. 調整基礎計算係數，使分數差異更明顯
+            2. 重新設計高分區間的處理
+            3. 確保進階使用者能獲得更高分數
+            4. 維持適當的分數下限
+            """
+            # 第一階段：基礎調整
+            # 降低基礎調整係數，使分數變化更平滑
+            adjusted = (score - 0.30) * 1.5
+            
+            # 第二階段：非線性轉換
+            # 使用較小的指數，讓分數差異更明顯
+            amplified = pow(adjusted, 2.8) / 4.2 + score
+            
+            # 第三階段：分數區間處理
+            if amplified > 0.85:
+                # 高分區間的處理更細緻
+                extra = (amplified - 0.85)
+                amplified = 0.85 + extra * 0.6
+            elif amplified < 0.65:
+                # 低分區間給予適當提升
+                boost = (0.65 - amplified) * 0.3
+                amplified += boost
+                
+            # 第四階段：確保分數在合理範圍內
+            # 提高最低分數，降低最高分數
+            final_score = max(0.60, min(0.92, amplified))
+            
+            # 第五階段：微調
+            # 讓分數更容易落在中間區間
+            if 0.75 <= final_score <= 0.85:
+                variance = (random.random() - 0.5) * 0.02
+                final_score += variance
+            
+            # 確保最終分數在絕對範圍內
+            final_score = max(0.60, min(0.92, final_score))
+            
+            return round(final_score, 3)
 
     except Exception as e:
         print(f"Error details: {str(e)}")