Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1479,465 +1479,331 @@ 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. 更精確的品種特性評估
 #     """
-#     # 評估關鍵特徵的匹配度，使用更極端的調整係數
-#     def evaluate_key_features():
-#         # 空間適配性評估
-#         space_multiplier = 1.0
-#         if user_prefs.living_space == 'apartment':
-#             if breed_info['Size'] == 'Giant':
-#                 space_multiplier = 0.3  # 嚴重不適合
-#             elif breed_info['Size'] == 'Large':
-#                 space_multiplier = 0.4  # 明顯不適合
-#             elif breed_info['Size'] == 'Small':
-#                 space_multiplier = 1.4  # 明顯優勢
+#     def evaluate_condition_extremity():
+#         """評估使用者條件的極端程度"""
+#         extremity_count = 0
         
-#         # 運動需求評估
-#         exercise_multiplier = 1.0
+#         # 空間條件極端性
+#         if user_prefs.living_space == 'apartment' and breed_info['Size'] in ['Large', 'Giant']:
+#             extremity_count += 2
+#         elif user_prefs.living_space == 'house_large' and breed_info['Size'] == 'Small':
+#             extremity_count += 1
+            
+#         # 運動需求極端性
 #         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-#         if exercise_needs == 'VERY HIGH':
-#             if user_prefs.exercise_time < 60:
-#                 exercise_multiplier = 0.3  # 嚴重不足
-#             elif user_prefs.exercise_time > 150:
-#                 exercise_multiplier = 1.5  # 完美匹配
+#         if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 60:
+#             extremity_count += 2
 #         elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
-#             exercise_multiplier = 0.5  # 運動過度
-
-#         return space_multiplier, exercise_multiplier
-
-#     # 計算經驗匹配度
-#     def evaluate_experience():
-#         exp_multiplier = 1.0
+#             extremity_count += 1
+            
+#         # 經驗等級極端性
 #         care_level = breed_info.get('Care Level', 'MODERATE')
+#         if care_level == 'High' and user_prefs.experience_level == 'beginner':
+#             extremity_count += 2
+            
+#         return extremity_count
+
+#     def calculate_dynamic_weights():
+#         """計算動態權重"""
+#         # 基礎權重
+#         weights = {
+#             'space': 0.20,
+#             'exercise': 0.20,
+#             'experience': 0.15,
+#             'grooming': 0.15,
+#             'health': 0.15,
+#             'noise': 0.15
+#         }
         
-#         if care_level == 'High':
-#             if user_prefs.experience_level == 'beginner':
-#                 exp_multiplier = 0.4
-#             elif user_prefs.experience_level == 'advanced':
-#                 exp_multiplier = 1.3
-#         elif care_level == 'Low':
-#             if user_prefs.experience_level == 'advanced':
-#                 exp_multiplier = 0.9  # 略微降低評分，因為可能不夠有挑戰性
-                
-#         return exp_multiplier
-
-#     # 取得特徵調整係數
-#     space_mult, exercise_mult = evaluate_key_features()
-#     exp_mult = evaluate_experience()
-
-#     # 調整基礎分數
-#     adjusted_scores = {
-#         'space': scores['space'] * space_mult,
-#         'exercise': scores['exercise'] * exercise_mult,
-#         'experience': scores['experience'] * exp_mult,
-#         'grooming': scores['grooming'],
-#         'health': scores['health'],
-#         'noise': scores['noise']
-#     }
-
-#     # 計算加權平均，關鍵特徵佔更大權重
-#     weights = {
-#         'space': 0.35,
-#         'exercise': 0.30,
-#         'experience': 0.20,
-#         'grooming': 0.15,
-#         'health': 0.10,
-#         'noise': 0.10
-#     }
-
-#     # 動態調整權重
-#     if user_prefs.has_children:
-#         if user_prefs.children_age == 'toddler':
-#             weights['noise'] *= 1.5     # 幼童對噪音更敏感
-#             weights['experience'] *= 1.3 # 需要更有經驗的飼主
-        
-#     if user_prefs.living_space == 'apartment':
-#         weights['space'] *= 1.4        # 公寓空間限制更重要
-#         weights['noise'] *= 1.3        # 噪音問題更重要
-
-#     # 運動時間極端情況
-#     if user_prefs.exercise_time < 30:
-#         weights['exercise'] *= 1.5     # 運動時間極少時加重權重
-#     elif user_prefs.exercise_time > 150:
-#         weights['exercise'] *= 1.3     # 運動時間充足時略微加重
-
-#     # 正規化權重
-#     total_weight = sum(weights.values())
-#     normalized_weights = {k: v/total_weight for k, v in weights.items()}
-
-#     # 計算最終分數
-#     final_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
-
-#     # 品種特性加成
-#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
-    
-#     # 整合最終分數，保持在0-1範圍內
-#     return min(1.0, max(0.0, (final_score * 0.85) + (breed_bonus * 0.15)))
-    
-
-# def amplify_score_extreme(score: float) -> float:
-#     """
-#     改進的分數轉換函數，提供更大的分數區間和更明顯的差異
-    
-#     轉換邏輯：
-#     - 極差匹配 (0.0-0.2) -> 50-60%
-#     - 較差匹配 (0.2-0.4) -> 60-70%
-#     - 中等匹配 (0.4-0.6) -> 70-82%
-#     - 良好匹配 (0.6-0.8) -> 82-90%
-#     - 優秀匹配 (0.8-1.0) -> 90-98%
-#     """
-#     if score < 0.2:
-#         # 極差匹配：更低的起始分數
-#         return 0.50 + (score / 0.2) * 0.10
-#     elif score < 0.4:
-#         # 較差匹配：緩慢增長
-#         position = (score - 0.2) / 0.2
-#         return 0.60 + position * 0.10
-#     elif score < 0.6:
-#         # 中等匹配：較大的分數增長
-#         position = (score - 0.4) / 0.2
-#         return 0.70 + position * 0.12
-#     elif score < 0.8:
-#         # 良好匹配：快速增長
-#         position = (score - 0.6) / 0.2
-#         return 0.82 + position * 0.08
-#     else:
-#         # 優秀匹配：達到更高分數
-#         position = (score - 0.8) / 0.2
-#         return 0.90 + position * 0.08
-
-
-# def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
-#     """改進的品種相容性評分系統"""
-    
-#     def evaluate_key_features():
-#         # 空間適配性評估 - 更極端的調整
-#         space_multiplier = 1.0
+#         # 根據生活環境調整權重
 #         if user_prefs.living_space == 'apartment':
-#             if breed_info['Size'] == 'Giant':
-#                 space_multiplier = 0.2  # 更嚴重的懲罰
-#             elif breed_info['Size'] == 'Large':
-#                 space_multiplier = 0.3
-#             elif breed_info['Size'] == 'Medium':
-#                 space_multiplier = 0.7
-#             elif breed_info['Size'] == 'Small':
-#                 space_multiplier = 1.6  # 更大的獎勵
-                
-#         # 運動需求評估 - 更細緻的匹配
-#         exercise_multiplier = 1.0
-#         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+#             weights['space'] *= 2.0
+#             weights['noise'] *= 1.8
         
-#         # 運動時間差異計算
-#         time_diff_ratio = abs(user_prefs.exercise_time - get_ideal_exercise_time(exercise_needs)) / 60.0
+#         # 根據家庭情況調整
+#         if user_prefs.has_children:
+#             if user_prefs.children_age == 'toddler':
+#                 weights['noise'] *= 2.0
+#                 weights['experience'] *= 1.8
+#                 weights['health'] *= 1.5
+#             elif user_prefs.children_age == 'school_age':
+#                 weights['noise'] *= 1.5
+#                 weights['experience'] *= 1.3
         
-#         if exercise_needs == 'VERY HIGH':
-#             if user_prefs.exercise_time < 90:
-#                 exercise_multiplier = max(0.2, 1.0 - time_diff_ratio)
-#             elif user_prefs.exercise_time > 150:
-#                 exercise_multiplier = min(2.0, 1.0 + time_diff_ratio/2)
-#         elif exercise_needs == 'HIGH':
-#             if user_prefs.exercise_time < 60:
-#                 exercise_multiplier = max(0.3, 1.0 - time_diff_ratio)
-#             elif user_prefs.exercise_time > 120:
-#                 exercise_multiplier = min(1.8, 1.0 + time_diff_ratio/2)
-#         elif exercise_needs == 'LOW':
-#             if user_prefs.exercise_time > 120:
-#                 exercise_multiplier = max(0.4, 1.0 - time_diff_ratio/2)
-
-#         return space_multiplier, exercise_multiplier
-
-#     def get_ideal_exercise_time(exercise_needs: str) -> int:
-#         """獲取理想運動時間"""
-#         return {
-#             'VERY HIGH': 150,
-#             'HIGH': 120,
-#             'MODERATE HIGH': 90,
-#             'MODERATE': 60,
-#             'MODERATE LOW': 45,
-#             'LOW': 30
-#         }.get(exercise_needs, 60)
-
-#     # 經驗匹配度評估 - 更強的影響力
-#     def evaluate_experience():
-#         exp_multiplier = 1.0
-#         care_level = breed_info.get('Care Level', 'MODERATE')
-        
-#         if care_level == 'High':
-#             if user_prefs.experience_level == 'beginner':
-#                 exp_multiplier = 0.3  # 更嚴重的懲罰
-#             elif user_prefs.experience_level == 'advanced':
-#                 exp_multiplier = 1.5  # 更大的獎勵
-#         elif care_level == 'Low':
-#             if user_prefs.experience_level == 'advanced':
-#                 exp_multiplier = 0.8
-                
-#         return exp_multiplier
-
-#     # 計算調整係數
-#     space_mult, exercise_mult = evaluate_key_features()
-#     exp_mult = evaluate_experience()
-
-#     # 調整基礎分數
-#     adjusted_scores = {
-#         'space': scores['space'] * space_mult,
-#         'exercise': scores['exercise'] * exercise_mult,
-#         'experience': scores['experience'] * exp_mult,
-#         'grooming': scores['grooming'],
-#         'health': scores['health'] * (1.5 if user_prefs.health_sensitivity == 'high' else 1.0),
-#         'noise': scores['noise']
-#     }
-
-#     # 基礎權重
-#     weights = {
-#         'space': 0.25,
-#         'exercise': 0.25,
-#         'experience': 0.15,
-#         'grooming': 0.15,
-#         'health': 0.10,
-#         'noise': 0.10
-#     }
-
-#     # 動態權重調整 - 更強的條件反應
-#     if user_prefs.has_children:
-#         if user_prefs.children_age == 'toddler':
-#             weights['noise'] *= 2.0  # 更強的噪音影響
-#             weights['experience'] *= 1.5
-#             weights['health'] *= 1.3
-#         elif user_prefs.children_age == 'school_age':
-#             weights['noise'] *= 1.5
-#             weights['experience'] *= 1.3
-
-#     if user_prefs.living_space == 'apartment':
-#         weights['space'] *= 1.8  # 更強的空間限制
-#         weights['noise'] *= 1.6
-
-#     # 運動時間極端情況
-#     if user_prefs.exercise_time < 30:
-#         weights['exercise'] *= 2.0
-#     elif user_prefs.exercise_time > 150:
-#         weights['exercise'] *= 1.5
+#         # 根據運動時間調整
+#         if user_prefs.exercise_time < 30:
+#             weights['exercise'] *= 2.5
+#         elif user_prefs.exercise_time > 150:
+#             weights['exercise'] *= 2.0
+            
+#         # 根據健康敏感度調整
+#         if user_prefs.health_sensitivity == 'high':
+#             weights['health'] *= 1.8
+            
+#         return weights
 
+#     # 計算條件極端程度
+#     extremity_level = evaluate_condition_extremity()
+    
+#     # 計算動態權重
+#     weights = calculate_dynamic_weights()
+    
 #     # 正規化權重
 #     total_weight = sum(weights.values())
 #     normalized_weights = {k: v/total_weight for k, v in weights.items()}
-
-#     # 計算基礎分數
-#     base_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
+    
+#     # 計算加權分數
+#     weighted_scores = {
+#         k: scores[k] * normalized_weights[k] for k in scores.keys()
+#     }
+    
+#     # 基礎分數
+#     base_score = sum(weighted_scores.values())
     
 #     # 品種特性加成
 #     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-#     # 動態整合係數
-#     bonus_weight = min(0.25, max(0.15, breed_bonus))  # 讓優秀特性有更大影響
+#     # 根據極端程度調整最終分數
+#     if extremity_level >= 3:
+#         base_score *= 0.6  # 多個極端條件的嚴重懲罰
+#     elif extremity_level >= 2:
+#         base_score *= 0.8  # 較少極端條件的適度懲罰
     
 #     # 完美匹配加成
-#     if all(score >= 0.8 for score in adjusted_scores.values()):
-#         base_score *= 1.2
+#     if all(score >= 0.8 for score in scores.values()):
+#         base_score *= 1.3
     
-#     # 極端不匹配懲罰
-#     if any(score <= 0.3 for score in adjusted_scores.values()):
-#         base_score *= 0.6
-
-#     return min(1.0, max(0.0, (base_score * (1.0 - bonus_weight)) + (breed_bonus * bonus_weight)))
+#     # 品種特性影響力隨匹配度增加
+#     bonus_weight = min(0.35, max(0.15, breed_bonus))
+    
+#     # 最終分數計算
+#     final_score = (base_score * (1.0 - bonus_weight)) + (breed_bonus * bonus_weight)
+    
+#     return min(1.0, max(0.0, final_score))
 
 
 # def amplify_score_extreme(score: float) -> float:
 #     """
-#     改進的分數轉換函數，提供更動態的分數範圍
+#     改進的分數轉換函數，提供更合理的分數分布
     
-#     動態轉換邏輯：
-#     - 極差匹配 (0.0-0.2) -> 45-58%
-#     - 較差匹配 (0.2-0.4) -> 58-72%
-#     - 中等匹配 (0.4-0.6) -> 72-85%
-#     - 良好匹配 (0.6-0.8) -> 85-92%
-#     - 優秀匹配 (0.8-0.9) -> 92-96%
-#     - 完美匹配 (0.9-1.0) -> 96-99%
+#     特點：
+#     1. 更大的分數範圍
+#     2. 更平滑的轉換曲線
+#     3. 更準確的極端情況處理
 #     """
+#     def sigmoid_transform(x: float, steepness: float = 10) -> float:
+#         """使用 sigmoid 函數實現更平滑的轉換"""
+#         import math
+#         return 1 / (1 + math.exp(-steepness * (x - 0.5)))
+
 #     if score < 0.2:
-#         return 0.45 + (score / 0.2) * 0.13
+#         # 極差匹配：使用更低的起始分數
+#         base = 0.40
+#         range_score = 0.15
+#         position = score / 0.2
+#         return base + (sigmoid_transform(position) * range_score)
+        
 #     elif score < 0.4:
+#         # 較差匹配：緩慢增長
+#         base = 0.55
+#         range_score = 0.15
 #         position = (score - 0.2) / 0.2
-#         return 0.58 + position * 0.14
+#         return base + (sigmoid_transform(position) * range_score)
+        
 #     elif score < 0.6:
+#         # 中等匹配：較大增長
+#         base = 0.70
+#         range_score = 0.15
 #         position = (score - 0.4) / 0.2
-#         return 0.72 + position * 0.13
+#         return base + (sigmoid_transform(position) * range_score)
+        
 #     elif score < 0.8:
+#         # 良好匹配：快速增長
+#         base = 0.85
+#         range_score = 0.10
 #         position = (score - 0.6) / 0.2
-#         return 0.85 + position * 0.07
+#         return base + (sigmoid_transform(position) * range_score)
+        
 #     elif score < 0.9:
+#         # 優秀匹配：接近最高分
+#         base = 0.95
+#         range_score = 0.03
 #         position = (score - 0.8) / 0.1
-#         return 0.92 + position * 0.04
+#         return base + (sigmoid_transform(position) * range_score)
+        
 #     else:
+#         # 完美匹配：可能達到最高分
+#         base = 0.98
+#         range_score = 0.02
 #         position = (score - 0.9) / 0.1
-#         return 0.96 + position * 0.03
+#         return base + (sigmoid_transform(position) * range_score)
 
 
 def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
     """
-    改進的品種相容性評分系統，提供更動態和精確的評分
-    
-    主要改進：
-    1. 更動態的權重系統
-    2. 更強的極端情況處理
-    3. 更精確的品種特性評估
+    重構的品種相容性評分系統
+    目標：實現更大的分數差異和更高的頂部分數
     """
-    def evaluate_condition_extremity():
-        """評估使用者條件的極端程度"""
-        extremity_count = 0
+    def evaluate_perfect_conditions():
+        """評估完美條件匹配度"""
+        perfect_matches = {
+            'size_match': False,
+            'exercise_match': False,
+            'experience_match': False,
+            'general_match': False
+        }
         
-        # 空間條件極端性
-        if user_prefs.living_space == 'apartment' and breed_info['Size'] in ['Large', 'Giant']:
-            extremity_count += 2
-        elif user_prefs.living_space == 'house_large' and breed_info['Size'] == 'Small':
-            extremity_count += 1
+        # 體型與空間匹配
+        if user_prefs.living_space == 'apartment':
+            perfect_matches['size_match'] = breed_info['Size'] == 'Small'
+        elif user_prefs.living_space == 'house_large':
+            perfect_matches['size_match'] = breed_info['Size'] in ['Medium', 'Large']
             
-        # 運動需求極端性
+        # 運動需求匹配
         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-        if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 60:
-            extremity_count += 2
-        elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
-            extremity_count += 1
+        if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time >= 150:
+            perfect_matches['exercise_match'] = True
+        elif exercise_needs == 'LOW' and 30 <= user_prefs.exercise_time <= 90:
+            perfect_matches['exercise_match'] = True
+        elif 60 <= user_prefs.exercise_time <= 120:
+            perfect_matches['exercise_match'] = True
             
-        # 經驗等級極端性
+        # 經驗匹配
         care_level = breed_info.get('Care Level', 'MODERATE')
-        if care_level == 'High' and user_prefs.experience_level == 'beginner':
-            extremity_count += 2
+        if care_level == 'High' and user_prefs.experience_level == 'advanced':
+            perfect_matches['experience_match'] = True
+        elif care_level == 'Low' and user_prefs.experience_level == 'beginner':
+            perfect_matches['experience_match'] = True
+        elif user_prefs.experience_level == 'intermediate':
+            perfect_matches['experience_match'] = True
             
-        return extremity_count
+        # 一般條件匹配
+        if all(score >= 0.85 for score in scores.values()):
+            perfect_matches['general_match'] = True
+            
+        return perfect_matches
 
-    def calculate_dynamic_weights():
+    def calculate_weights():
         """計算動態權重"""
-        # 基礎權重
-        weights = {
+        base_weights = {
             'space': 0.20,
             'exercise': 0.20,
-            'experience': 0.15,
+            'experience': 0.20,  
             'grooming': 0.15,
             'health': 0.15,
-            'noise': 0.15
+            'noise': 0.10
         }
         
-        # 根據生活環境調整權重
-        if user_prefs.living_space == 'apartment':
-            weights['space'] *= 2.0
-            weights['noise'] *= 1.8
-        
-        # 根據家庭情況調整
-        if user_prefs.has_children:
-            if user_prefs.children_age == 'toddler':
-                weights['noise'] *= 2.0
-                weights['experience'] *= 1.8
-                weights['health'] *= 1.5
-            elif user_prefs.children_age == 'school_age':
-                weights['noise'] *= 1.5
-                weights['experience'] *= 1.3
+        # 極端條件權重調整
+        multipliers = {}
         
-        # 根據運動時間調整
-        if user_prefs.exercise_time < 30:
-            weights['exercise'] *= 2.5
-        elif user_prefs.exercise_time > 150:
-            weights['exercise'] *= 2.0
+        # 經驗權重調整
+        if user_prefs.experience_level == 'beginner':
+            multipliers['experience'] = 3.0  # 新手經驗極其重要
+        elif user_prefs.experience_level == 'advanced':
+            multipliers['experience'] = 2.5  # 專家經驗很重要
+            
+        # 運動需求權重調整
+        if user_prefs.exercise_time > 150:
+            multipliers['exercise'] = 3.0
+        elif user_prefs.exercise_time < 30:
+            multipliers['exercise'] = 3.5
+            
+        # 空間限制權重調整
+        if user_prefs.living_space == 'apartment':
+            multipliers['space'] = 2.5
+            multipliers['noise'] = 2.0
             
-        # 根據健康敏感度調整
-        if user_prefs.health_sensitivity == 'high':
-            weights['health'] *= 1.8
+        # 應用乘數
+        for key, multiplier in multipliers.items():
+            base_weights[key] *= multiplier
             
-        return weights
+        return base_weights
 
-    # 計算條件極端程度
-    extremity_level = evaluate_condition_extremity()
+    # 評估完美匹配條件
+    perfect_conditions = evaluate_perfect_conditions()
     
     # 計算動態權重
-    weights = calculate_dynamic_weights()
+    weights = calculate_weights()
     
     # 正規化權重
     total_weight = sum(weights.values())
     normalized_weights = {k: v/total_weight for k, v in weights.items()}
     
-    # 計算加權分數
-    weighted_scores = {
-        k: scores[k] * normalized_weights[k] for k in scores.keys()
-    }
-    
-    # 基礎分數
-    base_score = sum(weighted_scores.values())
-    
+    # 計算基礎分數
+    base_score = sum(scores[k] * normalized_weights[k] for k in scores.keys())
+    
+    # 完美匹配獎勵
+    perfect_bonus = 1.0
+    if perfect_conditions['size_match']:
+        perfect_bonus += 0.2
+    if perfect_conditions['exercise_match']:
+        perfect_bonus += 0.2
+    if perfect_conditions['experience_match']:
+        perfect_bonus += 0.2
+    if perfect_conditions['general_match']:
+        perfect_bonus += 0.2
+        
     # 品種特性加成
-    breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
-    
-    # 根據極端程度調整最終分數
-    if extremity_level >= 3:
-        base_score *= 0.6  # 多個極端條件的嚴重懲罰
-    elif extremity_level >= 2:
-        base_score *= 0.8  # 較少極端條件的適度懲罰
-    
-    # 完美匹配加成
-    if all(score >= 0.8 for score in scores.values()):
-        base_score *= 1.3
+    breed_bonus = calculate_breed_bonus(breed_info, user_prefs) * 1.5  # 增加品種特性影響
     
-    # 品種特性影響力隨匹配度增加
-    bonus_weight = min(0.35, max(0.15, breed_bonus))
+    # 計算最終分數
+    final_score = (base_score * 0.7 + breed_bonus * 0.3) * perfect_bonus
     
-    # 最終分數計算
-    final_score = (base_score * (1.0 - bonus_weight)) + (breed_bonus * bonus_weight)
+    return min(1.0, final_score)
     
-    return min(1.0, max(0.0, final_score))
-
 
 def amplify_score_extreme(score: float) -> float:
     """
-    改進的分數轉換函數，提供更合理的分數分布
-    
-    特點：
-    1. 更大的分數範圍
-    2. 更平滑的轉換曲線
-    3. 更準確的極端情況處理
+    改進的分數轉換函數：實現更高的頂部分數
+    - 完美匹配可達到95-99%
+    - 優秀匹配在90-95%
+    - 良好匹配在85-90%
+    - 一般匹配在75-85%
+    - 較差匹配在65-75%
+    - 極差匹配在50-65%
     """
-    def sigmoid_transform(x: float, steepness: float = 10) -> float:
-        """使用 sigmoid 函數實現更平滑的轉換"""
+    def smooth_curve(x: float, steepness: float = 12) -> float:
+        """使用sigmoid curve"""
         import math
         return 1 / (1 + math.exp(-steepness * (x - 0.5)))
 
-    if score < 0.2:
-        # 極差匹配：使用更低的起始分數
-        base = 0.40
-        range_score = 0.15
-        position = score / 0.2
-        return base + (sigmoid_transform(position) * range_score)
+    if score >= 0.9:
+        # 完美匹配：95-99%
+        position = (score - 0.9) / 0.1
+        return 0.95 + (position * 0.04)
         
-    elif score < 0.4:
-        # 較差匹配：緩慢增長
-        base = 0.55
-        range_score = 0.15
-        position = (score - 0.2) / 0.2
-        return base + (sigmoid_transform(position) * range_score)
+    elif score >= 0.8:
+        # 優秀匹配：90-95%
+        position = (score - 0.8) / 0.1
+        return 0.90 + (position * 0.05)
         
-    elif score < 0.6:
-        # 中等匹��：較大增長
-        base = 0.70
-        range_score = 0.15
-        position = (score - 0.4) / 0.2
-        return base + (sigmoid_transform(position) * range_score)
+    elif score >= 0.7:
+        # 良好匹配：85-90%
+        position = (score - 0.7) / 0.1
+        return 0.85 + (position * 0.05)
         
-    elif score < 0.8:
-        # 良好匹配：快速增長
-        base = 0.85
-        range_score = 0.10
-        position = (score - 0.6) / 0.2
-        return base + (sigmoid_transform(position) * range_score)
+    elif score >= 0.5:
+        # 一般匹配：75-85%
+        position = (score - 0.5) / 0.2
+        base = 0.75
+        return base + (smooth_curve(position) * 0.10)
         
-    elif score < 0.9:
-        # 優秀匹配：接近最高分
-        base = 0.95
-        range_score = 0.03
-        position = (score - 0.8) / 0.1
-        return base + (sigmoid_transform(position) * range_score)
+    elif score >= 0.3:
+        # 較差匹配：65-75%
+        position = (score - 0.3) / 0.2
+        base = 0.65
+        return base + (smooth_curve(position) * 0.10)
         
     else:
-        # 完美匹配：可能達到最高分
-        base = 0.98
-        range_score = 0.02
-        position = (score - 0.9) / 0.1
-        return base + (sigmoid_transform(position) * range_score)
+        # 極差匹配：50-65%
+        position = score / 0.3
+        base = 0.50
+        return base + (smooth_curve(position) * 0.15)