Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -3,59 +3,29 @@ from breed_health_info import breed_health_info
 from breed_noise_info import breed_noise_info
 import traceback
 import math
-import random
-
-# @dataclass
-# class UserPreferences:
-
-#     """使用者偏好設定的資料結構"""
-#     living_space: str  # "apartment", "house_small", "house_large"
-#     yard_access: str  # "no_yard", "shared_yard", "private_yard" 
-#     exercise_time: int  # minutes per day
-#     exercise_type: str  # "light_walks", "moderate_activity", "active_training" 
-#     grooming_commitment: str  # "low", "medium", "high"
-#     experience_level: str  # "beginner", "intermediate", "advanced"
-#     time_availability: str  # "limited", "moderate", "flexible" 
-#     has_children: bool
-#     children_age: str  # "toddler", "school_age", "teenager"
-#     noise_tolerance: str  # "low", "medium", "high"
-#     space_for_play: bool
-#     other_pets: bool
-#     climate: str  # "cold", "moderate", "hot"
-#     health_sensitivity: str = "medium"
-#     barking_acceptance: str = None
-
-#     def __post_init__(self):
-#         """在初始化後運行，用於設置派生值"""
-#         if self.barking_acceptance is None:
-#             self.barking_acceptance = self.noise_tolerance
 
 @dataclass
 class UserPreferences:
-    """使用者偏好設定的資料結構，整合基本條件與進階評估參數"""
-    living_space: str        # "apartment", "house_small", "house_large"
-    yard_access: str        # "no_yard", "shared_yard", "private_yard"
-    exercise_time: int      # 每日運動時間（分鐘）
-    exercise_type: str      # "light_walks", "moderate_activity", "active_training"
-    grooming_commitment: str    # "low", "medium", "high"
-    experience_level: str       # "beginner", "intermediate", "advanced"
-    time_availability: str      # "limited", "moderate", "flexible"
+
+    """使用者偏好設定的資料結構"""
+    living_space: str  # "apartment", "house_small", "house_large"
+    yard_access: str  # "no_yard", "shared_yard", "private_yard" 
+    exercise_time: int  # minutes per day
+    exercise_type: str  # "light_walks", "moderate_activity", "active_training" 
+    grooming_commitment: str  # "low", "medium", "high"
+    experience_level: str  # "beginner", "intermediate", "advanced"
+    time_availability: str  # "limited", "moderate", "flexible" 
     has_children: bool
-    children_age: str       # "toddler", "school_age", "teenager"
-    noise_tolerance: str    # "low", "medium", "high"
+    children_age: str  # "toddler", "school_age", "teenager"
+    noise_tolerance: str  # "low", "medium", "high"
     space_for_play: bool
     other_pets: bool
-    climate: str           # "cold", "moderate", "hot"
-
-    living_floor: int = 1   # 居住樓層，對公寓住戶特別重要
-    exercise_intensity: str = "moderate"  # "low", "moderate", "high"
-    home_alone_time: int = 4    # 每日獨處時間（小時）
-    health_sensitivity: str = "medium"    # "low", "medium", "high"
-    barking_acceptance: str = None        # 如果未指定，默認使用 noise_tolerance
-    lifestyle_activity: str = "moderate"  # "sedentary", "moderate", "active"
+    climate: str  # "cold", "moderate", "hot"
+    health_sensitivity: str = "medium"
+    barking_acceptance: str = None
 
     def __post_init__(self):
-        """初始化後執行，用於設置派生值和驗證"""
+        """在初始化後運行，用於設置派生值"""
         if self.barking_acceptance is None:
             self.barking_acceptance = self.noise_tolerance
 
@@ -446,404 +416,182 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             raise KeyError("Size information missing")
             
 
-        # def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
-        #     """       
-        #     主要改進：
-        #     1. 更均衡的基礎分數分配
-        #     2. 更細緻的空間需求評估
-        #     3. 強化運動需求與空間的關聯性
-        #     """
-        #     # 重新設計基礎分數矩陣，降低普遍分數以增加區別度
-        #     base_scores = {
-        #         "Small": {
-        #             "apartment": 0.85,    # 降低滿分機會
-        #             "house_small": 0.80,  # 小型犬不應在大空間得到太高分數
-        #             "house_large": 0.75   # 避免小型犬總是得到最高分
-        #         },
-        #         "Medium": {
-        #             "apartment": 0.45,    # 維持對公寓環境的限制
-        #             "house_small": 0.75,  # 適中的分數
-        #             "house_large": 0.85   # 給予合理的獎勵
-        #         },
-        #         "Large": {
-        #             "apartment": 0.15,    # 加重對大型犬在公寓的限制
-        #             "house_small": 0.65,  # 中等適合度
-        #             "house_large": 0.90   # 最適合的環境
-        #         },
-        #         "Giant": {
-        #             "apartment": 0.10,    # 更嚴格的限制
-        #             "house_small": 0.45,  # 顯著的空間限制
-        #             "house_large": 0.95   # 最理想的配對
-        #         }
-        #     }
-            
-        #     # 取得基礎分數
-        #     base_score = base_scores.get(size, base_scores["Medium"])[living_space]
-            
-        #     # 運動需求相關的調整更加動態
-        #     exercise_adjustments = {
-        #         "Very High": {
-        #             "apartment": -0.25,    # 加重在受限空間的懲罰
-        #             "house_small": -0.15,
-        #             "house_large": -0.05
-        #         },
-        #         "High": {
-        #             "apartment": -0.20,
-        #             "house_small": -0.10,
-        #             "house_large": 0
-        #         },
-        #         "Moderate": {
-        #             "apartment": -0.10,
-        #             "house_small": -0.05,
-        #             "house_large": 0
-        #         },
-        #         "Low": {
-        #             "apartment": 0.05,     # 低運動需求在小空間反而有優勢
-        #             "house_small": 0,
-        #             "house_large": -0.05   # 輕微降低評分，因為空間可能過大
-        #         }
-        #     }
-            
-        #     # 根據空間類型獲取運動需求調整
-        #     adjustment = exercise_adjustments.get(exercise_needs, 
-        #                                         exercise_adjustments["Moderate"])[living_space]
-            
-        #     # 院子效益根據品種大小和運動需求動態調整
-        #     if has_yard:
-        #         yard_bonus = {
-        #             "Giant": 0.20,
-        #             "Large": 0.15,
-        #             "Medium": 0.10,
-        #             "Small": 0.05
-        #         }.get(size, 0.10)
-                
-        #         # 運動需求會影響院子的重要性
-        #         if exercise_needs in ["Very High", "High"]:
-        #             yard_bonus *= 1.2
-        #         elif exercise_needs == "Low":
-        #             yard_bonus *= 0.8
-                    
-        #         current_score = base_score + adjustment + yard_bonus
-        #     else:
-        #         current_score = base_score + adjustment
-                
-        #     # 確保分數在合理範圍內，但避免極端值
-        #     return min(0.95, max(0.15, current_score))
-
-
-        # def calculate_exercise_score(breed_needs: str, exercise_time: int, exercise_type: str) -> float:
-        #     """
-        #     精確評估品種運動需求與使用者運動條件的匹配度
-            
-        #     Parameters:
-        #     breed_needs: 品種的運動需求等級
-        #     exercise_time: 使用者能提供的運動時間（分鐘）
-        #     exercise_type: 使用者偏好的運動類型
-            
-        #     Returns:
-        #     float: -0.2 到 0.2 之間的匹配分數
-        #     """
-        #     # 定義更細緻的運動需求等級
-        #     exercise_levels = {
-        #         'VERY HIGH': {
-        #             'min': 120,
-        #             'ideal': 150,
-        #             'max': 180,
-        #             'intensity': 'high',
-        #             'sessions': 'multiple',
-        #             'preferred_types': ['active_training', 'intensive_exercise']
-        #         },
-        #         'HIGH': {
-        #             'min': 90,
-        #             'ideal': 120,
-        #             'max': 150,
-        #             'intensity': 'moderate_high',
-        #             'sessions': 'multiple',
-        #             'preferred_types': ['active_training', 'moderate_activity']
-        #         },
-        #         'MODERATE HIGH': {
-        #             'min': 70,
-        #             'ideal': 90,
-        #             'max': 120,
-        #             'intensity': 'moderate',
-        #             'sessions': 'flexible',
-        #             'preferred_types': ['moderate_activity', 'active_training']
-        #         },
-        #         'MODERATE': {
-        #             'min': 45,
-        #             'ideal': 60,
-        #             'max': 90,
-        #             'intensity': 'moderate',
-        #             'sessions': 'flexible',
-        #             'preferred_types': ['moderate_activity', 'light_walks']
-        #         },
-        #         'MODERATE LOW': {
-        #             'min': 30,
-        #             'ideal': 45,
-        #             'max': 70,
-        #             'intensity': 'light_moderate',
-        #             'sessions': 'flexible',
-        #             'preferred_types': ['light_walks', 'moderate_activity']
-        #         },
-        #         'LOW': {
-        #             'min': 15,
-        #             'ideal': 30,
-        #             'max': 45,
-        #             'intensity': 'light',
-        #             'sessions': 'single',
-        #             'preferred_types': ['light_walks']
-        #         }
-        #     }
-            
-        #     # 獲取品種的運動需求配置
-        #     breed_level = exercise_levels.get(breed_needs.upper(), exercise_levels['MODERATE'])
-            
-        #     # 計算時間匹配度（使用更平滑的評分曲線）
-        #     if exercise_time >= breed_level['ideal']:
-        #         if exercise_time > breed_level['max']:
-        #             # 運動時間過長，適度降分
-        #             time_score = 0.15 - (0.05 * (exercise_time - breed_level['max']) / 30)
-        #         else:
-        #             time_score = 0.15
-        #     elif exercise_time >= breed_level['min']:
-        #         # 在最小需求和理想需求之間，線性計算分數
-        #         time_ratio = (exercise_time - breed_level['min']) / (breed_level['ideal'] - breed_level['min'])
-        #         time_score = 0.05 + (time_ratio * 0.10)
-        #     else:
-        #         # 運動時間不足，根據差距程度扣分
-        #         time_ratio = max(0, exercise_time / breed_level['min'])
-        #         time_score = -0.15 * (1 - time_ratio)
-            
-        #     # 運動類型匹配度評估
-        #     type_score = 0.0
-        #     if exercise_type in breed_level['preferred_types']:
-        #         type_score = 0.05
-        #         if exercise_type == breed_level['preferred_types'][0]:
-        #             type_score = 0.08  # 最佳匹配類型給予更高分數
-            
-        #     return max(-0.2, min(0.2, time_score + type_score))
-
-
-        def calculate_space_score(breed_info: dict, user_prefs: UserPreferences) -> float:
-            """
-            計算品種與居住空間的匹配程度
-            
-            這個函數實現了一個全面的空間評分系統，考慮：
-            1. 基本空間需求（住所類型與品種大小的匹配）
-            2. 樓層因素（特別是公寓住戶）
-            3. 戶外活動空間（院子類型及可用性）
-            4. 室內活動空間的實際可用性
-            5. 品種的特殊空間需求
-            
-            Parameters:
-            -----------
-            breed_info: 包含品種特徵的字典，包括體型、活動需求等
-            user_prefs: 使用者偏好設定，包含居住條件相關信息
-            
-            Returns:
-            --------
-            float: 0.0-1.0 之間的匹配分數
+        def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
+            """       
+            主要改進：
+            1. 更均衡的基礎分數分配
+            2. 更細緻的空間需求評估
+            3. 強化運動需求與空間的關聯性
             """
-            # 取得品種基本信息
-            size = breed_info.get('Size', 'Medium')
-            temperament = breed_info.get('Temperament', '').lower()
-            exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-            
-            # 基礎空間需求評分矩陣 - 考慮品種大小與居住空間的基本匹配度
-            base_space_scores = {
+            # 重新設計基礎分數矩陣，降低普遍分數以增加區別度
+            base_scores = {
                 "Small": {
-                    "apartment": 0.95,      # 小型犬最適合公寓
-                    "house_small": 0.90,    # 小房子也很適合
-                    "house_large": 0.85     # 大房子可能過大
+                    "apartment": 0.85,    # 降低滿分機會
+                    "house_small": 0.80,  # 小型犬不應在大空間得到太高分數
+                    "house_large": 0.75   # 避免小型犬總是得到最高分
                 },
                 "Medium": {
-                    "apartment": 0.60,      # 中型犬在公寓有一定限制
-                    "house_small": 0.85,    # 小房子較適合
-                    "house_large": 0.95     # 大房子最理想
+                    "apartment": 0.45,    # 維持對公寓環境的限制
+                    "house_small": 0.75,  # 適中的分數
+                    "house_large": 0.85   # 給予合理的獎勵
                 },
                 "Large": {
-                    "apartment": 0.30,      # 大型犬不適合公寓
-                    "house_small": 0.70,    # 小房子稍嫌擁擠
-                    "house_large": 1.0      # 大房子最理想
+                    "apartment": 0.15,    # 加重對大型犬在公寓的限制
+                    "house_small": 0.65,  # 中等適合度
+                    "house_large": 0.90   # 最適合的環境
                 },
                 "Giant": {
-                    "apartment": 0.20,      # 極大型犬極不適合公寓
-                    "house_small": 0.50,    # 小房子明顯不足
-                    "house_large": 1.0      # 大房子必需
+                    "apartment": 0.10,    # 更嚴格的限制
+                    "house_small": 0.45,  # 顯著的空間限制
+                    "house_large": 0.95   # 最理想的配對
                 }
             }
             
-            # 取得基礎空間分數
-            base_score = base_space_scores.get(size, base_space_scores["Medium"])[user_prefs.living_space]
-            
-            # 公寓特殊考量
-            if user_prefs.living_space == "apartment":
-                # 樓層調整
-                floor_penalty = 0
-                if user_prefs.living_floor > 1:
-                    if size in ["Large", "Giant"]:
-                        floor_penalty = min(0.3, (user_prefs.living_floor - 1) * 0.05)
-                    elif size == "Medium":
-                        floor_penalty = min(0.2, (user_prefs.living_floor - 1) * 0.03)
-                    else:
-                        floor_penalty = min(0.1, (user_prefs.living_floor - 1) * 0.02)
-                base_score = max(0.2, base_score - floor_penalty)
-            
-            # 戶外空間評估
-            yard_scores = {
-                "no_yard": 0,
-                "shared_yard": 0.1,
-                "private_yard": 0.2
-            }
-            
-            # 根據品種大小調整院子加分
-            yard_size_multipliers = {
-                "Giant": 1.2,
-                "Large": 1.1,
-                "Medium": 1.0,
-                "Small": 0.8
+            # 取得基礎分數
+            base_score = base_scores.get(size, base_scores["Medium"])[living_space]
+            
+            # 運動需求相關的調整更加動態
+            exercise_adjustments = {
+                "Very High": {
+                    "apartment": -0.25,    # 加重在受限空間的懲罰
+                    "house_small": -0.15,
+                    "house_large": -0.05
+                },
+                "High": {
+                    "apartment": -0.20,
+                    "house_small": -0.10,
+                    "house_large": 0
+                },
+                "Moderate": {
+                    "apartment": -0.10,
+                    "house_small": -0.05,
+                    "house_large": 0
+                },
+                "Low": {
+                    "apartment": 0.05,     # 低運動需求在小空間反而有優勢
+                    "house_small": 0,
+                    "house_large": -0.05   # 輕微降低評分，因為空間可能過大
+                }
             }
             
-            yard_bonus = yard_scores[user_prefs.yard_access] * yard_size_multipliers.get(size, 1.0)
-            
-            # 活動空間需求評估
-            activity_space_score = 0
-            if user_prefs.space_for_play:
-                if exercise_needs in ["VERY HIGH", "HIGH"]:
-                    activity_space_score = 0.15
-                elif exercise_needs == "MODERATE":
-                    activity_space_score = 0.10
-                else:
-                    activity_space_score = 0.05
-            
-            # 品種特性評估
-            temperament_adjustments = 0
-            if 'active' in temperament or 'energetic' in temperament:
-                if user_prefs.living_space == 'apartment':
-                    temperament_adjustments -= 0.15
-                elif user_prefs.living_space == 'house_small':
-                    temperament_adjustments -= 0.05
-                    
-            if 'calm' in temperament or 'lazy' in temperament:
-                if user_prefs.living_space == 'apartment':
-                    temperament_adjustments += 0.10
+            # 根據空間類型獲取運動需求調整
+            adjustment = exercise_adjustments.get(exercise_needs, 
+                                                exercise_adjustments["Moderate"])[living_space]
+            
+            # 院子效益根據品種大小和運動需求動態調整
+            if has_yard:
+                yard_bonus = {
+                    "Giant": 0.20,
+                    "Large": 0.15,
+                    "Medium": 0.10,
+                    "Small": 0.05
+                }.get(size, 0.10)
+                
+                # 運動需求會影響院子的重要性
+                if exercise_needs in ["Very High", "High"]:
+                    yard_bonus *= 1.2
+                elif exercise_needs == "Low":
+                    yard_bonus *= 0.8
                     
-            if 'adaptable' in temperament:
-                temperament_adjustments += 0.05
-            
-            # 家庭環境考量
-            if user_prefs.has_children:
-                if user_prefs.living_space == 'apartment':
-                    # 公寓中有孩童需要更多活動空間
-                    if size in ["Large", "Giant"]:
-                        base_score *= 0.85
-                    elif size == "Medium":
-                        base_score *= 0.90
-            
-            # 整合所有評分因素
-            final_score = base_score + yard_bonus + activity_space_score + temperament_adjustments
-            
-            # 確保最終分數在合理範圍內
-            return max(0.15, min(1.0, final_score))
+                current_score = base_score + adjustment + yard_bonus
+            else:
+                current_score = base_score + adjustment
+                
+            # 確保分數在合理範圍內，但避免極端值
+            return min(0.95, max(0.15, current_score))
 
 
-        def calculate_exercise_score(breed_needs: str, exercise_time: int, user_prefs: 'UserPreferences') -> float:
+        def calculate_exercise_score(breed_needs: str, exercise_time: int, exercise_type: str) -> float:
             """
-            計算品種運動需求與使用者條件的匹配分數
-            
-            這個函數實現了一個精細的運動評分系統，考慮：
-            1. 運動時間的匹配度（0-180分鐘）
-            2. 運動強度的適配性
-            3. 品種特性對運動的特殊需求
-            4. 生活方式的整體活躍度
+            精確評估品種運動需求與使用者運動條件的匹配度
             
             Parameters:
-            -----------
             breed_needs: 品種的運動需求等級
             exercise_time: 使用者能提供的運動時間（分鐘）
-            user_prefs: 使用者偏好設定，包含運動類型和強度等信息
+            exercise_type: 使用者偏好的運動類型
             
             Returns:
-            --------
-            float: 0.0-1.0 之間的匹配分數
+            float: -0.2 到 0.2 之間的匹配分數
             """
-            # 定義更精確的運動需求標準
+            # 定義更細緻的運動需求等級
             exercise_levels = {
                 'VERY HIGH': {
                     'min': 120,
                     'ideal': 150,
                     'max': 180,
-                    'intensity_required': 'high',
-                    'intensity_factors': {'high': 1.2, 'moderate': 0.8, 'low': 0.6},
-                    'type_bonus': {'active_training': 0.15, 'moderate_activity': 0.05, 'light_walks': -0.1}
+                    'intensity': 'high',
+                    'sessions': 'multiple',
+                    'preferred_types': ['active_training', 'intensive_exercise']
                 },
                 'HIGH': {
                     'min': 90,
                     'ideal': 120,
                     'max': 150,
-                    'intensity_required': 'moderate',
-                    'intensity_factors': {'high': 1.1, 'moderate': 1.0, 'low': 0.7},
-                    'type_bonus': {'active_training': 0.1, 'moderate_activity': 0.1, 'light_walks': -0.05}
+                    'intensity': 'moderate_high',
+                    'sessions': 'multiple',
+                    'preferred_types': ['active_training', 'moderate_activity']
                 },
-                'MODERATE': {
-                    'min': 60,
+                'MODERATE HIGH': {
+                    'min': 70,
                     'ideal': 90,
                     'max': 120,
-                    'intensity_required': 'moderate',
-                    'intensity_factors': {'high': 1.0, 'moderate': 1.0, 'low': 0.8},
-                    'type_bonus': {'active_training': 0.05, 'moderate_activity': 0.1, 'light_walks': 0.05}
+                    'intensity': 'moderate',
+                    'sessions': 'flexible',
+                    'preferred_types': ['moderate_activity', 'active_training']
                 },
-                'LOW': {
-                    'min': 30,
+                'MODERATE': {
+                    'min': 45,
                     'ideal': 60,
                     'max': 90,
-                    'intensity_required': 'low',
-                    'intensity_factors': {'high': 0.7, 'moderate': 0.9, 'low': 1.0},
-                    'type_bonus': {'active_training': -0.05, 'moderate_activity': 0.05, 'light_walks': 0.1}
+                    'intensity': 'moderate',
+                    'sessions': 'flexible',
+                    'preferred_types': ['moderate_activity', 'light_walks']
+                },
+                'MODERATE LOW': {
+                    'min': 30,
+                    'ideal': 45,
+                    'max': 70,
+                    'intensity': 'light_moderate',
+                    'sessions': 'flexible',
+                    'preferred_types': ['light_walks', 'moderate_activity']
+                },
+                'LOW': {
+                    'min': 15,
+                    'ideal': 30,
+                    'max': 45,
+                    'intensity': 'light',
+                    'sessions': 'single',
+                    'preferred_types': ['light_walks']
                 }
             }
             
-            # 獲取品種運動需求配置
+            # 獲取品種的運動需求配置
             breed_level = exercise_levels.get(breed_needs.upper(), exercise_levels['MODERATE'])
             
-            # 計算基礎運動時間分數
-            def calculate_time_score(time: int, level: dict) -> float:
-                if time < level['min']:
-                    # 運動時間不足，指數下降
-                    return max(0.3, (time / level['min']) ** 1.5)
-                elif time < level['ideal']:
-                    # 運動時間接近理想，線性增長
-                    return 0.7 + 0.3 * ((time - level['min']) / (level['ideal'] - level['min']))
-                elif time <= level['max']:
-                    # 理想運動時間範圍，高分保持
-                    return 1.0
+            # 計算時間匹配度（使用更平滑的評分曲線）
+            if exercise_time >= breed_level['ideal']:
+                if exercise_time > breed_level['max']:
+                    # 運動時間過長，適度降分
+                    time_score = 0.15 - (0.05 * (exercise_time - breed_level['max']) / 30)
                 else:
-                    # 運動時間過多，緩慢扣分
-                    excess = (time - level['max']) / 30  # 每超過30分鐘扣分
-                    return max(0.7, 1.0 - (excess * 0.1))
-            
-            # 計算運動時間基礎分數
-            time_score = calculate_time_score(exercise_time, breed_level)
-            
-            # 計算運動強度匹配度
-            intensity_factor = breed_level['intensity_factors'].get(user_prefs.exercise_intensity, 1.0)
-            
-            # 運動類型加成
-            type_bonus = breed_level['type_bonus'].get(user_prefs.exercise_type, 0)
-            
-            # 生活方式調整
-            lifestyle_adjustments = {
-                'sedentary': -0.1,
-                'moderate': 0,
-                'active': 0.1
-            }
-            lifestyle_factor = lifestyle_adjustments.get(user_prefs.lifestyle_activity, 0)
-            
-            # 整合所有因素
-            final_score = time_score * intensity_factor + type_bonus + lifestyle_factor
-            
-            # 確保分數在合理範圍內
-            return max(0.1, min(1.0, final_score))
+                    time_score = 0.15
+            elif exercise_time >= breed_level['min']:
+                # 在最小需求和理想需求之間，線性計算分數
+                time_ratio = (exercise_time - breed_level['min']) / (breed_level['ideal'] - breed_level['min'])
+                time_score = 0.05 + (time_ratio * 0.10)
+            else:
+                # 運動時間不足，根據差距程度扣分
+                time_ratio = max(0, exercise_time / breed_level['min'])
+                time_score = -0.15 * (1 - time_ratio)
+            
+            # 運動類型匹配度評估
+            type_score = 0.0
+            if exercise_type in breed_level['preferred_types']:
+                type_score = 0.05
+                if exercise_type == breed_level['preferred_types'][0]:
+                    type_score = 0.08  # 最佳匹配類型給予更高分數
+            
+            return max(-0.2, min(0.2, time_score + type_score))
 
 
         def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
@@ -977,275 +725,114 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return max(0.1, min(1.0, final_score))
 
 
-        # def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
-        #     """
-        #     計算使用者經驗與品種需求的匹配分數，加強經驗等級的影響力
-            
-        #     重要改進：
-        #     1. 擴大基礎分數差異
-        #     2. 加重困難特徵的懲罰
-        #     3. 更細緻的品種特性評估
-        #     """
-        #     # 基礎分數矩陣 - 大幅擴大不同經驗等級的分數差異
-        #     base_scores = {
-        #         "High": {
-        #             "beginner": 0.10,      # 降低起始分，高難度品種對新手幾乎不推薦
-        #             "intermediate": 0.60,   # 中級玩家仍需謹慎
-        #             "advanced": 1.0        # 資深者能完全勝任
-        #         },
-        #         "Moderate": {
-        #             "beginner": 0.35,      # 適中難度對新手仍具挑戰
-        #             "intermediate": 0.80,   # 中級玩家較適合
-        #             "advanced": 1.0        # 資深者完全勝任
-        #         },
-        #         "Low": {
-        #             "beginner": 0.90,      # 新手友善品種
-        #             "intermediate": 0.95,   # 中級玩家幾乎完全勝任
-        #             "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.30,        # 固執性格嚴重影響新手
-        #             'independent': -0.25,      # 獨立性高的品種不適合新手
-        #             'dominant': -0.25,         # 支配性強的品種需要經驗處理
-        #             'strong-willed': -0.20,    # 強勢性格需要技巧管理
-        #             'protective': -0.20,       # 保護性強需要適當訓練
-        #             'aloof': -0.15,           # 冷漠性格需要耐心培養
-        #             'energetic': -0.15,       # 活潑好動需要經驗引導
-        #             'aggressive': -0.35        # 攻擊傾向極不適合新手
-        #         }
-                
-        #         # 新手友善的特徵 - 適度的獎勵
-        #         easy_traits = {
-        #             'gentle': 0.05,            # 溫和性格適合新手
-        #             'friendly': 0.05,          # 友善性格容易相處
-        #             'eager to please': 0.08,   # 願意服從較容易訓練
-        #             'patient': 0.05,           # 耐心的特質有助於建立關係
-        #             'adaptable': 0.05,         # 適應性強較容易照顧
-        #             'calm': 0.06              # 冷靜的性格較好掌握
-        #         }
-                
-        #         # 計算特徵調整
-        #         for trait, penalty in difficult_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += penalty
-                
-        #         for trait, bonus in easy_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += bonus
-                        
-        #         # 品種類型特殊評估
-        #         if 'terrier' in temperament_lower:
-        #             temperament_adjustments -= 0.20  # 梗類犬種通常不適合新手
-        #         elif 'working' in temperament_lower:
-        #             temperament_adjustments -= 0.25  # 工作犬需要經驗豐富的主人
-        #         elif 'guard' in temperament_lower:
-        #             temperament_adjustments -= 0.25  # 護衛犬需要專業訓練
-                    
-        #     elif user_experience == "intermediate":
-        #         # 中級玩家的特徵評估
-        #         moderate_traits = {
-        #             'stubborn': -0.15,        # 仍然需要注意，但懲罰較輕
-        #             'independent': -0.10,
-        #             'intelligent': 0.08,      # 聰明的特質可以好好發揮
-        #             'athletic': 0.06,         # 運動能力可以適當訓練
-        #             'versatile': 0.07,        # 多功能性可以開發
-        #             'protective': -0.08       # 保護性仍需注意
-        #         }
-                
-        #         for trait, adjustment in moderate_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += adjustment
-                        
-        #     else:  # advanced
-        #         # 資深玩家能夠應對挑戰性特徵
-        #         advanced_traits = {
-        #             'stubborn': 0.05,         # 困難特徵反而成為優勢
-        #             'independent': 0.05,
-        #             'intelligent': 0.10,
-        #             'protective': 0.05,
-        #             'strong-willed': 0.05
-        #         }
-                
-        #         for trait, bonus in advanced_traits.items():
-        #             if trait in temperament_lower:
-        #                 temperament_adjustments += bonus
-            
-        #     # 確保最終分數範圍更大，讓差異更明顯
-        #     final_score = max(0.05, min(1.0, score + temperament_adjustments))
-            
-        #     return final_score
-
-
-        def calculate_experience_score(breed_info: dict, user_prefs: UserPreferences) -> float:
+        def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
             """
-            計算飼主經驗與品種需求的匹配分數
-            
-            這個函數實現了一個全面的經驗評分系統，考慮：
-            1. 品種的基本照護難度
-            2. 飼主的經驗水平
-            3. 特殊照護需求（如健康問題、行為訓練）
-            4. 時間投入與生活方式的匹配
-            5. 家庭環境對照護的影響
-            
-            特別注意：
-            - 新手飼主面對高難度品種時的顯著降分
-            - 資深飼主照顧簡單品種的微幅降分
-            - 特殊需求品種的額外評估
+            計算使用者經驗與品種需求的匹配分數，加強經驗等級的影響力
             
-            Parameters:
-            -----------
-            breed_info: 包含品種特徵的字典
-            user_prefs: 使用者偏好設定
-            
-            Returns:
-            --------
-            float: 0.0-1.0 之間的匹配���數
+            重要改進：
+            1. 擴大基礎分數差異
+            2. 加重困難特徵的懲罰
+            3. 更細緻的品種特性評估
             """
-            care_level = breed_info.get('Care Level', 'MODERATE').upper()
-            temperament = breed_info.get('Temperament', '').lower()
-            health_issues = breed_info.get('Health Issues', '').lower()
-            
-            # 基礎照護難度評分矩陣
-            base_experience_scores = {
-                "HIGH": {
-                    "beginner": 0.30,      # 高難度品種對新手極具挑戰
-                    "intermediate": 0.70,   # 中級飼主需要額外努力
-                    "advanced": 0.95       # 資深飼主最適合
+            # 基礎分數矩陣 - 大幅擴大不同經驗等級的分數差異
+            base_scores = {
+                "High": {
+                    "beginner": 0.10,      # 降低起始分，高難度品種對新手幾乎不推薦
+                    "intermediate": 0.60,   # 中級玩家仍需謹慎
+                    "advanced": 1.0        # 資深者能完全勝任
                 },
-                "MODERATE": {
-                    "beginner": 0.60,      # 中等難度對新手有一定挑戰
-                    "intermediate": 0.85,   # 中級飼主較適合
-                    "advanced": 0.90       # 資深飼主可能稍嫌簡單
+                "Moderate": {
+                    "beginner": 0.35,      # 適中難度對新手仍具挑戰
+                    "intermediate": 0.80,   # 中級玩家較適合
+                    "advanced": 1.0        # 資深者完全勝任
                 },
-                "LOW": {
-                    "beginner": 0.90,      # 低難度適合新手
-                    "intermediate": 0.85,   # 中級飼主可能感覺無趣
-                    "advanced": 0.80       # 資深飼主可能缺乏挑戰
+                "Low": {
+                    "beginner": 0.90,      # 新手友善品種
+                    "intermediate": 0.95,   # 中級玩家幾乎完全勝任
+                    "advanced": 1.0        # 資深者完全勝任
                 }
             }
             
-            # 取得基礎經驗分數
-            base_score = base_experience_scores.get(care_level, 
-                                                  base_experience_scores["MODERATE"])[user_prefs.experience_level]
-            
-            # 時間可用性評估
-            time_adjustments = {
-                "limited": {
-                    "HIGH": -0.20,
-                    "MODERATE": -0.15,
-                    "LOW": -0.10
-                },
-                "moderate": {
-                    "HIGH": -0.10,
-                    "MODERATE": -0.05,
-                    "LOW": 0
-                },
-                "flexible": {
-                    "HIGH": 0,
-                    "MODERATE": 0.05,
-                    "LOW": 0.10
-                }
-            }
+            # 取得基礎分數
+            score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
             
-            time_adjustment = time_adjustments[user_prefs.time_availability][care_level]
+            temperament_lower = temperament.lower()
+            temperament_adjustments = 0.0
             
-            # 行為特徵評估
-            def evaluate_temperament(temp: str, exp_level: str) -> float:
-                """評估品種性格特徵與飼主經驗的匹配度"""
-                score = 0
-                
-                # 困難特徵評估
+            # 根據經驗等級設定不同的特徵評估標準
+            if user_experience == "beginner":
+                # 新手不適合的特徵 - 更嚴格的懲罰
                 difficult_traits = {
-                    'stubborn': {'beginner': -0.20, 'intermediate': -0.10, 'advanced': 0},
-                    'independent': {'beginner': -0.15, 'intermediate': -0.08, 'advanced': 0},
-                    'dominant': {'beginner': -0.20, 'intermediate': -0.10, 'advanced': -0.05},
-                    'aggressive': {'beginner': -0.25, 'intermediate': -0.15, 'advanced': -0.10}
+                    'stubborn': -0.30,        # 固執性格嚴重影響新手
+                    'independent': -0.25,      # 獨立性高的品種不適合新手
+                    'dominant': -0.25,         # 支配性強的品種需要經驗處理
+                    'strong-willed': -0.20,    # 強勢性格需要技巧管理
+                    'protective': -0.20,       # 保護性強需要適當訓練
+                    'aloof': -0.15,           # 冷漠性格需要耐心培養
+                    'energetic': -0.15,       # 活潑好動需要經驗引導
+                    'aggressive': -0.35        # 攻擊傾向極不適合新手
                 }
                 
-                # 友善特徵評估
-                friendly_traits = {
-                    'friendly': {'beginner': 0.10, 'intermediate': 0.05, 'advanced': 0},
-                    'gentle': {'beginner': 0.10, 'intermediate': 0.05, 'advanced': 0},
-                    'easy to train': {'beginner': 0.15, 'intermediate': 0.10, 'advanced': 0.05}
+                # 新手友善的特徵 - 適度的獎勵
+                easy_traits = {
+                    'gentle': 0.05,            # 溫和性格適合新手
+                    'friendly': 0.05,          # 友善性格容易相處
+                    'eager to please': 0.08,   # 願意服從較容易訓練
+                    'patient': 0.05,           # 耐心的特質有助於建立關係
+                    'adaptable': 0.05,         # 適應性強較容易照顧
+                    'calm': 0.06              # 冷靜的性格較好掌握
                 }
                 
-                # 計算特徵分數
-                for trait, penalties in difficult_traits.items():
-                    if trait in temp:
-                        score += penalties[exp_level]
-                        
-                for trait, bonuses in friendly_traits.items():
-                    if trait in temp:
-                        score += bonuses[exp_level]
-                
-                return score
-            
-            temperament_adjustment = evaluate_temperament(temperament, user_prefs.experience_level)
-            
-            # 健康問題評估
-            def evaluate_health_needs(health: str, exp_level: str) -> float:
-                """評估健康問題的照護難度"""
-                score = 0
-                serious_conditions = ['hip dysplasia', 'heart disease', 'cancer']
-                moderate_conditions = ['allergies', 'skin problems', 'ear infections']
+                # 計算特徵調整
+                for trait, penalty in difficult_traits.items():
+                    if trait in temperament_lower:
+                        temperament_adjustments += penalty
                 
-                # 根據經驗等級調整健康問題的影響
-                health_impact = {
-                    'beginner': {'serious': -0.20, 'moderate': -0.10},
-                    'intermediate': {'serious': -0.15, 'moderate': -0.05},
-                    'advanced': {'serious': -0.10, 'moderate': -0.03}
+                for trait, bonus in easy_traits.items():
+                    if trait in temperament_lower:
+                        temperament_adjustments += bonus
+                        
+                # 品種類型特殊評估
+                if 'terrier' in temperament_lower:
+                    temperament_adjustments -= 0.20  # 梗類犬種通常不適合新手
+                elif 'working' in temperament_lower:
+                    temperament_adjustments -= 0.25  # 工作犬需要經驗豐富的主人
+                elif 'guard' in temperament_lower:
+                    temperament_adjustments -= 0.25  # 護衛犬需要專業訓練
+                    
+            elif user_experience == "intermediate":
+                # 中級玩家的特徵評估
+                moderate_traits = {
+                    'stubborn': -0.15,        # 仍然需要注意，但懲罰較輕
+                    'independent': -0.10,
+                    'intelligent': 0.08,      # 聰明的特質可以好好發揮
+                    'athletic': 0.06,         # 運動能力可以適當訓練
+                    'versatile': 0.07,        # 多功能性可以開發
+                    'protective': -0.08       # 保護性仍需注意
                 }
                 
-                for condition in serious_conditions:
-                    if condition in health:
-                        score += health_impact[exp_level]['serious']
+                for trait, adjustment in moderate_traits.items():
+                    if trait in temperament_lower:
+                        temperament_adjustments += adjustment
                         
-                for condition in moderate_conditions:
-                    if condition in health:
-                        score += health_impact[exp_level]['moderate']
+            else:  # advanced
+                # 資深玩家能夠應對挑戰性特徵
+                advanced_traits = {
+                    'stubborn': 0.05,         # 困難特徵反而成為優勢
+                    'independent': 0.05,
+                    'intelligent': 0.10,
+                    'protective': 0.05,
+                    'strong-willed': 0.05
+                }
                 
-                return score
+                for trait, bonus in advanced_traits.items():
+                    if trait in temperament_lower:
+                        temperament_adjustments += bonus
             
-            health_adjustment = evaluate_health_needs(health_issues, user_prefs.experience_level)
+            # 確保最終分數範圍更大，讓差異更明顯
+            final_score = max(0.05, min(1.0, score + temperament_adjustments))
             
-            # 家庭環境考量
-            family_adjustment = 0
-            if user_prefs.has_children:
-                if user_prefs.children_age == 'toddler':
-                    if user_prefs.experience_level == 'beginner':
-                        family_adjustment -= 0.15
-                    elif user_prefs.experience_level == 'intermediate':
-                        family_adjustment -= 0.10
-                elif user_prefs.children_age == 'school_age':
-                    if user_prefs.experience_level == 'beginner':
-                        family_adjustment -= 0.10
-            
-            # 生活方式匹配度
-            lifestyle_adjustments = {
-                'sedentary': -0.10 if care_level == 'HIGH' else 0,
-                'moderate': 0,
-                'active': 0.10 if care_level in ['HIGH', 'MODERATE'] else 0
-            }
-            lifestyle_adjustment = lifestyle_adjustments[user_prefs.lifestyle_activity]
-            
-            # 整合所有評分因素
-            final_score = base_score + time_adjustment + temperament_adjustment + \
-                         health_adjustment + family_adjustment + lifestyle_adjustment
-            
-            # 確保最終分數在合理範圍內
-            return max(0.15, min(1.0, final_score))
-    
+            return final_score
 
         def calculate_health_score(breed_name: str, user_prefs: UserPreferences) -> float:
             """
@@ -1355,343 +942,131 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return max(0.1, min(1.0, health_score))
             
 
-        # def calculate_noise_score(breed_name: str, user_prefs: UserPreferences) -> float:
-        #     """
-        #     計算品種噪音分數，特別加強噪音程度與生活環境的關聯性評估
-        #     """
-        #     if breed_name not in breed_noise_info:
-        #         return 0.5
-        
-        #     noise_info = breed_noise_info[breed_name]
-        #     noise_level = noise_info['noise_level'].lower()
-        #     noise_notes = noise_info['noise_notes'].lower()
-        
-        #     # 重新設計基礎噪音分數矩陣，考慮不同情境下的接受度
-        #     base_scores = {
-        #         'low': {
-        #             'low': 1.0,       # 安靜的狗對低容忍完美匹配
-        #             'medium': 0.95,   # 安靜的狗對一般容忍很好
-        #             'high': 0.90      # 安靜的狗對高容忍當然可以
-        #         },
-        #         'medium': {
-        #             'low': 0.60,      # 一般吠叫對低容忍較困難
-        #             'medium': 0.90,   # 一般吠叫對一般容忍可接受
-        #             'high': 0.95      # 一般吠叫對高容忍很好
-        #         },
-        #         'high': {
-        #             'low': 0.25,      # 愛叫的狗對低容忍極不適合
-        #             'medium': 0.65,   # 愛叫的狗對一般容忍有挑戰
-        #             'high': 0.90      # 愛叫的狗對高容忍可以接受
-        #         },
-        #         'varies': {
-        #             'low': 0.50,      # 不確定的情況對低容忍風險較大
-        #             'medium': 0.75,   # 不確定的情況對一般容忍可嘗試
-        #             'high': 0.85      # 不確定的情況對高容忍問題較小
-        #         }
-        #     }
-        
-        #     # 取得基礎分數
-        #     base_score = base_scores.get(noise_level, {'low': 0.6, 'medium': 0.75, 'high': 0.85})[user_prefs.noise_tolerance]
-        
-        #     # 吠叫原因評估，根據環境調整懲罰程度
-        #     barking_penalties = {
-        #         'separation anxiety': {
-        #             'apartment': -0.30,    # 在公寓對鄰居影響更大
-        #             'house_small': -0.25,
-        #             'house_large': -0.20
-        #         },
-        #         'excessive barking': {
-        #             'apartment': -0.25,
-        #             'house_small': -0.20,
-        #             'house_large': -0.15
-        #         },
-        #         'territorial': {
-        #             'apartment': -0.20,    # 在公寓更容易被觸發
-        #             'house_small': -0.15,
-        #             'house_large': -0.10
-        #         },
-        #         'alert barking': {
-        #             'apartment': -0.15,    # 公寓環境刺激較多
-        #             'house_small': -0.10,
-        #             'house_large': -0.08
-        #         },
-        #         'attention seeking': {
-        #             'apartment': -0.15,
-        #             'house_small': -0.12,
-        #             'house_large': -0.10
-        #         }
-        #     }
-        
-        #     # 計算環境相關的吠叫懲罰
-        #     living_space = user_prefs.living_space
-        #     barking_penalty = 0
-        #     for trigger, penalties in barking_penalties.items():
-        #         if trigger in noise_notes:
-        #             barking_penalty += penalties.get(living_space, -0.15)
+        def calculate_noise_score(breed_name: str, user_prefs: UserPreferences) -> float:
+            """
+            計算品種噪音分數，特別加強噪音程度與生活環境的關聯性評估
+            """
+            if breed_name not in breed_noise_info:
+                return 0.5
         
-        #     # 特殊情況評估
-        #     special_adjustments = 0
-        #     if user_prefs.has_children:
-        #         # 孩童年齡相關調整
-        #         child_age_adjustments = {
-        #             'toddler': {
-        #                 'high': -0.20,     # 幼童對吵鬧更敏感
-        #                 'medium': -0.15,
-        #                 'low': -0.05
-        #             },
-        #             'school_age': {
-        #                 'high': -0.15,
-        #                 'medium': -0.10,
-        #                 'low': -0.05
-        #             },
-        #             'teenager': {
-        #                 'high': -0.10,
-        #                 'medium': -0.05,
-        #                 'low': -0.02
-        #             }
-        #         }
-                
-        #         # 根據孩童年齡和噪音等級調整
-        #         age_adj = child_age_adjustments.get(user_prefs.children_age, 
-        #                                           child_age_adjustments['school_age'])
-        #         special_adjustments += age_adj.get(noise_level, -0.10)
+            noise_info = breed_noise_info[breed_name]
+            noise_level = noise_info['noise_level'].lower()
+            noise_notes = noise_info['noise_notes'].lower()
         
-        #     # 訓練性補償評估
-        #     trainability_bonus = 0
-        #     if 'responds well to training' in noise_notes:
-        #         trainability_bonus = 0.12
-        #     elif 'can be trained' in noise_notes:
-        #         trainability_bonus = 0.08
-        #     elif 'difficult to train' in noise_notes:
-        #         trainability_bonus = 0.02
+            # 重新設計基礎噪音分數矩陣，考慮不同情境下的接受度
+            base_scores = {
+                'low': {
+                    'low': 1.0,       # 安靜的狗對低容忍完美匹配
+                    'medium': 0.95,   # 安靜的狗對一般容忍很好
+                    'high': 0.90      # 安靜的狗對高容忍當然可以
+                },
+                'medium': {
+                    'low': 0.60,      # 一般吠叫對低容忍較困難
+                    'medium': 0.90,   # 一般吠叫對一般容忍可接受
+                    'high': 0.95      # 一般吠叫對高容忍很好
+                },
+                'high': {
+                    'low': 0.25,      # 愛叫的狗對低容忍極不適合
+                    'medium': 0.65,   # 愛叫的狗對一般容忍有挑戰
+                    'high': 0.90      # 愛叫的狗對高容忍可以接受
+                },
+                'varies': {
+                    'low': 0.50,      # 不確定的情況對低容忍風險較大
+                    'medium': 0.75,   # 不確定的情況對一般容忍可嘗試
+                    'high': 0.85      # 不確定的情況對高容忍問題較小
+                }
+            }
         
-        #     # 夜間吠叫特別考量
-        #     if 'night barking' in noise_notes or 'howls' in noise_notes:
-        #         if user_prefs.living_space == 'apartment':
-        #             special_adjustments -= 0.15
-        #         elif user_prefs.living_space == 'house_small':
-        #             special_adjustments -= 0.10
-        #         else:
-        #             special_adjustments -= 0.05
+            # 取得基礎分數
+            base_score = base_scores.get(noise_level, {'low': 0.6, 'medium': 0.75, 'high': 0.85})[user_prefs.noise_tolerance]
         
-        #     # 計算最終分數，確保更大的分數範圍
-        #     final_score = base_score + barking_penalty + special_adjustments + trainability_bonus
-        #     return max(0.1, min(1.0, final_score))
-
-
-        def calculate_noise_score(breed_info: dict, user_prefs: UserPreferences) -> float:
-            """
-            計算品種噪音特性與使用者需求的匹配分數
-            
-            這個函數建立了一個細緻的噪音評估系統，考慮多個關鍵因素：
-            1. 品種的基本吠叫傾向
-            2. 居住環境對噪音的敏感度
-            3. 吠叫的情境和原因
-            4. 鄰居影響的考量
-            5. 家庭成員的噪音承受度
-            6. 訓練可能性的評估
-            
-            特別注意：
-            - 公寓環境的嚴格標準
-            - 有幼童時的特殊考量
-            - 獨處時間的影響
-            - 品種的可訓練性
-            
-            Parameters:
-            -----------
-            breed_info: 包含品種特性的字典，包括吠叫傾向和訓練難度
-            user_prefs: 使用者偏好設定，包含噪音容忍度和環境因素
-            
-            Returns:
-            --------
-            float: 0.0-1.0 之間的匹配��數，分數越高表示噪音特性越符合需求
-            """
-            
-            # 提取基本資訊
-            noise_level = breed_info.get('Noise Level', 'MODERATE').upper()
-            barking_tendency = breed_info.get('Barking Tendency', 'MODERATE').upper()
-            trainability = breed_info.get('Trainability', 'MODERATE').upper()
-            temperament = breed_info.get('Temperament', '').lower()
-            
-            # 基礎噪音評分矩陣 - 考慮環境和噪音容忍度
-            base_noise_scores = {
-                "LOW": {
-                    "apartment": {
-                        "low": 1.0,     # 安靜的狗在公寓最理想
-                        "medium": 0.95,
-                        "high": 0.90
-                    },
-                    "house_small": {
-                        "low": 0.95,
-                        "medium": 0.90,
-                        "high": 0.85
-                    },
-                    "house_large": {
-                        "low": 0.90,
-                        "medium": 0.85,
-                        "high": 0.80    # 太安靜可能不夠警戒
-                    }
+            # 吠叫原因評估，根據環境調整懲罰程度
+            barking_penalties = {
+                'separation anxiety': {
+                    'apartment': -0.30,    # 在公寓對鄰居影響更大
+                    'house_small': -0.25,
+                    'house_large': -0.20
                 },
-                "MODERATE": {
-                    "apartment": {
-                        "low": 0.60,
-                        "medium": 0.80,
-                        "high": 0.85
-                    },
-                    "house_small": {
-                        "low": 0.70,
-                        "medium": 0.85,
-                        "high": 0.90
-                    },
-                    "house_large": {
-                        "low": 0.75,
-                        "medium": 0.90,
-                        "high": 0.95
-                    }
+                'excessive barking': {
+                    'apartment': -0.25,
+                    'house_small': -0.20,
+                    'house_large': -0.15
                 },
-                "HIGH": {
-                    "apartment": {
-                        "low": 0.20,    # 吵鬧的狗在公寓極不適合
-                        "medium": 0.40,
-                        "high": 0.60
-                    },
-                    "house_small": {
-                        "low": 0.30,
-                        "medium": 0.50,
-                        "high": 0.70
-                    },
-                    "house_large": {
-                        "low": 0.40,
-                        "medium": 0.60,
-                        "high": 0.80
-                    }
+                'territorial': {
+                    'apartment': -0.20,    # 在公寓更容易被觸發
+                    'house_small': -0.15,
+                    'house_large': -0.10
+                },
+                'alert barking': {
+                    'apartment': -0.15,    # 公寓環境刺激較多
+                    'house_small': -0.10,
+                    'house_large': -0.08
+                },
+                'attention seeking': {
+                    'apartment': -0.15,
+                    'house_small': -0.12,
+                    'house_large': -0.10
                 }
             }
-            
-            # 取得基礎噪音分數
-            base_score = base_noise_scores.get(noise_level, base_noise_scores["MODERATE"])\
-                        [user_prefs.living_space][user_prefs.noise_tolerance]
-            
-            # 吠叫情境評估
-            def evaluate_barking_context(temp: str, living_space: str) -> float:
-                """評估不同情境下的吠叫問題嚴重度"""
-                context_score = 0
-                
-                # 不同吠叫原因的權重
-                barking_contexts = {
-                    'separation anxiety': {
-                        'apartment': -0.25,
-                        'house_small': -0.20,
-                        'house_large': -0.15
-                    },
-                    'territorial': {
-                        'apartment': -0.20,
-                        'house_small': -0.15,
-                        'house_large': -0.10
+        
+            # 計算環境相關的吠叫懲罰
+            living_space = user_prefs.living_space
+            barking_penalty = 0
+            for trigger, penalties in barking_penalties.items():
+                if trigger in noise_notes:
+                    barking_penalty += penalties.get(living_space, -0.15)
+        
+            # 特殊情況評估
+            special_adjustments = 0
+            if user_prefs.has_children:
+                # 孩童年齡相關調整
+                child_age_adjustments = {
+                    'toddler': {
+                        'high': -0.20,     # 幼童對吵鬧更敏感
+                        'medium': -0.15,
+                        'low': -0.05
                     },
-                    'alert barking': {
-                        'apartment': -0.15,
-                        'house_small': -0.10,
-                        'house_large': -0.05
+                    'school_age': {
+                        'high': -0.15,
+                        'medium': -0.10,
+                        'low': -0.05
                     },
-                    'attention seeking': {
-                        'apartment': -0.15,
-                        'house_small': -0.10,
-                        'house_large': -0.08
+                    'teenager': {
+                        'high': -0.10,
+                        'medium': -0.05,
+                        'low': -0.02
                     }
                 }
                 
-                for context, penalties in barking_contexts.items():
-                    if context in temp:
-                        context_score += penalties[living_space]
-                
-                return context_score
-            
-            # 計算吠叫情境的影響
-            barking_context_adjustment = evaluate_barking_context(temperament, user_prefs.living_space)
-            
-            # 訓練可能性評估
-            trainability_adjustments = {
-                "HIGH": 0.10,      # 容易訓練可以改善吠叫問題
-                "MODERATE": 0.05,
-                "LOW": -0.05      # 難以訓練則較難改善
-            }
-            trainability_adjustment = trainability_adjustments.get(trainability, 0)
-            
-            # 家庭環境考量
-            family_adjustment = 0
-            if user_prefs.has_children:
-                child_age_factors = {
-                    'toddler': -0.20,    # 幼童需要安靜環境
-                    'school_age': -0.15,
-                    'teenager': -0.10
-                }
-                family_adjustment = child_age_factors.get(user_prefs.children_age, -0.15)
-                
-                # 根據噪音等級調整影響程度
-                if noise_level == "HIGH":
-                    family_adjustment *= 1.5
-                elif noise_level == "LOW":
-                    family_adjustment *= 0.5
-            
-            # 獨處時間的影響
-            alone_time_adjustment = 0
-            if user_prefs.home_alone_time > 6:
-                if 'separation anxiety' in temperament or noise_level == "HIGH":
-                    alone_time_adjustment = -0.15
-                elif noise_level == "MODERATE":
-                    alone_time_adjustment = -0.10
-            
-            # 鄰居影響評估（特別是公寓環境）
-            neighbor_adjustment = 0
-            if user_prefs.living_space == "apartment":
-                if noise_level == "HIGH":
-                    neighbor_adjustment = -0.15
-                elif noise_level == "MODERATE":
-                    neighbor_adjustment = -0.10
-                    
-                # 樓層因素
-                if user_prefs.living_floor > 1:
-                    neighbor_adjustment -= min(0.10, (user_prefs.living_floor - 1) * 0.02)
-            
-            # 整合所有評分因素
-            final_score = base_score + barking_context_adjustment + trainability_adjustment + \
-                         family_adjustment + alone_time_adjustment + neighbor_adjustment
-            
-            # 確保最終分數在合理範圍內
-            return max(0.15, min(1.0, final_score))
-
-    except Exception as e:
-        print(f"Error calculating compatibility score: {str(e)}")
-        return 60.0  # 返回最低分數作為默認值
-
-
-def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -> float:
-    """計算品種與環境的適應性加成"""
-    adaptability_score = 0.0
-    description = breed_info.get('Description', '').lower()
-    temperament = breed_info.get('Temperament', '').lower()
-    
-    # 環境適應性評估
-    if user_prefs.living_space == 'apartment':
-        if 'adaptable' in temperament or 'apartment' in description:
-            adaptability_score += 0.1
-        if breed_info.get('Size') == 'Small':
-            adaptability_score += 0.05
-    elif user_prefs.living_space == 'house_large':
-        if 'active' in temperament or 'energetic' in description:
-            adaptability_score += 0.1
-            
-    # 氣候適應性
-    if user_prefs.climate in description or user_prefs.climate in temperament:
-        adaptability_score += 0.05
+                # 根據孩童年齡和噪音等級調整
+                age_adj = child_age_adjustments.get(user_prefs.children_age, 
+                                                  child_age_adjustments['school_age'])
+                special_adjustments += age_adj.get(noise_level, -0.10)
         
-    return min(0.2, adaptability_score)
-
+            # 訓練性補償評估
+            trainability_bonus = 0
+            if 'responds well to training' in noise_notes:
+                trainability_bonus = 0.12
+            elif 'can be trained' in noise_notes:
+                trainability_bonus = 0.08
+            elif 'difficult to train' in noise_notes:
+                trainability_bonus = 0.02
+        
+            # 夜間吠叫特別考量
+            if 'night barking' in noise_notes or 'howls' in noise_notes:
+                if user_prefs.living_space == 'apartment':
+                    special_adjustments -= 0.15
+                elif user_prefs.living_space == 'house_small':
+                    special_adjustments -= 0.10
+                else:
+                    special_adjustments -= 0.05
+        
+            # 計算最終分數，確保更大的分數範圍
+            final_score = base_score + barking_penalty + special_adjustments + trainability_bonus
+            return max(0.1, min(1.0, final_score))
+            
 
-def calculate_breed_matching(breed_info: dict, user_prefs: UserPreferences) -> dict:
-    """計算品種的整體評分與匹配度"""
-    try:
+        # 1. 計算基礎分數
         print("\n=== 開始計算品種相容性分數 ===")
         print(f"處理品種: {breed_info.get('Breed', 'Unknown')}")
         print(f"品種信息: {breed_info}")
@@ -1699,46 +1074,58 @@ def calculate_breed_matching(breed_info: dict, user_prefs: UserPreferences) -> d
 
         # 計算所有基礎分數並整合到字典中
         scores = {
-            'space': calculate_space_score(breed_info, user_prefs),
+            'space': calculate_space_score(
+                breed_info['Size'], 
+                user_prefs.living_space,
+                user_prefs.yard_access != 'no_yard',
+                breed_info.get('Exercise Needs', 'Moderate')
+            ),
             'exercise': calculate_exercise_score(
                 breed_info.get('Exercise Needs', 'Moderate'),
                 user_prefs.exercise_time,
-                user_prefs
+                user_prefs.exercise_type
             ),
             'grooming': calculate_grooming_score(
                 breed_info.get('Grooming Needs', 'Moderate'),
                 user_prefs.grooming_commitment.lower(),
                 breed_info['Size']
             ),
-            'experience': calculate_experience_score(breed_info, user_prefs),
+            'experience': calculate_experience_score(
+                breed_info.get('Care Level', 'Moderate'),
+                user_prefs.experience_level,
+                breed_info.get('Temperament', '')
+            ),
             'health': calculate_health_score(
                 breed_info.get('Breed', ''),
                 user_prefs
             ),
             'noise': calculate_noise_score(
-                breed_info,
+                breed_info.get('Breed', ''),
                 user_prefs
             )
         }
 
-        # 計算最終相容性分數
-        final_score = calculate_compatibility_score(scores, user_prefs, breed_info)
-        
+        final_score = calculate_breed_compatibility_score(
+            scores=scores,
+            user_prefs=user_prefs,
+            breed_info=breed_info
+        )
+
         # 計算環境適應性加成
         adaptability_bonus = calculate_environmental_fit(breed_info, user_prefs)
-        
+
         # 整合最終分數和加成
         final_score = (final_score * 0.9) + (adaptability_bonus * 0.1)
         final_score = amplify_score_extreme(final_score)
-        
+
         # 更新並返回完整的評分結果
         scores.update({
             'overall': final_score,
             'adaptability_bonus': adaptability_bonus
         })
-        
+
         return scores
-        
+
     except Exception as e:
         print(f"\n!!!!! 發生嚴重錯誤 !!!!!")
         print(f"錯誤類型: {type(e).__name__}")
@@ -1748,328 +1135,149 @@ def calculate_breed_matching(breed_info: dict, user_prefs: UserPreferences) -> d
         return {k: 0.6 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}
 
 
-# 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.3  # 嚴重不適合
-#             elif breed_info['Size'] == 'Large':
-#                 space_multiplier = 0.4  # 明顯不適合
-#             elif breed_info['Size'] == 'Small':
-#                 space_multiplier = 1.4  # 明顯優勢
+def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -> float:
+    """計算品種與環境的適應性加成"""
+    adaptability_score = 0.0
+    description = breed_info.get('Description', '').lower()
+    temperament = breed_info.get('Temperament', '').lower()
+    
+    # ���境適應性評估
+    if user_prefs.living_space == 'apartment':
+        if 'adaptable' in temperament or 'apartment' in description:
+            adaptability_score += 0.1
+        if breed_info.get('Size') == 'Small':
+            adaptability_score += 0.05
+    elif user_prefs.living_space == 'house_large':
+        if 'active' in temperament or 'energetic' in description:
+            adaptability_score += 0.1
+            
+    # 氣候適應性
+    if user_prefs.climate in description or user_prefs.climate in temperament:
+        adaptability_score += 0.05
         
-#         # 運動需求評估
-#         exercise_multiplier = 1.0
-#         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  # 完美匹配
-#         elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
-#             exercise_multiplier = 0.5  # 運動過度
+    return min(0.2, adaptability_score)
 
-#         return space_multiplier, exercise_multiplier
 
-#     # 計算經驗匹配度
-#     def evaluate_experience():
-#         exp_multiplier = 1.0
-#         care_level = breed_info.get('Care Level', 'MODERATE')
+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.3  # 嚴重不適合
+            elif breed_info['Size'] == 'Large':
+                space_multiplier = 0.4  # 明顯不適合
+            elif breed_info['Size'] == 'Small':
+                space_multiplier = 1.4  # 明顯優勢
         
-#         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()
+        # 運動需求評估
+        exercise_multiplier = 1.0
+        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  # 完美匹配
+        elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
+            exercise_multiplier = 0.5  # 運動過度
 
-#     # 調整基礎分數
-#     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']
-#     }
+        return space_multiplier, exercise_multiplier
 
-#     # 計算加權平均，關鍵特徵佔更大權重
-#     weights = {
-#         'space': 0.35,
-#         'exercise': 0.30,
-#         'experience': 0.20,
-#         'grooming': 0.15,
-#         'health': 0.10,
-#         'noise': 0.10
-#     }
+    # 計算經驗匹配度
+    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.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
 
-#     # 動態調整權重
-#     if user_prefs.living_space == 'apartment':
-#         weights['space'] *= 1.5
-#         weights['noise'] *= 1.3
-    
-#     if abs(user_prefs.exercise_time - 120) > 60:  # 運動時間極端情況
-#         weights['exercise'] *= 1.4
+    # 取得特徵調整係數
+    space_mult, exercise_mult = evaluate_key_features()
+    exp_mult = evaluate_experience()
 
-#     # 正規化權重
-#     total_weight = sum(weights.values())
-#     normalized_weights = {k: v/total_weight for k, v in weights.items()}
+    # 調整基礎分數
+    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']
+    }
 
-#     # 計算最終分數
-#     final_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
+    # 計算加權平均，關鍵特徵佔更大權重
+    weights = {
+        'space': 0.35,
+        'exercise': 0.30,
+        'experience': 0.20,
+        'grooming': 0.15,
+        'health': 0.10,
+        'noise': 0.10
+    }
 
-#     # 品種特性加成
-#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+    # 動態調整權重
+    if user_prefs.living_space == 'apartment':
+        weights['space'] *= 1.5
+        weights['noise'] *= 1.3
     
-#     # 整合最終分數，保持在0-1範圍內
-#     return min(1.0, max(0.0, (final_score * 0.85) + (breed_bonus * 0.15)))
+    if abs(user_prefs.exercise_time - 120) > 60:  # 運動時間極端情況
+        weights['exercise'] *= 1.4
 
+    # 正規化權重
+    total_weight = sum(weights.values())
+    normalized_weights = {k: v/total_weight for k, v in weights.items()}
 
-# def amplify_score_extreme(score: float) -> float:
-#     """
-#     改進的分數轉換函數
-#     提供更大的分數範圍和更明顯的差異
-    
-#     轉換邏輯：
-#     - 極差匹配 (0.0-0.3) -> 60-68%
-#     - 較差匹配 (0.3-0.5) -> 68-75%
-#     - 中等匹配 (0.5-0.7) -> 75-85%
-#     - 良好匹配 (0.7-0.85) -> 85-92%
-#     - 優秀匹配 (0.85-1.0) -> 92-95%
-#     """
-#     if score < 0.3:
-#         # 極差匹配：快速線性增長
-#         return 0.60 + (score / 0.3) * 0.08
-#     elif score < 0.5:
-#         # 較差匹配：緩慢增長
-#         position = (score - 0.3) / 0.2
-#         return 0.68 + position * 0.07
-#     elif score < 0.7:
-#         # 中等匹配：穩定線性增長
-#         position = (score - 0.5) / 0.2
-#         return 0.75 + position * 0.10
-#     elif score < 0.85:
-#         # 良好匹配：加速增長
-#         position = (score - 0.7) / 0.15
-#         return 0.85 + position * 0.07
-#     else:
-#         # 優秀匹配：最後衝刺
-#         position = (score - 0.85) / 0.15
-#         return 0.92 + position * 0.03
-
+    # 計算最終分數
+    final_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
 
-def calculate_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
-    """
-    計算品種與使用者的整體相容性分數
-    
-    這是推薦系統的核心評分函數，負責：
-    1. 智能整合各面向評分
-    2. 動態調整評分權重
-    3. 處理關鍵條件的優先級
-    4. 產生最終的匹配分數
-    
-    評分策略：
-    - 基礎分數：由各項指標的加權平均獲得
-    - 動態權重：根據用戶情況動態調整各項權重
-    - 關鍵條件：某些條件不滿足會顯著降低總分
-    - 加成系統：特殊匹配會提供額外加分
-    
-    Parameters:
-    -----------
-    scores: 包含各項評分的字典
-    user_prefs: 使用者偏好設定
-    breed_info: 品種特性信息
+    # 品種特性加成
+    breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-    Returns:
-    --------
-    float: 60.0-95.0 之間的最終匹配分數
-    """
-    def calculate_dynamic_weights() -> dict:
-        """計算動態權重分配"""
-        # 基礎權重設定
-        weights = {
-            'space': 0.20,
-            'exercise': 0.20,
-            'experience': 0.15,
-            'grooming': 0.15,
-            'health': 0.15,
-            'noise': 0.15
-        }
-        
-        # 公寓住戶權重調整
-        if user_prefs.living_space == "apartment":
-            weights['space'] *= 1.3
-            weights['noise'] *= 1.3
-            weights['exercise'] *= 0.8
-        
-        # 有幼童時的權重調整
-        if user_prefs.has_children and user_prefs.children_age == 'toddler':
-            weights['experience'] *= 1.3
-            weights['noise'] *= 1.2
-            weights['health'] *= 1.2
-        
-        # 新手飼主的權重調整
-        if user_prefs.experience_level == 'beginner':
-            weights['experience'] *= 1.4
-            weights['health'] *= 1.2
-            weights['grooming'] *= 1.2
-        
-        # 健康敏感度的權重調整
-        if user_prefs.health_sensitivity == 'high':
-            weights['health'] *= 1.3
-        
-        # 運動時間極端情況的權重調整
-        if abs(user_prefs.exercise_time - 120) > 60:
-            weights['exercise'] *= 1.3
-        
-        # 正規化權重
-        total = sum(weights.values())
-        return {k: v/total for k, v in weights.items()}
-    
-    def calculate_critical_factors() -> float:
-        """評估關鍵因素的影響"""
-        critical_score = 1.0
-        
-        # 空間關鍵條件
-        if user_prefs.living_space == "apartment":
-            if breed_info['Size'] == 'Giant':
-                critical_score *= 0.7
-            elif breed_info['Size'] == 'Large':
-                critical_score *= 0.8
-        
-        # 運動需求關鍵條件
-        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-        if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 60:
-            critical_score *= 0.75
-        elif exercise_needs == 'HIGH' and user_prefs.exercise_time < 45:
-            critical_score *= 0.8
-        
-        # 新手飼主關鍵條件
-        if user_prefs.experience_level == 'beginner':
-            if 'aggressive' in breed_info.get('Temperament', '').lower():
-                critical_score *= 0.7
-            elif 'dominant' in breed_info.get('Temperament', '').lower():
-                critical_score *= 0.8
-        
-        # 噪音關鍵條件
-        if user_prefs.living_space == "apartment" and \
-           breed_info.get('Noise Level', 'MODERATE').upper() == 'HIGH' and \
-           user_prefs.noise_tolerance == 'low':
-            critical_score *= 0.7
-        
-        return critical_score
+    # 整合最終分數，保持在0-1範圍內
+    return min(1.0, max(0.0, (final_score * 0.85) + (breed_bonus * 0.15)))
     
-    def calculate_bonus_factors() -> float:
-        """計算額外加分因素"""
-        bonus = 1.0
-        temperament = breed_info.get('Temperament', '').lower()
-        
-        # 完美匹配加分
-        perfect_matches = 0
-        for score in scores.values():
-            if score > 0.9:
-                perfect_matches += 1
-        
-        if perfect_matches >= 3:
-            bonus += 0.05
-        
-        # 特殊匹配加分
-        if user_prefs.has_children and 'good with children' in temperament:
-            bonus += 0.03
-        
-        if user_prefs.living_space == "apartment" and 'adaptable' in temperament:
-            bonus += 0.03
-        
-        if user_prefs.experience_level == 'beginner' and 'easy to train' in temperament:
-            bonus += 0.03
-        
-        return min(1.15, bonus)
-    
-    # 計算動態權重
-    weights = calculate_dynamic_weights()
-    
-    # 計算基礎加權分數
-    base_score = sum(scores[k] * weights[k] for k in scores.keys())
-    
-    # 應用關鍵因素
-    critical_factor = calculate_critical_factors()
-    
-    # 計算加分
-    bonus_factor = calculate_bonus_factors()
-    
-    # 計算最終原始分數
-    raw_score = base_score * critical_factor * bonus_factor
-    
-    # 轉換為最終分數（60-95範圍）
-    final_score = 60 + (raw_score * 35)
-    
-    # 確保分數在合理範圍內並保留兩位小數
-    return round(max(60.0, min(95.0, final_score)), 2)
-
 
 def amplify_score_extreme(score: float) -> float:
     """
-    將原始相容性分數（0-1）轉換為最終評分（60-95）
-    
-    這個函數負責：
-    1. 將內部計算的原始分數轉換為更有意義的最終分數
-    2. 確保分數分布更自然且有區別性
-    3. 突出極佳和極差的匹配
-    4. 避免分數過度集中在中間區域
+    改進的分數轉換函數
+    提供更大的分數範圍和更明顯的差異
     
-    轉換策略：
-    - 極佳匹配（0.85-1.0）：轉換為 90-95 分
-    - 優良匹配（0.70-0.85）：轉換為 85-90 分
-    - 良好匹配（0.55-0.70）：轉換為 75-85 分
-    - 一般匹配（0.40-0.55）：轉換為 70-75 分
-    - 勉強匹配（0.25-0.40）：轉換為 65-70 分
-    - 不推薦匹配（0-0.25）：轉換為 60-65 分
-    
-    Parameters:
-    -----------
-    score: 原始相容性分數（0.0-1.0）
-    
-    Returns:
-    --------
-    float: 轉換後的最終分數（60.0-95.0）
+    轉換邏輯：
+    - 極差匹配 (0.0-0.3) -> 60-68%
+    - 較差匹配 (0.3-0.5) -> 68-75%
+    - 中等匹配 (0.5-0.7) -> 75-85%
+    - 良好匹配 (0.7-0.85) -> 85-92%
+    - 優秀匹配 (0.85-1.0) -> 92-95%
     """
-    # 使用分段函數進行更自然的轉換
-    if score >= 0.85:
-        # 極佳匹配：90-95分
-        position = (score - 0.85) / 0.15
-        return 90.0 + (position * 5.0)
-    elif score >= 0.70:
-        # 優良匹配：85-90分
-        position = (score - 0.70) / 0.15
-        return 85.0 + (position * 5.0)
-    elif score >= 0.55:
-        # 良好匹配：75-85分
-        position = (score - 0.55) / 0.15
-        return 75.0 + (position * 10.0)
-    elif score >= 0.40:
-        # 一般匹配：70-75分
-        position = (score - 0.40) / 0.15
-        return 70.0 + (position * 5.0)
-    elif score >= 0.25:
-        # 勉強匹配：65-70分
-        position = (score - 0.25) / 0.15
-        return 65.0 + (position * 5.0)
+    if score < 0.3:
+        # 極差匹配：快速線性增長
+        return 0.60 + (score / 0.3) * 0.08
+    elif score < 0.5:
+        # 較差匹配：緩慢增長
+        position = (score - 0.3) / 0.2
+        return 0.68 + position * 0.07
+    elif score < 0.7:
+        # 中等匹配：穩定線性增長
+        position = (score - 0.5) / 0.2
+        return 0.75 + position * 0.10
+    elif score < 0.85:
+        # 良好匹配：加速增長
+        position = (score - 0.7) / 0.15
+        return 0.85 + position * 0.07
     else:
-        # 不推薦匹配：60-65分
-        position = score / 0.25
-        return 60.0 + (position * 5.0)
+        # 優秀匹配：最後衝刺
+        position = (score - 0.85) / 0.15
+        return 0.92 + position * 0.03