Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -419,104 +419,370 @@ 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.90,    # 降低滿分機會
-                    "house_small": 0.85,  # 小型犬不應在大空間得到太高分數
-                    "house_large": 0.80   # 避免小型犬總是得到最高分
-                },
-                "Medium": {
-                    "apartment": 0.40,    # 維持對公寓環境的限制
-                    "house_small": 0.80,  # 適中的分數
-                    "house_large": 0.90   # 給予合理的獎勵
-                },
-                "Large": {
-                    "apartment": 0.10,    # 加重對大型犬在公寓的限制
-                    "house_small": 0.60,  # 中等適合度
-                    "house_large": 0.95   # 最適合的環境
-                },
-                "Giant": {
-                    "apartment": 0.10,    # 更嚴格的限制
-                    "house_small": 0.45,  # 顯著的空間限制
-                    "house_large": 0.95   # 最理想的配對
-                }
-            }
+        # def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
+        #     """       
+        #     主要改進：
+        #     1. 更均衡的基礎分數分配
+        #     2. 更細緻的空間需求評估
+        #     3. 強化運動需求與空間的關聯性
+        #     """
+        #     # 重新設計基礎分數矩陣，降低普遍分數以增加區別度
+        #     base_scores = {
+        #         "Small": {
+        #             "apartment": 0.90,    # 降低滿分機會
+        #             "house_small": 0.85,  # 小型犬不應在大空間得到太高分數
+        #             "house_large": 0.80   # 避免小型犬總是得到最高分
+        #         },
+        #         "Medium": {
+        #             "apartment": 0.40,    # 維持對公寓環境的限制
+        #             "house_small": 0.80,  # 適中的分數
+        #             "house_large": 0.90   # 給予合理的獎勵
+        #         },
+        #         "Large": {
+        #             "apartment": 0.10,    # 加重對大型犬在公寓的限制
+        #             "house_small": 0.60,  # 中等適合度
+        #             "house_large": 0.95   # 最適合的環境
+        #         },
+        #         "Giant": {
+        #             "apartment": 0.10,    # 更嚴格的限制
+        #             "house_small": 0.45,  # 顯著的空間限制
+        #             "house_large": 0.95   # 最理想的配對
+        #         }
+        #     }
             
-            # 取得基礎分數
-            base_score = base_scores.get(size, base_scores["Medium"])[living_space]
+        #     # 取得基礎分數
+        #     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   # 輕微降低評分，因為空間可能過大
-                }
-            }
+        #     # 運動需求相關的調整更加動態
+        #     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.08 * (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.20 * (1 - time_ratio)
             
-            # 根據空間類型獲取運動需求調整
-            adjustment = exercise_adjustments.get(exercise_needs, 
-                                                exercise_adjustments["Moderate"])[living_space]
+        #     # 運動類型匹配度評估
+        #     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  # 最佳匹配類型給予更高分數
             
-            # 院子效益根據品種大小和運動需求動態調整
-            if has_yard:
-                yard_bonus = {
-                    "Giant": 0.20,
-                    "Large": 0.15,
-                    "Medium": 0.10,
-                    "Small": 0.05
-                }.get(size, 0.10)
+        #     return max(-0.2, min(0.2, time_score + type_score))
+
+
+        def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
+            """
+            改進的空間評分系統，提供更細緻的居住環境評估
+            
+            改進重點：
+            1. 更動態的基礎分數矩陣
+            2. 強化空間品質評估
+            3. 增加極端情況處理
+            4. 考慮不同空間組合的協同效應
+            """
+            def get_base_score():
+                # 基礎分數矩陣 - 更極端的分數分配
+                base_matrix = {
+                    "Small": {
+                        "apartment": {
+                            "no_yard": 0.85,      # 小型犬在公寓仍然適合
+                            "shared_yard": 0.90,   # 共享院子提供額外活動空間
+                            "private_yard": 0.95   # 私人院子最理想
+                        },
+                        "house_small": {
+                            "no_yard": 0.80,
+                            "shared_yard": 0.85,
+                            "private_yard": 0.90
+                        },
+                        "house_large": {
+                            "no_yard": 0.75,
+                            "shared_yard": 0.80,
+                            "private_yard": 0.85
+                        }
+                    },
+                    "Medium": {
+                        "apartment": {
+                            "no_yard": 0.35,      # 中型犬在公寓較受限
+                            "shared_yard": 0.45,
+                            "private_yard": 0.55
+                        },
+                        "house_small": {
+                            "no_yard": 0.75,
+                            "shared_yard": 0.85,
+                            "private_yard": 0.90
+                        },
+                        "house_large": {
+                            "no_yard": 0.85,
+                            "shared_yard": 0.90,
+                            "private_yard": 0.95
+                        }
+                    },
+                    "Large": {
+                        "apartment": {
+                            "no_yard": 0.15,      # 大型犬在公寓極不適合
+                            "shared_yard": 0.25,
+                            "private_yard": 0.35
+                        },
+                        "house_small": {
+                            "no_yard": 0.55,
+                            "shared_yard": 0.65,
+                            "private_yard": 0.75
+                        },
+                        "house_large": {
+                            "no_yard": 0.85,
+                            "shared_yard": 0.90,
+                            "private_yard": 1.0
+                        }
+                    },
+                    "Giant": {
+                        "apartment": {
+                            "no_yard": 0.10,      # 巨型犬在公寓基本不適合
+                            "shared_yard": 0.20,
+                            "private_yard": 0.30
+                        },
+                        "house_small": {
+                            "no_yard": 0.40,
+                            "shared_yard": 0.50,
+                            "private_yard": 0.60
+                        },
+                        "house_large": {
+                            "no_yard": 0.80,
+                            "shared_yard": 0.90,
+                            "private_yard": 1.0
+                        }
+                    }
+                }
+                
+                yard_type = "private_yard" if has_yard else "no_yard"
+                return base_matrix.get(size, base_matrix["Medium"])[living_space][yard_type]
+        
+            def calculate_exercise_adjustment():
+                # 運動需求對空間評分的影響
+                exercise_impact = {
+                    "Very High": {
+                        "apartment": -0.30,    # 高運動需求在公寓環境更受限
+                        "house_small": -0.15,
+                        "house_large": -0.05
+                    },
+                    "High": {
+                        "apartment": -0.25,
+                        "house_small": -0.10,
+                        "house_large": 0
+                    },
+                    "Moderate": {
+                        "apartment": -0.15,
+                        "house_small": -0.05,
+                        "house_large": 0
+                    },
+                    "Low": {
+                        "apartment": 0.10,     # 低運動需求反而適合小空間
+                        "house_small": 0.05,
+                        "house_large": 0
+                    }
+                }
                 
-                # 運動需求會影響院子的重要性
-                if exercise_needs in ["Very High", "High"]:
-                    yard_bonus *= 1.2
-                elif exercise_needs == "Low":
-                    yard_bonus *= 0.8
+                return exercise_impact.get(exercise_needs, exercise_impact["Moderate"])[living_space]
+        
+            def calculate_yard_bonus():
+                # 院子效益評估更加細緻
+                if not has_yard:
+                    return 0
                     
-                current_score = base_score + adjustment + yard_bonus
-            else:
-                current_score = base_score + adjustment
+                yard_benefits = {
+                    "Giant": {
+                        "Very High": 0.25,
+                        "High": 0.20,
+                        "Moderate": 0.15,
+                        "Low": 0.10
+                    },
+                    "Large": {
+                        "Very High": 0.20,
+                        "High": 0.15,
+                        "Moderate": 0.10,
+                        "Low": 0.05
+                    },
+                    "Medium": {
+                        "Very High": 0.15,
+                        "High": 0.10,
+                        "Moderate": 0.08,
+                        "Low": 0.05
+                    },
+                    "Small": {
+                        "Very High": 0.10,
+                        "High": 0.08,
+                        "Moderate": 0.05,
+                        "Low": 0.03
+                    }
+                }
                 
-            # 確保分數在合理範圍內，但避免極端值
-            return min(0.95, max(0.15, current_score))
+                size_benefits = yard_benefits.get(size, yard_benefits["Medium"])
+                return size_benefits.get(exercise_needs, size_benefits["Moderate"])
+        
+            def apply_extreme_case_adjustments(score):
+                # 處理極端情況
+                if size == "Giant" and living_space == "apartment":
+                    return score * 0.5  # 巨型犬在公寓給予更嚴重的懲罰
+                
+                if size == "Large" and living_space == "apartment" and exercise_needs == "Very High":
+                    return score * 0.6  # 高運動需求的大型犬在公寓更不適合
+                    
+                if size == "Small" and living_space == "house_large" and exercise_needs == "Low":
+                    return score * 0.9  # 低運動需求的小型犬在大房子可能過於寬敞
+                    
+                return score
+        
+            # 計算最終分數
+            base_score = get_base_score()
+            exercise_adj = calculate_exercise_adjustment()
+            yard_bonus = calculate_yard_bonus()
+            
+            # 整合所有評分因素
+            initial_score = base_score + exercise_adj + yard_bonus
+            
+            # 應用極端情況調整
+            final_score = apply_extreme_case_adjustments(initial_score)
+            
+            # 確保分數在有效範圍內，但允許更極端的結果
+            return max(0.05, min(1.0, final_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 之間的匹配分數
+            改進重點：
+            1. 擴大分數範圍到 0.1-1.0
+            2. 加強運動類型影響
+            3. 考慮運動強度與時間的綜合效果
+            4. 更細緻的時間匹配評估
             """
-            # 定義更細緻的運動需求等級
             exercise_levels = {
                 'VERY HIGH': {
                     'min': 120,
@@ -524,7 +790,12 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     'max': 180,
                     'intensity': 'high',
                     'sessions': 'multiple',
-                    'preferred_types': ['active_training', 'intensive_exercise']
+                    'preferred_types': ['active_training', 'intensive_exercise'],
+                    'type_weights': {
+                        'active_training': 1.0,
+                        'moderate_activity': 0.6,
+                        'light_walks': 0.3
+                    }
                 },
                 'HIGH': {
                     'min': 90,
@@ -532,7 +803,12 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     'max': 150,
                     'intensity': 'moderate_high',
                     'sessions': 'multiple',
-                    'preferred_types': ['active_training', 'moderate_activity']
+                    'preferred_types': ['active_training', 'moderate_activity'],
+                    'type_weights': {
+                        'active_training': 0.9,
+                        'moderate_activity': 0.8,
+                        'light_walks': 0.4
+                    }
                 },
                 'MODERATE HIGH': {
                     'min': 70,
@@ -540,7 +816,12 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     'max': 120,
                     'intensity': 'moderate',
                     'sessions': 'flexible',
-                    'preferred_types': ['moderate_activity', 'active_training']
+                    'preferred_types': ['moderate_activity', 'active_training'],
+                    'type_weights': {
+                        'active_training': 0.8,
+                        'moderate_activity': 0.9,
+                        'light_walks': 0.5
+                    }
                 },
                 'MODERATE': {
                     'min': 45,
@@ -548,7 +829,12 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     'max': 90,
                     'intensity': 'moderate',
                     'sessions': 'flexible',
-                    'preferred_types': ['moderate_activity', 'light_walks']
+                    'preferred_types': ['moderate_activity', 'light_walks'],
+                    'type_weights': {
+                        'active_training': 0.7,
+                        'moderate_activity': 1.0,
+                        'light_walks': 0.8
+                    }
                 },
                 'MODERATE LOW': {
                     'min': 30,
@@ -556,7 +842,12 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     'max': 70,
                     'intensity': 'light_moderate',
                     'sessions': 'flexible',
-                    'preferred_types': ['light_walks', 'moderate_activity']
+                    'preferred_types': ['light_walks', 'moderate_activity'],
+                    'type_weights': {
+                        'active_training': 0.6,
+                        'moderate_activity': 0.9,
+                        'light_walks': 1.0
+                    }
                 },
                 'LOW': {
                     'min': 15,
@@ -564,37 +855,62 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     'max': 45,
                     'intensity': 'light',
                     'sessions': 'single',
-                    'preferred_types': ['light_walks']
+                    'preferred_types': ['light_walks'],
+                    'type_weights': {
+                        'active_training': 0.5,
+                        'moderate_activity': 0.8,
+                        'light_walks': 1.0
+                    }
                 }
             }
-            
-            # 獲取品種的運動需求配置
+        
             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.08 * (exercise_time - breed_level['max']) / 30)
+            # 時間匹配度評估（基礎分數）
+            def calculate_time_score():
+                if exercise_time >= breed_level['ideal']:
+                    if exercise_time > breed_level['max']:
+                        # 超出最大值的懲罰更明顯
+                        excess = (exercise_time - breed_level['max']) / 30
+                        return max(0.4, 1.0 - (excess * 0.2))
+                    return 1.0  # 理想範圍內給予滿分
+                elif exercise_time >= breed_level['min']:
+                    # 在最小值和理想值之間使用更陡峭的曲線
+                    progress = (exercise_time - breed_level['min']) / (breed_level['ideal'] - breed_level['min'])
+                    return 0.5 + (progress * 0.5)
                 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.20 * (1 - time_ratio)
-            
+                    # 低於最小值時給予更嚴厲的懲罰
+                    deficit_ratio = exercise_time / breed_level['min']
+                    return max(0.1, deficit_ratio * 0.5)
+        
             # 運動類型匹配度評估
-            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  # 最佳匹配類型給予更高分數
+            def calculate_type_score():
+                type_weight = breed_level['type_weights'].get(exercise_type, 0.5)
+                
+                # 根據運動需求等級調整類型權重
+                if breed_needs.upper() in ['VERY HIGH', 'HIGH']:
+                    if exercise_type == 'light_walks':
+                        type_weight *= 0.5  # 高需求品種做輕度運動的懲罰
+                elif breed_needs.upper() == 'LOW':
+                    if exercise_type == 'active_training':
+                        type_weight *= 0.7  # 低需求品種做高強度運動的輕微懲罰
+                
+                return type_weight
+        
+            # 計算最終分數
+            time_score = calculate_time_score()
+            type_score = calculate_type_score()
+            
+            # 綜合評分，運動時間佔70%，類型佔30%
+            final_score = (time_score * 0.7) + (type_score * 0.3)
             
-            return max(-0.2, min(0.2, time_score + type_score))
+            # 特殊情況調整
+            if exercise_time < breed_level['min'] * 0.5:  # 運動時間嚴重不足
+                final_score *= 0.5
+            elif exercise_time > breed_level['max'] * 1.5:  # 運動時間過多
+                final_score *= 0.7
+        
+            return max(0.1, min(1.0, final_score))
 
 
         def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
@@ -1293,166 +1609,335 @@ def calculate_environmental_fit(breed_info: dict, user_prefs: UserPreferences) -
 #         return 0.90 + position * 0.08
 
 
-def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
-    """改進的品種相容性評分系統"""
+# def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
+#     """改進的品種相容性評分系統"""
     
-    def evaluate_key_features():
-        # 空間適配性評估 - 更極端的調整
-        space_multiplier = 1.0
-        if user_prefs.living_space == 'apartment':
-            if breed_info['Size'] == 'Giant':
-                space_multiplier = 0.2  # 更嚴重的懲罰
-            elif breed_info['Size'] == 'Large':
-                space_multiplier = 0.3
-            elif breed_info['Size'] == 'Medium':
-                space_multiplier = 0.7
-            elif breed_info['Size'] == 'Small':
-                space_multiplier = 1.6  # 更大的獎勵
+#     def evaluate_key_features():
+#         # 空間適配性評估 - 更極端的調整
+#         space_multiplier = 1.0
+#         if user_prefs.living_space == 'apartment':
+#             if breed_info['Size'] == 'Giant':
+#                 space_multiplier = 0.2  # 更嚴重的懲罰
+#             elif breed_info['Size'] == 'Large':
+#                 space_multiplier = 0.3
+#             elif breed_info['Size'] == 'Medium':
+#                 space_multiplier = 0.7
+#             elif breed_info['Size'] == 'Small':
+#                 space_multiplier = 1.6  # 更大的獎勵
                 
-        # 運動需求評估 - 更細緻的匹配
-        exercise_multiplier = 1.0
-        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+#         # 運動需求評估 - 更細緻的匹配
+#         exercise_multiplier = 1.0
+#         exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
         
-        # 運動時間差異計算
-        time_diff_ratio = abs(user_prefs.exercise_time - get_ideal_exercise_time(exercise_needs)) / 60.0
+#         # 運動時間差異計算
+#         time_diff_ratio = abs(user_prefs.exercise_time - get_ideal_exercise_time(exercise_needs)) / 60.0
         
-        if exercise_needs == 'VERY HIGH':
-            if user_prefs.exercise_time < 90:
-                exercise_multiplier = max(0.2, 1.0 - time_diff_ratio)
-            elif user_prefs.exercise_time > 150:
-                exercise_multiplier = min(2.0, 1.0 + time_diff_ratio/2)
-        elif exercise_needs == 'HIGH':
-            if user_prefs.exercise_time < 60:
-                exercise_multiplier = max(0.3, 1.0 - time_diff_ratio)
-            elif user_prefs.exercise_time > 120:
-                exercise_multiplier = min(1.8, 1.0 + time_diff_ratio/2)
-        elif exercise_needs == 'LOW':
-            if user_prefs.exercise_time > 120:
-                exercise_multiplier = max(0.4, 1.0 - time_diff_ratio/2)
-
-        return space_multiplier, exercise_multiplier
-
-    def get_ideal_exercise_time(exercise_needs: str) -> int:
-        """獲取理想運動時間"""
-        return {
-            'VERY HIGH': 150,
-            'HIGH': 120,
-            'MODERATE HIGH': 90,
-            'MODERATE': 60,
-            'MODERATE LOW': 45,
-            'LOW': 30
-        }.get(exercise_needs, 60)
-
-    # 經驗匹配度評估 - 更強的影響力
-    def evaluate_experience():
-        exp_multiplier = 1.0
-        care_level = breed_info.get('Care Level', 'MODERATE')
+#         if exercise_needs == 'VERY HIGH':
+#             if user_prefs.exercise_time < 90:
+#                 exercise_multiplier = max(0.2, 1.0 - time_diff_ratio)
+#             elif user_prefs.exercise_time > 150:
+#                 exercise_multiplier = min(2.0, 1.0 + time_diff_ratio/2)
+#         elif exercise_needs == 'HIGH':
+#             if user_prefs.exercise_time < 60:
+#                 exercise_multiplier = max(0.3, 1.0 - time_diff_ratio)
+#             elif user_prefs.exercise_time > 120:
+#                 exercise_multiplier = min(1.8, 1.0 + time_diff_ratio/2)
+#         elif exercise_needs == 'LOW':
+#             if user_prefs.exercise_time > 120:
+#                 exercise_multiplier = max(0.4, 1.0 - time_diff_ratio/2)
+
+#         return space_multiplier, exercise_multiplier
+
+#     def get_ideal_exercise_time(exercise_needs: str) -> int:
+#         """獲取理想運動時間"""
+#         return {
+#             'VERY HIGH': 150,
+#             'HIGH': 120,
+#             'MODERATE HIGH': 90,
+#             'MODERATE': 60,
+#             'MODERATE LOW': 45,
+#             'LOW': 30
+#         }.get(exercise_needs, 60)
+
+#     # 經驗匹配度評估 - 更強的影響力
+#     def evaluate_experience():
+#         exp_multiplier = 1.0
+#         care_level = breed_info.get('Care Level', 'MODERATE')
         
-        if care_level == 'High':
-            if user_prefs.experience_level == 'beginner':
-                exp_multiplier = 0.3  # 更嚴重的懲罰
-            elif user_prefs.experience_level == 'advanced':
-                exp_multiplier = 1.5  # 更大的獎勵
-        elif care_level == 'Low':
-            if user_prefs.experience_level == 'advanced':
-                exp_multiplier = 0.8
+#         if care_level == 'High':
+#             if user_prefs.experience_level == 'beginner':
+#                 exp_multiplier = 0.3  # 更嚴重的懲罰
+#             elif user_prefs.experience_level == 'advanced':
+#                 exp_multiplier = 1.5  # 更大的獎勵
+#         elif care_level == 'Low':
+#             if user_prefs.experience_level == 'advanced':
+#                 exp_multiplier = 0.8
                 
-        return exp_multiplier
-
-    # 計算調整係數
-    space_mult, exercise_mult = evaluate_key_features()
-    exp_mult = evaluate_experience()
-
-    # 調整基礎分數
-    adjusted_scores = {
-        'space': scores['space'] * space_mult,
-        'exercise': scores['exercise'] * exercise_mult,
-        'experience': scores['experience'] * exp_mult,
-        'grooming': scores['grooming'],
-        'health': scores['health'] * (1.5 if user_prefs.health_sensitivity == 'high' else 1.0),
-        'noise': scores['noise']
-    }
+#         return exp_multiplier
 
-    # 基礎權重
-    weights = {
-        'space': 0.25,
-        'exercise': 0.25,
-        'experience': 0.15,
-        'grooming': 0.15,
-        'health': 0.10,
-        'noise': 0.10
-    }
+#     # 計算調整係數
+#     space_mult, exercise_mult = evaluate_key_features()
+#     exp_mult = evaluate_experience()
 
-    # 動態權重調整 - 更強的條件反應
-    if user_prefs.has_children:
-        if user_prefs.children_age == 'toddler':
-            weights['noise'] *= 2.0  # 更強的噪音影響
-            weights['experience'] *= 1.5
-            weights['health'] *= 1.3
-        elif user_prefs.children_age == 'school_age':
-            weights['noise'] *= 1.5
-            weights['experience'] *= 1.3
+#     # 調整基礎分數
+#     adjusted_scores = {
+#         'space': scores['space'] * space_mult,
+#         'exercise': scores['exercise'] * exercise_mult,
+#         'experience': scores['experience'] * exp_mult,
+#         'grooming': scores['grooming'],
+#         'health': scores['health'] * (1.5 if user_prefs.health_sensitivity == 'high' else 1.0),
+#         'noise': scores['noise']
+#     }
 
-    if user_prefs.living_space == 'apartment':
-        weights['space'] *= 1.8  # 更強的空間限制
-        weights['noise'] *= 1.6
+#     # 基礎權重
+#     weights = {
+#         'space': 0.25,
+#         'exercise': 0.25,
+#         'experience': 0.15,
+#         'grooming': 0.15,
+#         'health': 0.10,
+#         'noise': 0.10
+#     }
+
+#     # 動態權重調整 - 更強的條件反應
+#     if user_prefs.has_children:
+#         if user_prefs.children_age == 'toddler':
+#             weights['noise'] *= 2.0  # 更強的噪音影響
+#             weights['experience'] *= 1.5
+#             weights['health'] *= 1.3
+#         elif user_prefs.children_age == 'school_age':
+#             weights['noise'] *= 1.5
+#             weights['experience'] *= 1.3
+
+#     if user_prefs.living_space == 'apartment':
+#         weights['space'] *= 1.8  # 更強的空間限制
+#         weights['noise'] *= 1.6
+
+#     # 運動時間極端情況
+#     if user_prefs.exercise_time < 30:
+#         weights['exercise'] *= 2.0
+#     elif user_prefs.exercise_time > 150:
+#         weights['exercise'] *= 1.5
+
+#     # 正規化權重
+#     total_weight = sum(weights.values())
+#     normalized_weights = {k: v/total_weight for k, v in weights.items()}
+
+#     # 計算基礎分數
+#     base_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
+    
+#     # 品種特性加成
+#     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+    
+#     # 動態整合係數
+#     bonus_weight = min(0.25, max(0.15, breed_bonus))  # 讓優秀特性有更大影響
+    
+#     # 完美匹配加成
+#     if all(score >= 0.8 for score in adjusted_scores.values()):
+#         base_score *= 1.2
+    
+#     # 極端不匹配懲罰
+#     if any(score <= 0.3 for score in adjusted_scores.values()):
+#         base_score *= 0.6
+
+#     return min(1.0, max(0.0, (base_score * (1.0 - bonus_weight)) + (breed_bonus * bonus_weight)))
 
-    # 運動時間極端情況
-    if user_prefs.exercise_time < 30:
-        weights['exercise'] *= 2.0
-    elif user_prefs.exercise_time > 150:
-        weights['exercise'] *= 1.5
 
+# def amplify_score_extreme(score: float) -> float:
+#     """
+#     改進的分數轉換函數，提供更動態的分數範圍
+    
+#     動態轉換邏輯：
+#     - 極差匹配 (0.0-0.2) -> 45-58%
+#     - 較差匹配 (0.2-0.4) -> 58-72%
+#     - 中等匹配 (0.4-0.6) -> 72-85%
+#     - 良好匹配 (0.6-0.8) -> 85-92%
+#     - 優秀匹配 (0.8-0.9) -> 92-96%
+#     - 完美匹配 (0.9-1.0) -> 96-99%
+#     """
+#     if score < 0.2:
+#         return 0.45 + (score / 0.2) * 0.13
+#     elif score < 0.4:
+#         position = (score - 0.2) / 0.2
+#         return 0.58 + position * 0.14
+#     elif score < 0.6:
+#         position = (score - 0.4) / 0.2
+#         return 0.72 + position * 0.13
+#     elif score < 0.8:
+#         position = (score - 0.6) / 0.2
+#         return 0.85 + position * 0.07
+#     elif score < 0.9:
+#         position = (score - 0.8) / 0.1
+#         return 0.92 + position * 0.04
+#     else:
+#         position = (score - 0.9) / 0.1
+#         return 0.96 + position * 0.03
+
+
+def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreferences, breed_info: dict) -> float:
+    """
+    改進的品種相容性評分系統，提供更動態和精確的評分
+    
+    主要改進：
+    1. 更動態的權重系統
+    2. 更強的極端情況處理
+    3. 更精確的品種特性評估
+    """
+    def evaluate_condition_extremity():
+        """評估使用者條件的極端程度"""
+        extremity_count = 0
+        
+        # 空間條件極端性
+        if user_prefs.living_space == 'apartment' and breed_info['Size'] in ['Large', 'Giant']:
+            extremity_count += 2
+        elif user_prefs.living_space == 'house_large' and breed_info['Size'] == 'Small':
+            extremity_count += 1
+            
+        # 運動需求極端性
+        exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
+        if exercise_needs == 'VERY HIGH' and user_prefs.exercise_time < 60:
+            extremity_count += 2
+        elif exercise_needs == 'LOW' and user_prefs.exercise_time > 150:
+            extremity_count += 1
+            
+        # 經驗等級極端性
+        care_level = breed_info.get('Care Level', 'MODERATE')
+        if care_level == 'High' and user_prefs.experience_level == 'beginner':
+            extremity_count += 2
+            
+        return extremity_count
+
+    def calculate_dynamic_weights():
+        """計算動態權重"""
+        # 基礎權重
+        weights = {
+            'space': 0.20,
+            'exercise': 0.20,
+            'experience': 0.15,
+            'grooming': 0.15,
+            'health': 0.15,
+            'noise': 0.15
+        }
+        
+        # 根據生活環境調整權重
+        if user_prefs.living_space == 'apartment':
+            weights['space'] *= 2.0
+            weights['noise'] *= 1.8
+        
+        # 根據家庭情況調整
+        if user_prefs.has_children:
+            if user_prefs.children_age == 'toddler':
+                weights['noise'] *= 2.0
+                weights['experience'] *= 1.8
+                weights['health'] *= 1.5
+            elif user_prefs.children_age == 'school_age':
+                weights['noise'] *= 1.5
+                weights['experience'] *= 1.3
+        
+        # 根據運動時間調整
+        if user_prefs.exercise_time < 30:
+            weights['exercise'] *= 2.5
+        elif user_prefs.exercise_time > 150:
+            weights['exercise'] *= 2.0
+            
+        # 根據健康敏感度調整
+        if user_prefs.health_sensitivity == 'high':
+            weights['health'] *= 1.8
+            
+        return weights
+
+    # 計算條件極端程度
+    extremity_level = evaluate_condition_extremity()
+    
+    # 計算動態權重
+    weights = calculate_dynamic_weights()
+    
     # 正規化權重
     total_weight = sum(weights.values())
     normalized_weights = {k: v/total_weight for k, v in weights.items()}
-
-    # 計算基礎分數
-    base_score = sum(adjusted_scores[k] * normalized_weights[k] for k in scores.keys())
+    
+    # 計算加權分數
+    weighted_scores = {
+        k: scores[k] * normalized_weights[k] for k in scores.keys()
+    }
+    
+    # 基礎分數
+    base_score = sum(weighted_scores.values())
     
     # 品種特性加成
     breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
     
-    # 動態整合係數
-    bonus_weight = min(0.25, max(0.15, breed_bonus))  # 讓優秀特性有更大影響
+    # 根據極端程度調整最終分數
+    if extremity_level >= 3:
+        base_score *= 0.6  # 多個極端條件的嚴重懲罰
+    elif extremity_level >= 2:
+        base_score *= 0.8  # 較少極端條件的適度懲罰
     
     # 完美匹配加成
-    if all(score >= 0.8 for score in adjusted_scores.values()):
-        base_score *= 1.2
+    if all(score >= 0.8 for score in scores.values()):
+        base_score *= 1.3
     
-    # 極端不匹配懲罰
-    if any(score <= 0.3 for score in adjusted_scores.values()):
-        base_score *= 0.6
-
-    return min(1.0, max(0.0, (base_score * (1.0 - bonus_weight)) + (breed_bonus * bonus_weight)))
+    # 品種特性影響力隨匹配度增加
+    bonus_weight = min(0.35, max(0.15, breed_bonus))
+    
+    # 最終分數計算
+    final_score = (base_score * (1.0 - bonus_weight)) + (breed_bonus * bonus_weight)
+    
+    return min(1.0, max(0.0, final_score))
 
 
 def amplify_score_extreme(score: float) -> float:
     """
-    改進的分數轉換函數，提供更動態的分數範圍
-    
-    動態轉換邏輯：
-    - 極差匹配 (0.0-0.2) -> 45-58%
-    - 較差匹配 (0.2-0.4) -> 58-72%
-    - 中等匹配 (0.4-0.6) -> 72-85%
-    - 良好匹配 (0.6-0.8) -> 85-92%
-    - 優秀匹配 (0.8-0.9) -> 92-96%
-    - 完美匹配 (0.9-1.0) -> 96-99%
+    改進的分數轉換函數，提供更合理的分數分布
+    
+    特點：
+    1. 更大的分數範圍
+    2. 更平滑的轉換曲線
+    3. 更準確的極端情況處理
     """
+    def sigmoid_transform(x: float, steepness: float = 10) -> float:
+        """使用 sigmoid 函數實現更平滑的轉換"""
+        import math
+        return 1 / (1 + math.exp(-steepness * (x - 0.5)))
+
     if score < 0.2:
-        return 0.45 + (score / 0.2) * 0.13
+        # 極差匹配：使用更低的起始分數
+        base = 0.40
+        range_score = 0.15
+        position = score / 0.2
+        return base + (sigmoid_transform(position) * range_score)
+        
     elif score < 0.4:
+        # 較差匹配：緩慢增長
+        base = 0.55
+        range_score = 0.15
         position = (score - 0.2) / 0.2
-        return 0.58 + position * 0.14
+        return base + (sigmoid_transform(position) * range_score)
+        
     elif score < 0.6:
+        # 中等匹配：較大增長
+        base = 0.70
+        range_score = 0.15
         position = (score - 0.4) / 0.2
-        return 0.72 + position * 0.13
+        return base + (sigmoid_transform(position) * range_score)
+        
     elif score < 0.8:
+        # 良好匹配：快速增長
+        base = 0.85
+        range_score = 0.10
         position = (score - 0.6) / 0.2
-        return 0.85 + position * 0.07
+        return base + (sigmoid_transform(position) * range_score)
+        
     elif score < 0.9:
+        # 優秀匹配：接近最高分
+        base = 0.95
+        range_score = 0.03
         position = (score - 0.8) / 0.1
-        return 0.92 + position * 0.04
+        return base + (sigmoid_transform(position) * range_score)
+        
     else:
+        # 完美匹配：可能達到最高分
+        base = 0.98
+        range_score = 0.02
         position = (score - 0.9) / 0.1
-        return 0.96 + position * 0.03
+        return base + (sigmoid_transform(position) * range_score)