Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1292,330 +1292,7 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
         adaptability_score += 0.05
         
     return min(0.2, adaptability_score)
-
-
-# def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
-#     """
-#     1. 運動類型與時間的精確匹配
-#     2. 進階使用者的專業需求
-#     3. 空間利用的實際效果
-#     4. 條件組合的嚴格評估
-#     """
-#     def evaluate_perfect_conditions():
-#         """評估條件匹配度，特別強化運動類型與專業程度的評估"""
-#         perfect_matches = {
-#             'size_match': 0,
-#             'exercise_match': 0,
-#             'experience_match': 0,
-#             'living_condition_match': 0
-#         }
-        
-#         # 運動類型與需求的精確匹配
-#         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-#         exercise_time = user_prefs.exercise_time
-#         exercise_type = user_prefs.exercise_type
-        
-#         # 定義品種的理想運動模式
-#         breed_exercise_preferences = {
-#             'VERY HIGH': {
-#                 'ideal_type': 'active_training',
-#                 'acceptable_types': ['moderate_activity'],
-#                 'time_ranges': {
-#                     'ideal': (120, 180),
-#                     'acceptable': (90, 200)
-#                 }
-#             },
-#             'HIGH': {
-#                 'ideal_type': 'moderate_activity',
-#                 'acceptable_types': ['active_training', 'light_walks'],
-#                 'time_ranges': {
-#                     'ideal': (90, 150),
-#                     'acceptable': (60, 180)
-#                 }
-#             },
-#             'MODERATE': {
-#                 'ideal_type': 'moderate_activity',
-#                 'acceptable_types': ['light_walks', 'active_training'],
-#                 'time_ranges': {
-#                     'ideal': (45, 90),
-#                     'acceptable': (30, 120)
-#                 }
-#             },
-#             'LOW': {
-#                 'ideal_type': 'light_walks',
-#                 'acceptable_types': ['moderate_activity'],
-#                 'time_ranges': {
-#                     'ideal': (30, 60),
-#                     'acceptable': (15, 90)
-#                 }
-#             }
-#         }
-        
-#         # 計算運動匹配度
-#         exercise_profile = breed_exercise_preferences.get(exercise_needs, 
-#                                                        breed_exercise_preferences['MODERATE'])
-        
-#         # 時間匹配度計算
-#         time_ranges = exercise_profile['time_ranges']
-#         if time_ranges['ideal'][0] <= exercise_time <= time_ranges['ideal'][1]:
-#             time_score = 1.0
-#         elif time_ranges['acceptable'][0] <= exercise_time <= time_ranges['acceptable'][1]:
-#             # 計算與理想範圍的距離
-#             if exercise_time < time_ranges['ideal'][0]:
-#                 deviation = (time_ranges['ideal'][0] - exercise_time) / time_ranges['ideal'][0]
-#             else:
-#                 deviation = (exercise_time - time_ranges['ideal'][1]) / time_ranges['ideal'][1]
-#             time_score = max(0.4, 1 - (deviation * 0.6))
-#         else:
-#             time_score = 0.3
-        
-#         # 運動類型匹配度計算
-#         if exercise_type == exercise_profile['ideal_type']:
-#             type_score = 1.0
-#         elif exercise_type in exercise_profile['acceptable_types']:
-#             type_score = 0.7
-#         else:
-#             type_score = 0.4
-            
-#         # 若運動時間過長但強度不足，額外降低分數
-#         if exercise_time > time_ranges['acceptable'][1] and exercise_type != exercise_profile['ideal_type']:
-#             type_score *= 0.7
-            
-#         perfect_matches['exercise_match'] = (time_score * 0.6) + (type_score * 0.4)
-        
-#         # 體型與空間的實際利用評估
-#         space_utilization = {
-#             'apartment': {
-#                 'Small': 1.0,
-#                 'Medium': 0.4,
-#                 'Large': 0.2,
-#                 'Giant': 0.1
-#             },
-#             'house_small': {
-#                 'Small': 0.9,
-#                 'Medium': 1.0,
-#                 'Large': 0.5,
-#                 'Giant': 0.3
-#             },
-#             'house_large': {
-#                 'Small': 0.7,
-#                 'Medium': 0.9,
-#                 'Large': 1.0,
-#                 'Giant': 0.95
-#             }
-#         }
-        
-#         # 增加活動空間需求評估
-#         space_needs = 'high' if exercise_needs in ['VERY HIGH', 'HIGH'] else 'moderate'
-#         if space_needs == 'high' and user_prefs.living_space != 'house_large':
-#             space_score = space_utilization[user_prefs.living_space][breed_info['Size']] * 0.8
-#         else:
-#             space_score = space_utilization.get(user_prefs.living_space, 
-#                                               space_utilization['house_small'])[breed_info['Size']]
-            
-#         perfect_matches['size_match'] = space_score
-        
-#         # 經驗需求的專業評估
-#         care_level = breed_info.get('Care Level', 'MODERATE').upper()
-#         temperament = breed_info.get('Temperament', '').lower()
-        
-#         # 定義進階特徵
-#         advanced_traits = ['working', 'independent', 'dominant', 'protective']
-#         advanced_trait_count = sum(1 for trait in advanced_traits if trait in temperament)
-        
-#         # 經驗匹配度計算
-#         experience_matrix = {
-#             'HIGH': {
-#                 'beginner': 0.2,        # 更嚴格的新手限制
-#                 'intermediate': 0.6,
-#                 'advanced': 1.0
-#             },
-#             'MODERATE': {
-#                 'beginner': 0.5,
-#                 'intermediate': 0.9,
-#                 'advanced': 0.95
-#             },
-#             'LOW': {
-#                 'beginner': 0.9,
-#                 'intermediate': 0.85,
-#                 'advanced': 0.8         # 對專家稍微降低簡單品種的分數
-#             }
-#         }
-        
-#         experience_score = experience_matrix[care_level][user_prefs.experience_level]
-        
-#         # 根據進階特徵調整分數
-#         if advanced_trait_count > 0:
-#             if user_prefs.experience_level == 'beginner':
-#                 experience_score *= (0.8 ** advanced_trait_count)
-#             elif user_prefs.experience_level == 'advanced':
-#                 experience_score *= (1.1 ** min(advanced_trait_count, 2))
-                
-#         perfect_matches['experience_match'] = experience_score
-        
-#         # 生活條件整體評估
-#         living_score = 1.0
-        
-#         # 院子影響的嚴格評估
-#         if breed_info.get('Exercise Needs', 'MODERATE').upper() in ['HIGH', 'VERY HIGH']:
-#             yard_impacts = {
-#                 'no_yard': 0.5,         # 更嚴格的懲罰
-#                 'shared_yard': 0.7,
-#                 'private_yard': 1.0
-#             }
-#             living_score *= yard_impacts.get(user_prefs.yard_access, 0.7)
-            
-#         # 時間可用性評估
-#         time_impacts = {
-#             'limited': 0.6,             # 更嚴格的時間限制影響
-#             'moderate': 0.8,
-#             'flexible': 1.0
-#         }
-#         living_score *= time_impacts.get(user_prefs.time_availability, 0.8)
-        
-#         perfect_matches['living_condition_match'] = living_score
-        
-#         return perfect_matches
-
-#     def calculate_weights():
-#         """計算動態權重，強化條件極端情況的影響"""
-#         base_weights = {
-#             'space': 0.20,
-#             'exercise': 0.20,
-#             'experience': 0.20,
-#             'grooming': 0.15,
-#             'noise': 0.15,
-#             'health': 0.10
-#         }
-        
-#         # 計算條件極端度
-#         def calculate_condition_extremity():
-#             extremities = {}
-            
-#             # 運動時間極端度評估
-#             if user_prefs.exercise_time < 30:
-#                 extremities['exercise'] = ('very_low', 0.9)
-#             elif user_prefs.exercise_time < 60:
-#                 extremities['exercise'] = ('low', 0.7)
-#             elif user_prefs.exercise_time > 150:
-#                 extremities['exercise'] = ('very_high', 0.9)
-#             elif user_prefs.exercise_time > 120:
-#                 extremities['exercise'] = ('high', 0.7)
-#             else:
-#                 extremities['exercise'] = ('moderate', 0.3)
-                
-#             # 空間限制極端度評估
-#             if user_prefs.living_space == 'apartment':
-#                 extremities['space'] = ('very_restricted', 0.9)
-#             elif user_prefs.living_space == 'house_small':
-#                 extremities['space'] = ('restricted', 0.6)
-#             else:
-#                 extremities['space'] = ('spacious', 0.3)
-                
-#             return extremities
-            
-#         extremities = calculate_condition_extremity()
-        
-#         # 權重調整
-#         weight_adjustments = {}
-        
-#         # 空間權重調整
-#         if extremities['space'][0] == 'very_restricted':
-#             weight_adjustments['space'] = 3.0
-#             weight_adjustments['noise'] = 2.5
-#         elif extremities['space'][0] == 'restricted':
-#             weight_adjustments['space'] = 2.0
-#             weight_adjustments['noise'] = 1.8
-#         elif extremities['space'][0] == 'spacious':
-#             weight_adjustments['space'] = 0.7    # 大空間時降低空間權重
-#             weight_adjustments['exercise'] = 1.5  # 提升運動重要性
-            
-#         # 運動需求權重調整
-#         if extremities['exercise'][0] in ['very_low', 'very_high']:
-#             weight_adjustments['exercise'] = 3.0
-#         elif extremities['exercise'][0] in ['low', 'high']:
-#             weight_adjustments['exercise'] = 2.0
-            
-#         # 經驗需求權重調整
-#         if user_prefs.experience_level == 'beginner':
-#             weight_adjustments['experience'] = 2.5
-#         elif user_prefs.experience_level == 'advanced':
-#             weight_adjustments['experience'] = 2.0
-            
-#         # 應用權重調整
-#         final_weights = base_weights.copy()
-#         for key, adjustment in weight_adjustments.items():
-#             final_weights[key] *= adjustment
-            
-#         return final_weights
-
-#     def apply_special_case_adjustments(score):
-#         """處理特殊情況，更嚴格的條件組合評估"""
-#         severity = 1.0
-        
-#         # 空間與運動組合的嚴格評估
-#         if user_prefs.living_space == 'apartment':
-#             if breed_info.get('Exercise Needs', 'MODERATE').upper() == 'VERY HIGH':
-#                 severity *= 0.5   # 更嚴重的懲罰
-#             elif breed_info.get('Exercise Needs') == 'HIGH':
-#                 severity *= 0.6
-#             if breed_info['Size'] in ['Large', 'Giant']:
-#                 severity *= 0.5
-                
-#         # 經驗與品種難度組合的嚴格評估
-#         if user_prefs.experience_level == 'beginner':
-#             if breed_info.get('Care Level') == 'HIGH':
-#                 if user_prefs.has_children:
-#                     severity *= 0.5
-#                 else:
-#                     severity *= 0.6
-                    
-#         # 時間限制與需求組合的嚴格評估
-#         if user_prefs.time_availability == 'limited':
-#             if breed_info.get('Exercise Needs').upper() in ['VERY HIGH', 'HIGH']:
-#                 severity *= 0.6
-                
-#         # 運動類型不匹配的懲罰
-#         if user_prefs.exercise_time > 120:
-#             exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-#             if exercise_needs == 'LOW':
-#                 severity *= 0.7
-#             elif exercise_needs == 'VERY HIGH' and user_prefs.exercise_type == 'light_walks':
-#                 severity *= 0.6
-                
-#         return score * severity
-
-#     # 評估完美匹配條件
-#     perfect_conditions = evaluate_perfect_conditions()
-    
-#     # 計算動態權重
-#     weights = calculate_weights()
-    
-#     # 正規化權重
-#     total_weight = sum(weights.values())
-#     normalized_weights = {k: v/total_weight for k, v in weights.items()}
     
-#     # 計算基礎分數
-#     base_score = sum(scores[k] * normalized_weights[k] for k in scores.keys())
-    
-#     # 完美匹配獎勵計算（降低獎勵影響）
-#     perfect_bonus = 1.0
-#     perfect_bonus += 0.12 * perfect_conditions['size_match']
-#     perfect_bonus += 0.12 * perfect_conditions['exercise_match']
-#     perfect_bonus += 0.12 * perfect_conditions['experience_match']
-#     perfect_bonus += 0.04 * perfect_conditions['living_condition_match']
-    
-#     # 品種特性加成
-#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
-    
-#     # 計算最終分數
-#     final_score = (base_score * 0.85 + breed_bonus * 0.15) * perfect_bonus
-    
-#     # 應用特殊情況調整
-#     final_score = apply_special_case_adjustments(final_score)
-    
-#     return min(1.0, final_score)
-
 
 def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
     """
@@ -2136,33 +1813,93 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
                     
             return multiplier
         
+        # def evaluate_breed_specific_requirements():
+        #     """評估品種特定的要求，加強運動需求的判斷"""
+        #     multiplier = 1.0
+        #     exercise_time = user_prefs.exercise_time
+        #     exercise_type = user_prefs.exercise_type
+            
+        #     # 檢查品種的基本特性
+        #     temperament = breed_info.get('Temperament', '').lower()
+        #     description = breed_info.get('Description', '').lower()
+        #     exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+            
+        #     # 加強運動需求的匹配判斷
+        #     if exercise_needs == 'LOW':
+        #         if exercise_time > 90:  # 如果用戶運動時間過長
+        #             multiplier *= 0.5   # 給予更強的懲罰
+        #     elif exercise_needs == 'VERY HIGH':
+        #         if exercise_time < 60:  # 如果用戶運動時間過短
+        #             multiplier *= 0.5
+                    
+        #     if 'sprint' in temperament:
+        #         if exercise_time > 120 and exercise_type != 'active_training':
+        #             multiplier *= 0.7
+                    
+        #     if any(trait in temperament for trait in ['working', 'herding']):
+        #         if exercise_time < 90 or exercise_type == 'light_walks':
+        #             multiplier *= 0.7
+                    
+        #     return multiplier
+
         def evaluate_breed_specific_requirements():
-            """評估品種特定的要求，加強運動需求的判斷"""
+            """
+            1. 嚴格的運動需求匹配
+            2. 細緻的品種特性評估
+            3. 強化經驗要求的判斷
+            """
             multiplier = 1.0
             exercise_time = user_prefs.exercise_time
             exercise_type = user_prefs.exercise_type
             
-            # 檢查品種的基本特性
+            # 獲取品種的關鍵特性
             temperament = breed_info.get('Temperament', '').lower()
             description = breed_info.get('Description', '').lower()
             exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+            care_level = breed_info.get('Care Level', 'MODERATE').upper()
+            
+            # 運動需求匹配評估 
+            exercise_mismatch = {
+                'VERY HIGH': {
+                    'min_time': 60,
+                    'penalty_rate': 0.4 if exercise_time < 60 else 0.0
+                },
+                'HIGH': {
+                    'min_time': 45,
+                    'penalty_rate': 0.35 if exercise_time < 45 else 0.0
+                },
+                'LOW': {
+                    'max_time': 90,
+                    'penalty_rate': 0.4 if exercise_time > 90 else 0.0
+                }
+            }
+            
+            if exercise_needs in exercise_mismatch:
+                match_info = exercise_mismatch[exercise_needs]
+                if 'min_time' in match_info and exercise_time < match_info['min_time']:
+                    multiplier *= (1 - match_info['penalty_rate'])
+                elif 'max_time' in match_info and exercise_time > match_info['max_time']:
+                    multiplier *= (1 - match_info['penalty_rate'])
+        
+            # 品種特性專門評估
+            breed_traits = {
+                'working_dog': ['working', 'herding', 'intelligent', 'active'],
+                'family_dog': ['gentle', 'friendly', 'good with children', 'patient'],
+                'guard_dog': ['protective', 'territorial', 'alert', 'watchdog']
+            }
+            
+            # 根據用戶條件評估特殊特性
+            for trait_type, traits in breed_traits.items():
+                if any(trait in temperament for trait in traits):
+                    if trait_type == 'working_dog':
+                        if user_prefs.experience_level == 'beginner':
+                            multiplier *= 0.7
+                        if exercise_time < 90:
+                            multiplier *= 0.75
+                    elif trait_type == 'guard_dog':
+                        if user_prefs.has_children and user_prefs.experience_level != 'advanced':
+                            multiplier *= 0.8
             
-            # 加強運動需求的匹配判斷
-            if exercise_needs == 'LOW':
-                if exercise_time > 90:  # 如果用戶運動時間過長
-                    multiplier *= 0.5   # 給予更強的懲罰
-            elif exercise_needs == 'VERY HIGH':
-                if exercise_time < 60:  # 如果用戶運動時間過短
-                    multiplier *= 0.5
-                    
-            if 'sprint' in temperament:
-                if exercise_time > 120 and exercise_type != 'active_training':
-                    multiplier *= 0.7
-                    
-            if any(trait in temperament for trait in ['working', 'herding']):
-                if exercise_time < 90 or exercise_type == 'light_walks':
-                    multiplier *= 0.7
-                    
             return multiplier
         
         def evaluate_environmental_impact():
@@ -2192,40 +1929,76 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         final_score = score * severity_multiplier
         return max(0.2, min(1.0, final_score))
 
+    # def calculate_base_score(scores: dict, weights: dict) -> float:
+    #     """
+    #     計算基礎分數，更寬容地處理極端組合
+    #     """
+    #     # 進一步降低關鍵指標閾值，使系統更包容極端組合
+    #     critical_thresholds = {
+    #     'space': 0.45,     # 進一步降低閾值
+    #     'exercise': 0.45,
+    #     'experience': 0.55,
+    #     'noise': 0.55
+    #     }
+        
+    #     critical_failures = []
+    #     for metric, threshold in critical_thresholds.items():
+    #         if scores[metric] < threshold:
+    #             critical_failures.append((metric, scores[metric]))
+        
+    #     base_score = sum(scores[k] * weights[k] for k in scores.keys())
+        
+    #     if critical_failures:
+    #         space_exercise_penalty = 0
+    #         other_penalty = 0
+            
+    #         for metric, score in critical_failures:
+    #             if metric in ['space', 'exercise']:
+    #                 space_exercise_penalty += (critical_thresholds[metric] - score) * 0.15  # 降低懲罰
+    #             else:
+    #                 other_penalty += (critical_thresholds[metric] - score) * 0.3
+            
+    #         total_penalty = (space_exercise_penalty + other_penalty) / 2
+    #         base_score *= (1 - total_penalty)
+            
+    #         if len(critical_failures) > 1:
+    #             base_score *= (0.98 ** (len(critical_failures) - 1))  # 進一步降低多重失敗懲罰
+        
+    #     return base_score
+
     def calculate_base_score(scores: dict, weights: dict) -> float:
         """
-        計算基礎分數，更寬容地處理極端組合
+        計算基礎分數，加強訓練需求評估
         """
-        # 進一步降低關鍵指標閾值，使系統更包容極端組合
+        # 基礎閾值保持不變
         critical_thresholds = {
-        'space': 0.45,     # 進一步降低閾值
-        'exercise': 0.45,
-        'experience': 0.55,
-        'noise': 0.55
+            'space': 0.5,
+            'exercise': 0.5,
+            'experience': 0.55,
+            'noise': 0.55
         }
         
+        # 評估訓練需求
+        training_level = breed_info.get('Training', 'MODERATE').upper()
+        if training_level == 'HIGH' and user_prefs.experience_level == 'beginner':
+            # 對需要大量訓練的品種給予較低的基礎分數
+            base_score = sum(scores[k] * weights[k] for k in scores.keys()) * 0.85
+        else:
+            base_score = sum(scores[k] * weights[k] for k in scores.keys())
+        
+        # 其他評估邏輯保持不變...
         critical_failures = []
         for metric, threshold in critical_thresholds.items():
             if scores[metric] < threshold:
                 critical_failures.append((metric, scores[metric]))
         
-        base_score = sum(scores[k] * weights[k] for k in scores.keys())
-        
         if critical_failures:
-            space_exercise_penalty = 0
-            other_penalty = 0
-            
-            for metric, score in critical_failures:
-                if metric in ['space', 'exercise']:
-                    space_exercise_penalty += (critical_thresholds[metric] - score) * 0.15  # 降低懲罰
-                else:
-                    other_penalty += (critical_thresholds[metric] - score) * 0.3
-            
-            total_penalty = (space_exercise_penalty + other_penalty) / 2
-            base_score *= (1 - total_penalty)
+            penalty = sum((critical_thresholds[metric] - score) * 0.3 
+                         for metric, score in critical_failures) / len(critical_failures)
+            base_score *= (1 - penalty)
             
             if len(critical_failures) > 1:
-                base_score *= (0.98 ** (len(critical_failures) - 1))  # 進一步降低多重失敗懲罰
+                base_score *= (0.98 ** (len(critical_failures) - 1))
         
         return base_score
 
@@ -2329,75 +2102,71 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
 
 
 def amplify_score_extreme(score: float) -> float:
-    """優化分數分布，提供更高的分數範圍"""
+    """
+    優化分數分布，增加區分度
+    1. 擴大分數區間差異
+    2. 更合理的分數映射
+    """
     def smooth_curve(x: float, steepness: float = 12) -> float:
         import math
         return 1 / (1 + math.exp(-steepness * (x - 0.5)))
 
+    def apply_distinction_factor(base_score: float, distinction: float = 0.05) -> float:
+        """增加分數的區分度"""
+        # 根據原始分數的位置增加區分
+        position_factor = base_score - int(base_score * 10) / 10
+        return base_score + (position_factor * distinction)
+
     if score >= 0.9:
-        position = (score - 0.9) / 0.1
-        return 0.96 + (position * 0.04)  # 90-100的原始分映射到96-100
+        # 優秀匹配：92-100%
+        base = 0.92 + ((score - 0.9) * 0.08)
+        return apply_distinction_factor(base, 0.06)
         
     elif score >= 0.8:
-        position = (score - 0.8) / 0.1
-        return 0.90 + (position * 0.06)  # 80-90的原始分映射到90-96
+        # 很好匹配：85-92%
+        base = 0.85 + ((score - 0.8) * 0.07)
+        return apply_distinction_factor(base, 0.05)
         
     elif score >= 0.7:
-        position = (score - 0.7) / 0.1
-        return 0.82 + (position * 0.08)  # 70-80的原始分映射到82-90
+        # 良好匹配：76-85%
+        base = 0.76 + ((score - 0.7) * 0.09)
+        return apply_distinction_factor(base, 0.04)
         
     elif score >= 0.5:
+        # 一般匹配：65-76%
         position = (score - 0.5) / 0.2
-        return 0.75 + (smooth_curve(position) * 0.07)  # 50-70的原始分映射到75-82
+        base = 0.65 + (smooth_curve(position) * 0.11)
+        return apply_distinction_factor(base, 0.03)
         
     else:
+        # 較低匹配：60-65%
         position = score / 0.5
-        return 0.70 + (smooth_curve(position) * 0.05)  # 50以下的原始分映射到70-75
-        
+        base = 0.60 + (smooth_curve(position) * 0.05)
+        return apply_distinction_factor(base, 0.02)
+
 
 # def amplify_score_extreme(score: float) -> float:
-#     """
-#     - 完美匹配可達到95-99%
-#     - 優秀匹配在90-95%
-#     - 良好匹配在85-90%
-#     - 一般匹配在75-85%
-#     - 較差匹配在65-75%
-#     - 極差匹配在50-65%
-#     """
+#     """優化分數分布，提供更高的分數範圍"""
 #     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.9:
-#         # 完美匹配：95-99%
 #         position = (score - 0.9) / 0.1
-#         return 0.95 + (position * 0.04)
+#         return 0.96 + (position * 0.04)  # 90-100的原始分映射到96-100
         
 #     elif score >= 0.8:
-#         # 優秀匹配：90-95%
 #         position = (score - 0.8) / 0.1
-#         return 0.90 + (position * 0.05)
+#         return 0.90 + (position * 0.06)  # 80-90的原始分映射到90-96
         
 #     elif score >= 0.7:
-#         # 良好匹配：85-90%
 #         position = (score - 0.7) / 0.1
-#         return 0.85 + (position * 0.05)
+#         return 0.82 + (position * 0.08)  # 70-80的原始分映射到82-90
         
 #     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.3:
-#         # 較差匹配：65-75%
-#         position = (score - 0.3) / 0.2
-#         base = 0.65
-#         return base + (smooth_curve(position) * 0.10)
+#         return 0.75 + (smooth_curve(position) * 0.07)  # 50-70的原始分映射到75-82
         
 #     else:
-#         # 極差匹配：50-65%
-#         position = score / 0.3
-#         base = 0.50
-#         return base + (smooth_curve(position) * 0.15)
+#         position = score / 0.5
+#         return 0.70 + (smooth_curve(position) * 0.05)  # 50以下的原始分映射到70-75