Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -28,207 +28,103 @@ class UserPreferences:
             self.barking_acceptance = self.noise_tolerance
 
 
-# @staticmethod
-# def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> float:
-#     """計算品種額外加分"""
-#     bonus = 0.0
-#     temperament = breed_info.get('Temperament', '').lower()
-    
-#     # 1. 壽命加分（最高0.05）
-#     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)
-#         bonus += longevity_bonus
-#     except:
-#         pass
-
-#     # 2. 性格特徵加分（最高0.15）
-#     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                
-#     }
-    
-#     negative_traits = {
-#         'aggressive': -0.08,        
-#         'stubborn': -0.06,
-#         'dominant': -0.06,
-#         'aloof': -0.04,
-#         'nervous': -0.05,           
-#         'protective': -0.04         
-#     }
-    
-#     personality_score = sum(value for trait, value in positive_traits.items() if trait in temperament)
-#     personality_score += sum(value for trait, value in negative_traits.items() if trait in temperament)
-#     bonus += max(-0.15, min(0.15, personality_score))
-
-#     # 3. 適應性加分（最高0.1）
-#     adaptability_bonus = 0.0
-#     if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
-#         adaptability_bonus += 0.05
-#     if 'adaptable' in temperament or 'versatile' in temperament:
-#         adaptability_bonus += 0.05
-#     bonus += min(0.1, adaptability_bonus)
-
-#     # 4. 家庭相容性（最高0.1）
-#     if user_prefs.has_children:
-#         family_traits = {
-#             'good with children': 0.06,  
-#             'patient': 0.05,
-#             'gentle': 0.05,
-#             'tolerant': 0.04,           
-#             'playful': 0.03             
-#         }
-#         unfriendly_traits = {
-#             'aggressive': -0.08,        
-#             'nervous': -0.07,
-#             'protective': -0.06,
-#             'territorial': -0.05        
-#         }
-        
-#         # 年齡評估這樣能更細緻
-#         age_adjustments = {
-#             'toddler': {'bonus_mult': 0.7, 'penalty_mult': 1.3},
-#             'school_age': {'bonus_mult': 1.0, 'penalty_mult': 1.0},
-#             'teenager': {'bonus_mult': 1.2, 'penalty_mult': 0.8}
-#         }
-        
-#         adj = age_adjustments.get(user_prefs.children_age, 
-#                                 {'bonus_mult': 1.0, 'penalty_mult': 1.0})
-        
-#         family_bonus = sum(value for trait, value in family_traits.items() 
-#                           if trait in temperament) * adj['bonus_mult']
-#         family_penalty = sum(value for trait, value in unfriendly_traits.items() 
-#                            if trait in temperament) * adj['penalty_mult']
-        
-#         bonus += min(0.15, max(-0.2, family_bonus + family_penalty))
-
-    
-#     # 5. 專門技能加分（最高0.1）
-#     skill_bonus = 0.0
-#     special_abilities = {
-#         'working': 0.03,
-#         'herding': 0.03,
-#         'hunting': 0.03,
-#         'tracking': 0.03,
-#         'agility': 0.02
-#     }
-#     for ability, value in special_abilities.items():
-#         if ability in temperament.lower():
-#             skill_bonus += value
-#     bonus += min(0.1, skill_bonus)
-
-#     return min(0.5, max(-0.25, bonus))
-
-
 @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.08）- 提高上限
+    # 1. 壽命加分（最高0.05）
     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.08, (max(years) - 10) * 0.015)  # 提高係數
+        longevity_bonus = min(0.05, (max(years) - 10) * 0.01)
         bonus += longevity_bonus
     except:
         pass
 
-    # 2. 性格特徵加分（最高0.20）- 提高上限
+    # 2. 性格特徵加分（最高0.15）
     positive_traits = {
-        '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                
+        '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                
     }
     
-    # 根據經驗等級調整負面特徵的影響
-    experience_multiplier = {
-        'beginner': 1.3,      
-        'intermediate': 0.8,
-        'advanced': 0.5       # 大幅降低進階使用者的負面特徵懲罰
-    }.get(user_prefs.experience_level, 1.0)
-    
     negative_traits = {
-        'aggressive': -0.08 * experience_multiplier,        
-        'stubborn': -0.06 * experience_multiplier,
-        'dominant': -0.06 * experience_multiplier,
-        'aloof': -0.04 * experience_multiplier,
-        'nervous': -0.05 * experience_multiplier,           
-        'protective': -0.04 * experience_multiplier         
+        'aggressive': -0.08,        
+        'stubborn': -0.06,
+        'dominant': -0.06,
+        'aloof': -0.04,
+        'nervous': -0.05,           
+        'protective': -0.04         
     }
     
     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.20, personality_score))
+    bonus += max(-0.15, min(0.15, personality_score))
 
-    # 3. 適應性加分（最高0.15）- 提高上限
+    # 3. 適應性加分（最高0.1）
     adaptability_bonus = 0.0
     if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
-        adaptability_bonus += 0.07
+        adaptability_bonus += 0.05
     if 'adaptable' in temperament or 'versatile' in temperament:
-        adaptability_bonus += 0.08
+        adaptability_bonus += 0.05
+    bonus += min(0.1, adaptability_bonus)
+
+    # 4. 家庭相容性（最高0.1）
+    if user_prefs.has_children:
+        family_traits = {
+            'good with children': 0.06,  
+            'patient': 0.05,
+            'gentle': 0.05,
+            'tolerant': 0.04,           
+            'playful': 0.03             
+        }
+        unfriendly_traits = {
+            'aggressive': -0.08,        
+            'nervous': -0.07,
+            'protective': -0.06,
+            'territorial': -0.05        
+        }
         
-    # 考慮環境適應因素
-    if user_prefs.yard_access == "no_yard":
-        if "needs space" in description or "requires yard" in description:
-            adaptability_bonus -= 0.05 * experience_multiplier  # 根據經驗調整懲罰
-    elif user_prefs.yard_access == "private_yard":
-        if "active" in description or "energetic" in description:
-            adaptability_bonus += 0.05
-            
-    bonus += min(0.15, adaptability_bonus)
+        # 年齡評估這樣能更細緻
+        age_adjustments = {
+            'toddler': {'bonus_mult': 0.7, 'penalty_mult': 1.3},
+            'school_age': {'bonus_mult': 1.0, 'penalty_mult': 1.0},
+            'teenager': {'bonus_mult': 1.2, 'penalty_mult': 0.8}
+        }
+        
+        adj = age_adjustments.get(user_prefs.children_age, 
+                                {'bonus_mult': 1.0, 'penalty_mult': 1.0})
+        
+        family_bonus = sum(value for trait, value in family_traits.items() 
+                          if trait in temperament) * adj['bonus_mult']
+        family_penalty = sum(value for trait, value in unfriendly_traits.items() 
+                           if trait in temperament) * adj['penalty_mult']
+        
+        bonus += min(0.15, max(-0.2, family_bonus + family_penalty))
 
-    # 4. 專門技能評估（最高0.15）- 提高上限和進階使用者加分
-    skill_bonus = 0.0
-    exercise_level = user_prefs.exercise_time / 60.0
     
+    # 5. 專門技能加分（最高0.1）
+    skill_bonus = 0.0
     special_abilities = {
-        '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
+        'working': 0.03,
+        'herding': 0.03,
+        'hunting': 0.03,
+        'tracking': 0.03,
+        'agility': 0.02
     }
-    
     for ability, value in special_abilities.items():
-        if ability in temperament.lower() or ability in description:
-            # 進階使用者在專門技能方面得到更多加分
-            if user_prefs.experience_level == 'advanced':
-                skill_bonus += value * 1.5
-            elif user_prefs.experience_level == 'intermediate':
-                skill_bonus += value * 1.2
-            else:
-                skill_bonus += value
-                
-    # 根據時間可用性調整技能加分
-    time_multiplier = {
-        'flexible': 1.2,
-        'moderate': 1.0,
-        'limited': 0.8
-    }.get(user_prefs.time_availability, 1.0)
-    
-    skill_bonus *= time_multiplier
-    bonus += min(0.15, skill_bonus)
+        if ability in temperament.lower():
+            skill_bonus += value
+    bonus += min(0.1, skill_bonus)
 
-    # 最終分數範圍調整，提高上限
-    return min(0.6, max(-0.20, bonus))
+    return min(0.5, max(-0.25, bonus))
 
 
 @staticmethod
@@ -507,206 +403,113 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return base_score
             
 
-        # def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
-        #     """
-        #     計算使用者經驗與品種需求的匹配分數
-            
-        #     參數說明:
-        #     care_level: 品種的照顧難度 ("High", "Moderate", "Low")
-        #     user_experience: 使用者經驗等級 ("beginner", "intermediate", "advanced") 
-        #     temperament: 品種的性格特徵描述
-            
-        #     返回:
-        #     float: 0.2-1.0 之間的匹配分數
-        #     """
-        #     # 基礎分數矩陣 - 更大的分數差異來反映經驗重要性
-        #     base_scores = {
-        #         "High": {
-        #             "beginner": 0.12,     # 降低起始分，反映高難度品種對新手的挑戰
-        #             "intermediate": 0.65,  # 中級玩家可以應付，但仍有改善空間
-        #             "advanced": 1.0       # 資深者能完全勝任
-        #         },
-        #         "Moderate": {
-        #             "beginner": 0.35,    # 適中難度對新手來說仍具挑戰
-        #             "intermediate": 0.82, # 中級玩家有很好的勝任能力
-        #             "advanced": 1.0      # 資深者完全勝任
-        #         },
-        #         "Low": {
-        #             "beginner": 0.72,    # 低難度品種適合新手
-        #             "intermediate": 0.92, # 中級玩家幾乎完全勝任
-        #             "advanced": 1.0      # 資深者完全勝任
-        #         }
-        #     }
-            
-        #     # 取得基礎分數
-        #     score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
-            
-        #     # 性格特徵評估 - 根據經驗等級調整權重
-        #     temperament_lower = temperament.lower()
-        #     temperament_adjustments = 0.0
-            
-        #     if user_experience == "beginner":
-        #         # 新手不適合的特徵 - 更嚴格的懲罰
-        #         difficult_traits = {
-        #             'stubborn': -0.15,      # 加重固執的懲罰
-        #             'independent': -0.12,    # 加重獨立性的懲罰
-        #             'dominant': -0.12,       # 加重支配性的懲罰
-        #             'strong-willed': -0.10,  # 加重強勢的懲罰
-        #             'protective': -0.08,     # 加重保護性的懲罰
-        #             'aloof': -0.08,         # 加重冷漠的懲罰
-        #             'energetic': -0.06      # 輕微懲罰高能量
-        #         }
-                
-        #         # 新手友善的特徵 - 提供更多獎勵
-        #         easy_traits = {
-        #             'gentle': 0.08,          # 增加溫和的獎勵
-        #             'friendly': 0.08,        # 增加友善的獎勵
-        #             'eager to please': 0.08, # 增加順從的獎勵
-        #             'patient': 0.06,         # 獎勵耐心
-        #             'adaptable': 0.06,       # 獎勵適應性
-        #             'calm': 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():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += bonus
-                        
-        #         # 品種特殊調整
-        #         if any(term in temperament_lower for term in ['terrier', 'working', 'guard']):
-        #             temperament_adjustments -= 0.12  # 加重對特定類型品種的懲罰
-                    
-        #     elif user_experience == "intermediate":
-        #         # 中級玩家的調整更加平衡
-        #         moderate_traits = {
-        #             'intelligent': 0.05,     # 獎勵聰明
-        #             'athletic': 0.04,        # 獎勵運動能力
-        #             'versatile': 0.04,       # 獎勵多功能性
-        #             'stubborn': -0.06,       # 輕微懲罰固執
-        #             'independent': -0.05,    # 輕微懲罰獨立性
-        #             'protective': -0.04      # 輕微懲罰保護性
-        #         }
-                
-        #         for trait, adjustment in moderate_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += adjustment
-                        
-        #     else:  # advanced
-        #         # 資深玩家能夠應對挑戰性特徵
-        #         advanced_traits = {
-        #             'stubborn': 0.04,        # 反轉為優勢
-        #             'independent': 0.04,      # 反轉為優勢
-        #             'intelligent': 0.05,      # 獎勵聰明
-        #             'protective': 0.04,       # 獎勵保護性
-        #             'strong-willed': 0.03    # 獎勵強勢
-        #         }
-                
-        #         for trait, bonus in advanced_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += bonus
-            
-        #     # 確保最終分數在合理範圍內
-        #     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) -> float:
             """
-            計算使用者經驗與品種需求的匹配分數，強化進階使用者的評分
+            計算使用者經驗與品種需求的匹配分數
+            
+            參數說明:
+            care_level: 品種的照顧難度 ("High", "Moderate", "Low")
+            user_experience: 使用者經驗等級 ("beginner", "intermediate", "advanced") 
+            temperament: 品種的性格特徵描述
+            
+            返回:
+            float: 0.2-1.0 之間的匹配分數
             """
-            # 調整基礎分數矩陣，提高 advanced 的基本分數
+            # 基礎分數矩陣 - 更大的分數差異來反映經驗重要性
             base_scores = {
                 "High": {
-                    "beginner": 0.35,
-                    "intermediate": 0.75,
-                    "advanced": 0.92    # 提高上限
+                    "beginner": 0.12,     # 降低起始分，反映高難度品種對新手的挑戰
+                    "intermediate": 0.65,  # 中級玩家可以應付，但仍有改善空間
+                    "advanced": 1.0       # 資深者能完全勝任
                 },
                 "Moderate": {
-                    "beginner": 0.45,
-                    "intermediate": 0.82,
-                    "advanced": 0.95
+                    "beginner": 0.35,    # 適中難度對新手來說仍具挑戰
+                    "intermediate": 0.82, # 中級玩家有很好的勝任能力
+                    "advanced": 1.0      # 資深者完全勝任
                 },
                 "Low": {
-                    "beginner": 0.60,
-                    "intermediate": 0.85,
-                    "advanced": 0.98
+                    "beginner": 0.72,    # 低難度品種適合新手
+                    "intermediate": 0.92, # 中級玩家幾乎完全勝任
+                    "advanced": 1.0      # 資深者完全勝任
                 }
             }
             
+            # 取得基礎分數
             score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
             
-            # 性格特徵評估
+            # 性格特徵評估 - 根據經驗等級調整權重
             temperament_lower = temperament.lower()
             temperament_adjustments = 0.0
             
-            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
+            if user_experience == "beginner":
+                # 新手不適合的特徵 - 更嚴格的懲罰
+                difficult_traits = {
+                    'stubborn': -0.15,      # 加重固執的懲罰
+                    'independent': -0.12,    # 加重獨立性的懲罰
+                    'dominant': -0.12,       # 加重支配性的懲罰
+                    'strong-willed': -0.10,  # 加重強勢的懲罰
+                    'protective': -0.08,     # 加重保護性的懲罰
+                    'aloof': -0.08,         # 加重冷漠的懲罰
+                    'energetic': -0.06      # 輕微懲罰高能量
+                }
+                
+                # 新手友善的特徵 - 提供更多獎勵
+                easy_traits = {
+                    'gentle': 0.08,          # 增加溫和的獎勵
+                    'friendly': 0.08,        # 增加友善的獎勵
+                    'eager to please': 0.08, # 增加順從的獎勵
+                    'patient': 0.06,         # 獎勵耐心
+                    'adaptable': 0.06,       # 獎勵適應性
+                    'calm': 0.05            # 獎勵冷靜
                 }
                 
-                for trait, adjustment in advanced_traits.items():
+                # 計算特徵調整
+                for trait, penalty in difficult_traits.items():
                     if trait in temperament_lower:
-                        temperament_adjustments += adjustment
+                        temperament_adjustments += penalty * 1.2  # 加重新手的懲罰
+                
+                for trait, bonus in easy_traits.items():
+                    if trait in temperament_lower:
+                        temperament_adjustments += bonus
                         
+                # 品種特殊調整
+                if any(term in temperament_lower for term in ['terrier', 'working', 'guard']):
+                    temperament_adjustments -= 0.12  # 加重對特定類型品種的懲罰
+                    
             elif user_experience == "intermediate":
+                # 中級玩家的調整更加平衡
                 moderate_traits = {
-                    'intelligent': 0.05,
-                    'adaptable': 0.04,
-                    'easy-going': 0.04,
-                    'stubborn': -0.06,
-                    'independent': -0.05,
-                    'dominant': -0.05,
-                    'aggressive': -0.08
+                    'intelligent': 0.05,     # 獎勵聰明
+                    'athletic': 0.04,        # 獎勵運動能力
+                    'versatile': 0.04,       # 獎勵多功能性
+                    'stubborn': -0.06,       # 輕微懲罰固執
+                    'independent': -0.05,    # 輕微懲罰獨立性
+                    'protective': -0.04      # 輕微懲罰保護性
                 }
                 
                 for trait, adjustment in moderate_traits.items():
                     if trait in temperament_lower:
                         temperament_adjustments += adjustment
-            
-            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
+                        
+            else:  # advanced
+                # 資深玩家能夠應對挑戰性特徵
+                advanced_traits = {
+                    'stubborn': 0.04,        # 反轉為優勢
+                    'independent': 0.04,      # 反轉為優勢
+                    'intelligent': 0.05,      # 獎勵聰明
+                    'protective': 0.04,       # 獎勵保護性
+                    'strong-willed': 0.03    # 獎勵強勢
                 }
                 
-                for trait, adjustment in beginner_traits.items():
+                for trait, bonus in advanced_traits.items():
                     if trait in temperament_lower:
-                        temperament_adjustments += adjustment
-            
-            # 特殊能力評估 - 對進階使用者加分
-            if user_experience == "advanced":
-                special_abilities = {
-                    'working': 0.04,
-                    'hunting': 0.04,
-                    'herding': 0.04,
-                    'guard': 0.03,
-                    'agility': 0.03
-                }
-                
-                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))
+            final_score = max(0.2, min(1.0, score + temperament_adjustments))
             return final_score
 
+
         def calculate_health_score(breed_name: str) -> float:
             """計算品種健康分數"""
             if breed_name not in breed_health_info:
@@ -850,13 +653,6 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'noise': calculate_noise_score(breed_info.get('Breed', ''), user_prefs.noise_tolerance)
         }
 
-        breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
-        scores['breed_bonus'] = breed_bonus
-        
-        # 如果有小孩，加入 family_safety 分數
-        if user_prefs.has_children:
-            scores['family_safety'] = calculate_family_safety_score(breed_info, user_prefs.children_age)
-            
 
         # 優化權重配置
         weights = {
@@ -868,91 +664,37 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'noise': 0.08      
         }
 
-        if user_prefs.has_children:          
-            weights = {
-                'space': 0.20,
-                'exercise': 0.13,
-                'grooming': 0.08,
-                'experience': 0.15,
-                'health': 0.10,
-                'noise': 0.06,
-                'breed_bonus': 0.08,
-                'family_safety': 0.20  # 給予家庭安���較高權重
-            }
-
         # 計算加權總分
         weighted_score = sum(score * weights[category] for category, score in scores.items())
 
-        # def amplify_score(score):
-        #     """
-        #     優化分數放大函數，確保分數範圍合理且結果一致
-        #     """
-        #     # 基礎調整
-        #     adjusted = (score - 0.35) * 1.8
-            
-        #     # 使用 3.2 次方使曲線更平滑
-        #     amplified = pow(adjusted, 3.2) / 5.8 + score
-            
-        #     # 特別處理高分區間，確保不超過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))
-            
-        #     # 四捨五入到小數點後第三位
-        #     return round(final_score, 3)
-        
-        # final_score = amplify_score(weighted_score)
-
-        # # 四捨五入所有分數
-        # scores = {k: round(v, 4) for k, v in scores.items()}
-        # scores['overall'] = round(final_score, 4)
-
-        # return scores
-
         def amplify_score(score):
             """
-            優化分數放大函數，確保更合理的分數分布和品種間的差異
-            
-            1. 調整基礎計算係數，使分數差異更明顯
-            2. 重新設計高分區間的處理
-            3. 確保進階使用者能獲得更高分數
-            4. 維持適當的分數下限
+            優化分數放大函數，確保分數範圍合理且結果一致
             """
-            # 第一階段：基礎調整
-            # 降低基礎調整係數，使分數變化更平滑
-            adjusted = (score - 0.30) * 1.5
+            # 基礎調整
+            adjusted = (score - 0.35) * 1.8
             
-            # 第二階段：非線性轉換
-            # 使用較小的指數，讓分數差異更明顯
-            amplified = pow(adjusted, 2.8) / 4.2 + score
+            # 使用 3.2 次方使曲線更平滑
+            amplified = pow(adjusted, 3.2) / 5.8 + 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))
+            # 特別處理高分區間，確保不超過95%
+            if amplified > 0.90:
+                # 壓縮高分區間，確保最高到95%
+                amplified = 0.90 + (amplified - 0.90) * 0.5
             
-            # 第五階段：微調
-            # 讓分數更容易落在中間區間
-            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))
+            # 確保最終分數在合理範圍內（0.55-0.95）
+            final_score = max(0.55, min(0.95, amplified))
             
+            # 四捨五入到小數點後第三位
             return round(final_score, 3)
+        
+        final_score = amplify_score(weighted_score)
+
+        # 四捨五入所有分數
+        scores = {k: round(v, 4) for k, v in scores.items()}
+        scores['overall'] = round(final_score, 4)
+
+        return scores
 
     except Exception as e:
         print(f"Error details: {str(e)}")