Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -29,103 +29,259 @@ class UserPreferences:
             self.barking_acceptance = self.noise_tolerance
 
 
+# @staticmethod
+# def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> float:
+#     """計算品種額外加分"""
+#     bonus = 0.0
+#     temperament = breed_info.get('Temperament', '').lower()
+    
+#     # 1. 壽命加分（最高0.05）
+#     try:
+#         lifespan = breed_info.get('Lifespan', '10-12 years')
+#         years = [int(x) for x in lifespan.split('-')[0].split()[0:1]]
+#         longevity_bonus = min(0.05, (max(years) - 10) * 0.01)
+#         bonus += longevity_bonus
+#     except:
+#         pass
+
+#     # 2. 性格特徵加分（最高0.15）
+#     positive_traits = {
+#         'friendly': 0.05,           
+#         'gentle': 0.05,
+#         'patient': 0.05,
+#         'intelligent': 0.04,
+#         'adaptable': 0.04,
+#         'affectionate': 0.04,
+#         'easy-going': 0.03,         
+#         'calm': 0.03                
+#     }
+    
+#     negative_traits = {
+#         'aggressive': -0.08,        
+#         'stubborn': -0.06,
+#         'dominant': -0.06,
+#         'aloof': -0.04,
+#         'nervous': -0.05,           
+#         'protective': -0.04         
+#     }
+    
+#     personality_score = sum(value for trait, value in positive_traits.items() if trait in temperament)
+#     personality_score += sum(value for trait, value in negative_traits.items() if trait in temperament)
+#     bonus += max(-0.15, min(0.15, personality_score))
+
+#     # 3. 適應性加分（最高0.1）
+#     adaptability_bonus = 0.0
+#     if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
+#         adaptability_bonus += 0.05
+#     if 'adaptable' in temperament or 'versatile' in temperament:
+#         adaptability_bonus += 0.05
+#     bonus += min(0.1, adaptability_bonus)
+
+#     # 4. 家庭相容性（最高0.1）
+#     if user_prefs.has_children:
+#         family_traits = {
+#             'good with children': 0.06,  
+#             'patient': 0.05,
+#             'gentle': 0.05,
+#             'tolerant': 0.04,           
+#             'playful': 0.03             
+#         }
+#         unfriendly_traits = {
+#             'aggressive': -0.08,        
+#             'nervous': -0.07,
+#             'protective': -0.06,
+#             'territorial': -0.05        
+#         }
+        
+#         # 年齡評估這樣能更細緻
+#         age_adjustments = {
+#             'toddler': {'bonus_mult': 0.7, 'penalty_mult': 1.3},
+#             'school_age': {'bonus_mult': 1.0, 'penalty_mult': 1.0},
+#             'teenager': {'bonus_mult': 1.2, 'penalty_mult': 0.8}
+#         }
+        
+#         adj = age_adjustments.get(user_prefs.children_age, 
+#                                 {'bonus_mult': 1.0, 'penalty_mult': 1.0})
+        
+#         family_bonus = sum(value for trait, value in family_traits.items() 
+#                           if trait in temperament) * adj['bonus_mult']
+#         family_penalty = sum(value for trait, value in unfriendly_traits.items() 
+#                            if trait in temperament) * adj['penalty_mult']
+        
+#         bonus += min(0.15, max(-0.2, family_bonus + family_penalty))
+
+    
+#     # 5. 專門技能加分（最高0.1）
+#     skill_bonus = 0.0
+#     special_abilities = {
+#         'working': 0.03,
+#         'herding': 0.03,
+#         'hunting': 0.03,
+#         'tracking': 0.03,
+#         'agility': 0.02
+#     }
+#     for ability, value in special_abilities.items():
+#         if ability in temperament.lower():
+#             skill_bonus += value
+#     bonus += min(0.1, skill_bonus)
+
+#     return min(0.5, max(-0.25, bonus))
+
+
 @staticmethod
-def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> float:
-    """計算品種額外加分"""
+def calculate_breed_bonus(breed_info: dict, user_prefs: UserPreferences) -> float:
+    """
+    計算品種的額外加分，評估品種的特殊特徵對使用者需求的適配性。
+    
+    這個函數考慮四個主要面向：
+    1. 壽命評估：考慮飼養的長期承諾
+    2. 性格特徵評估：評估品種性格與使用者需求的匹配度
+    3. 環境適應性：評估品種在特定生活環境中的表現
+    4. 家庭相容性：特別關注品種與家庭成員的互動
+    """
     bonus = 0.0
     temperament = breed_info.get('Temperament', '').lower()
     
-    # 1. 壽命加分（最高0.05）
+    # 壽命評估 - 重新設計以反映更實際的考量
     try:
         lifespan = breed_info.get('Lifespan', '10-12 years')
         years = [int(x) for x in lifespan.split('-')[0].split()[0:1]]
-        longevity_bonus = min(0.05, (max(years) - 10) * 0.01)
-        bonus += longevity_bonus
+        avg_years = float(years[0])
+        
+        # 根據壽命長短給予不同程度的獎勵或懲罰
+        if avg_years < 8:
+            bonus -= 0.08  # 短壽命可能帶來情感負擔
+        elif avg_years < 10:
+            bonus -= 0.04  # 稍短壽命輕微降低評分
+        elif avg_years > 13:
+            bonus += 0.06  # 長壽命適度加分
+        elif avg_years > 15:
+            bonus += 0.08  # 特別長壽的品種獲得更多加分
     except:
         pass
 
-    # 2. 性格特徵加分（最高0.15）
+    # 性格特徵評估 - 擴充並細化評分標準
     positive_traits = {
-        'friendly': 0.05,           
-        'gentle': 0.05,
-        'patient': 0.05,
-        'intelligent': 0.04,
-        'adaptable': 0.04,
-        'affectionate': 0.04,
-        'easy-going': 0.03,         
-        'calm': 0.03                
+        'friendly': 0.08,           # 提高友善性的重要性
+        'gentle': 0.08,            # 溫和性格更受歡迎
+        'patient': 0.07,           # 耐心是重要特質
+        'intelligent': 0.06,        # 聰明但不過分重要
+        'adaptable': 0.06,         # 適應性佳的特質
+        'affectionate': 0.06,      # 親密性很重要
+        'easy-going': 0.05,        # 容易相處的性格
+        'calm': 0.05              # 冷靜的特質
     }
     
     negative_traits = {
-        'aggressive': -0.08,        
-        'stubborn': -0.06,
-        'dominant': -0.06,
-        'aloof': -0.04,
-        'nervous': -0.05,           
-        'protective': -0.04         
+        'aggressive': -0.15,       # 嚴重懲罰攻擊性
+        'stubborn': -0.10,        # 固執性格不易處理
+        'dominant': -0.10,        # 支配性可能造成問題
+        'aloof': -0.08,          # 冷漠性格影響互動
+        'nervous': -0.08,         # 緊張性格需要更多關注
+        'protective': -0.06       # 過度保護可能有風險
     }
     
-    personality_score = sum(value for trait, value in positive_traits.items() if trait in temperament)
-    personality_score += sum(value for trait, value in negative_traits.items() if trait in temperament)
-    bonus += max(-0.15, min(0.15, personality_score))
+    # 性格評分計算 - 加入累積效應
+    personality_score = 0
+    positive_count = 0
+    negative_count = 0
+    
+    for trait, value in positive_traits.items():
+        if trait in temperament:
+            personality_score += value
+            positive_count += 1
+            
+    for trait, value in negative_traits.items():
+        if trait in temperament:
+            personality_score += value
+            negative_count += 1
+    
+    # 多重特徵的累積效應
+    if positive_count > 2:
+        personality_score *= (1 + (positive_count - 2) * 0.1)
+    if negative_count > 1:
+        personality_score *= (1 - (negative_count - 1) * 0.15)
+    
+    bonus += max(-0.25, min(0.25, personality_score))
 
-    # 3. 適應性加分（最高0.1）
+    # 適應性評估 - 根據具體環境給予更細緻的評分
     adaptability_bonus = 0.0
     if breed_info.get('Size') == "Small" and user_prefs.living_space == "apartment":
-        adaptability_bonus += 0.05
+        adaptability_bonus += 0.08  # 小型犬更適合公寓
+    
+    # 環境適應性評估
     if 'adaptable' in temperament or 'versatile' in temperament:
-        adaptability_bonus += 0.05
-    bonus += min(0.1, adaptability_bonus)
+        if user_prefs.living_space == "apartment":
+            adaptability_bonus += 0.10  # 適應性在公寓環境更重要
+        else:
+            adaptability_bonus += 0.05  # 其他環境仍有加分
+            
+    # 氣候適應性
+    description = breed_info.get('Description', '').lower()
+    climate = user_prefs.climate
+    if climate == 'hot':
+        if 'heat tolerant' in description or 'warm climate' in description:
+            adaptability_bonus += 0.08
+        elif 'thick coat' in description or 'cold climate' in description:
+            adaptability_bonus -= 0.10
+    elif climate == 'cold':
+        if 'thick coat' in description or 'cold climate' in description:
+            adaptability_bonus += 0.08
+        elif 'heat tolerant' in description or 'short coat' in description:
+            adaptability_bonus -= 0.10
+            
+    bonus += min(0.15, adaptability_bonus)
 
-    # 4. 家庭相容性（最高0.1）
+    # 家庭相容性評估 - 特別關注有孩童的家庭
     if user_prefs.has_children:
         family_traits = {
-            'good with children': 0.06,  
-            'patient': 0.05,
-            'gentle': 0.05,
-            'tolerant': 0.04,           
-            'playful': 0.03             
+            'good with children': 0.12,  # 提高與孩童相處的重要性
+            'patient': 0.10,
+            'gentle': 0.10,
+            'tolerant': 0.08,
+            'playful': 0.06
         }
+        
         unfriendly_traits = {
-            'aggressive': -0.08,        
-            'nervous': -0.07,
-            'protective': -0.06,
-            'territorial': -0.05        
+            'aggressive': -0.15,       # 加重攻擊性的懲罰
+            'nervous': -0.12,         # 緊張特質可能有風險
+            'protective': -0.10,      # 過度保護性需要注意
+            'territorial': -0.08      # 地域性可能造成問題
         }
         
-        # 年齡評估這樣能更細緻
+        # 根據孩童年齡調整評分權重
         age_adjustments = {
-            'toddler': {'bonus_mult': 0.7, 'penalty_mult': 1.3},
-            'school_age': {'bonus_mult': 1.0, 'penalty_mult': 1.0},
-            'teenager': {'bonus_mult': 1.2, 'penalty_mult': 0.8}
+            'toddler': {
+                'bonus_mult': 0.6,    # 降低正面特質的獎勵
+                'penalty_mult': 1.5    # 加重負面特質的懲罰
+            },
+            'school_age': {
+                'bonus_mult': 1.0,
+                'penalty_mult': 1.0
+            },
+            'teenager': {
+                'bonus_mult': 1.2,    # 提高正面特質的獎勵
+                'penalty_mult': 0.8    # 降低負面特質的懲罰
+            }
         }
         
         adj = age_adjustments.get(user_prefs.children_age, 
                                 {'bonus_mult': 1.0, 'penalty_mult': 1.0})
         
-        family_bonus = sum(value for trait, value in family_traits.items() 
-                          if trait in temperament) * adj['bonus_mult']
-        family_penalty = sum(value for trait, value in unfriendly_traits.items() 
-                           if trait in temperament) * adj['penalty_mult']
+        # 計算家庭相容性分數
+        family_score = 0
+        for trait, value in family_traits.items():
+            if trait in temperament:
+                family_score += value * adj['bonus_mult']
+                
+        for trait, value in unfriendly_traits.items():
+            if trait in temperament:
+                family_score += value * adj['penalty_mult']
         
-        bonus += min(0.15, max(-0.2, family_bonus + family_penalty))
-
-    
-    # 5. 專門技能加分（最高0.1）
-    skill_bonus = 0.0
-    special_abilities = {
-        'working': 0.03,
-        'herding': 0.03,
-        'hunting': 0.03,
-        'tracking': 0.03,
-        'agility': 0.02
-    }
-    for ability, value in special_abilities.items():
-        if ability in temperament.lower():
-            skill_bonus += value
-    bonus += min(0.1, skill_bonus)
+        bonus += min(0.20, max(-0.30, family_score))
 
-    return min(0.5, max(-0.25, bonus))
+    # 確保總體加分在合理範圍內，但允許更大的變化
+    return min(0.5, max(-0.35, bonus))
 
 
 @staticmethod
@@ -216,36 +372,105 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             print("Missing Size information")
             raise KeyError("Size information missing")
             
+        # def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
+        #     """空間分數計算"""
+        #     # 基礎空間需求矩陣
+        #     base_scores = {
+        #         "Small": {"apartment": 0.95, "house_small": 1.0, "house_large": 0.90},
+        #         "Medium": {"apartment": 0.60, "house_small": 0.90, "house_large": 1.0},
+        #         "Large": {"apartment": 0.30, "house_small": 0.75, "house_large": 1.0},
+        #         "Giant": {"apartment": 0.15, "house_small": 0.55, "house_large": 1.0}
+        #     }
+            
+        #     # 取得基礎分數
+        #     base_score = base_scores.get(size, base_scores["Medium"])[living_space]
+            
+        #     # 運動需求調整
+        #     exercise_adjustments = {
+        #         "Very High": -0.15 if living_space == "apartment" else 0,
+        #         "High": -0.10 if living_space == "apartment" else 0,
+        #         "Moderate": 0,
+        #         "Low": 0.05 if living_space == "apartment" else 0
+        #     }
+            
+        #     adjustments = exercise_adjustments.get(exercise_needs.strip(), 0)
+            
+        #     # 院子獎勵
+        #     if has_yard and size in ["Large", "Giant"]:
+        #         adjustments += 0.10
+        #     elif has_yard:
+        #         adjustments += 0.05
+                
+        #     return min(1.0, max(0.1, base_score + adjustments))
+
         def calculate_space_score(size: str, living_space: str, has_yard: bool, exercise_needs: str) -> float:
-            """空間分數計算"""
-            # 基礎空間需求矩陣
+            # 重新設計基礎分數矩陣
             base_scores = {
-                "Small": {"apartment": 0.95, "house_small": 1.0, "house_large": 0.90},
-                "Medium": {"apartment": 0.60, "house_small": 0.90, "house_large": 1.0},
-                "Large": {"apartment": 0.30, "house_small": 0.75, "house_large": 1.0},
-                "Giant": {"apartment": 0.15, "house_small": 0.55, "house_large": 1.0}
+                "Small": {
+                    "apartment": 1.0,      # 小型犬最適合公寓
+                    "house_small": 0.95,   # 在大房子反而稍微降分
+                    "house_large": 0.85    # 可能浪費空間
+                },
+                "Medium": {
+                    "apartment": 0.45,     # 中���犬在公寓明顯受限
+                    "house_small": 0.85,
+                    "house_large": 1.0
+                },
+                "Large": {
+                    "apartment": 0.15,     # 大型犬在公寓極不適合
+                    "house_small": 0.60,   # 在小房子仍然受限
+                    "house_large": 1.0
+                },
+                "Giant": {
+                    "apartment": 0.1,      # 更嚴格的限制
+                    "house_small": 0.45,
+                    "house_large": 1.0
+                }
             }
             
             # 取得基礎分數
             base_score = base_scores.get(size, base_scores["Medium"])[living_space]
             
-            # 運動需求調整
+            # 運動需求調整更明顯
             exercise_adjustments = {
-                "Very High": -0.15 if living_space == "apartment" else 0,
-                "High": -0.10 if living_space == "apartment" else 0,
-                "Moderate": 0,
-                "Low": 0.05 if living_space == "apartment" else 0
+                "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
+                }
             }
             
-            adjustments = exercise_adjustments.get(exercise_needs.strip(), 0)
+            # 根據空間類型獲取對應的運動調整
+            adjustment = exercise_adjustments.get(exercise_needs, 
+                                                exercise_adjustments["Moderate"])[living_space]
             
-            # 院子獎勵
-            if has_yard and size in ["Large", "Giant"]:
-                adjustments += 0.10
-            elif has_yard:
-                adjustments += 0.05
-                
-            return min(1.0, max(0.1, base_score + adjustments))
+            # 院子獎勵也要根據犬種大小調整
+            yard_bonus = 0
+            if has_yard:
+                if size in ["Large", "Giant"]:
+                    yard_bonus = 0.20 if living_space != "apartment" else 0.10
+                elif size == "Medium":
+                    yard_bonus = 0.15 if living_space != "apartment" else 0.08
+                else:
+                    yard_bonus = 0.10 if living_space != "apartment" else 0.05
+                    
+            final_score = base_score + adjustment + yard_bonus
+            return min(1.0, max(0.1, final_score))
 
         def calculate_exercise_score(breed_needs: str, user_time: int) -> float:
             """運動需求計算"""
@@ -269,29 +494,160 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             else:
                 return max(0.3, 0.8 * (user_time / breed_need['min']))
 
+        # def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
+        #     """美容需求計算"""
+        #     # 基礎分數矩陣
+        #     base_scores = {
+        #         "High": {"low": 0.3, "medium": 0.7, "high": 1.0},
+        #         "Moderate": {"low": 0.5, "medium": 0.9, "high": 1.0},
+        #         "Low": {"low": 1.0, "medium": 0.95, "high": 0.8}
+        #     }
+            
+        #     # 取得基礎分數
+        #     base_score = base_scores.get(breed_needs, base_scores["Moderate"])[user_commitment]
+            
+        #     # 體型影響調整
+        #     size_adjustments = {
+        #         "Large": {"low": -0.2, "medium": -0.1, "high": 0},
+        #         "Giant": {"low": -0.3, "medium": -0.15, "high": 0},
+        #     }
+            
+        #     if breed_size in size_adjustments:
+        #         adjustment = size_adjustments[breed_size].get(user_commitment, 0)
+        #         base_score = max(0.2, base_score + adjustment)
+                
+        #     return base_score
+
+
         def calculate_grooming_score(breed_needs: str, user_commitment: str, breed_size: str) -> float:
-            """美容需求計算"""
-            # 基礎分數矩陣
+            """
+            計算美容需求分數，強化美容維護需求與使用者承諾度的匹配評估。
+            這個函數特別注意品種大小對美容工作的影響，以及不同程度的美容需求對時間投入的要求。
+            """
+            # 重新設計基礎分數矩陣，讓美容需求的差異更加明顯
             base_scores = {
-                "High": {"low": 0.3, "medium": 0.7, "high": 1.0},
-                "Moderate": {"low": 0.5, "medium": 0.9, "high": 1.0},
-                "Low": {"low": 1.0, "medium": 0.95, "high": 0.8}
+                "High": {
+                    "low": 0.20,      # 高需求對低承諾極不合適，顯著降低初始分數
+                    "medium": 0.65,   # 中等承諾仍有挑戰
+                    "high": 1.0       # 高承諾最適合
+                },
+                "Moderate": {
+                    "low": 0.45,      # 中等需求對低承諾有困難
+                    "medium": 0.85,   # 較好的匹配
+                    "high": 0.95      # 高承諾會有餘力
+                },
+                "Low": {
+                    "low": 0.90,      # 低需求對低承諾很合適
+                    "medium": 0.85,   # 略微降低以反映可能過度投入
+                    "high": 0.80      # 可能造成資源浪費
+                }
             }
-            
+        
             # 取得基礎分數
             base_score = base_scores.get(breed_needs, base_scores["Moderate"])[user_commitment]
-            
-            # 體型影響調整
+        
+            # 根據品種大小調整美容工作量
             size_adjustments = {
-                "Large": {"low": -0.2, "medium": -0.1, "high": 0},
-                "Giant": {"low": -0.3, "medium": -0.15, "high": 0},
+                "Giant": {
+                    "low": -0.35,     # 大型犬的美容工作量顯著增加
+                    "medium": -0.20,
+                    "high": -0.10
+                },
+                "Large": {
+                    "low": -0.25,
+                    "medium": -0.15,
+                    "high": -0.05
+                },
+                "Medium": {
+                    "low": -0.15,
+                    "medium": -0.10,
+                    "high": 0
+                },
+                "Small": {
+                    "low": -0.10,
+                    "medium": -0.05,
+                    "high": 0
+                }
             }
-            
-            if breed_size in size_adjustments:
-                adjustment = size_adjustments[breed_size].get(user_commitment, 0)
-                base_score = max(0.2, base_score + adjustment)
+        
+            # 應用體型調整
+            size_adjustment = size_adjustments.get(breed_size, size_adjustments["Medium"])[user_commitment]
+            current_score = base_score + size_adjustment
+        
+            # 特殊毛髮類型的額外調整
+            def get_coat_adjustment(breed_description: str, commitment: str) -> float:
+                """
+                評估特殊毛髮類型所需的額外維護工作
+                """
+                adjustments = 0
                 
-            return base_score
+                # 長毛品種需要更多維護
+                if 'long coat' in breed_description.lower():
+                    coat_penalties = {
+                        'low': -0.20,
+                        'medium': -0.15,
+                        'high': -0.05
+                    }
+                    adjustments += coat_penalties[commitment]
+                    
+                # 雙層毛的品種掉毛量更大
+                if 'double coat' in breed_description.lower():
+                    double_coat_penalties = {
+                        'low': -0.15,
+                        'medium': -0.10,
+                        'high': -0.05
+                    }
+                    adjustments += double_coat_penalties[commitment]
+                    
+                # 捲毛品種需要定期專業修剪
+                if 'curly' in breed_description.lower():
+                    curly_penalties = {
+                        'low': -0.15,
+                        'medium': -0.10,
+                        'high': -0.05
+                    }
+                    adjustments += curly_penalties[commitment]
+                    
+                return adjustments
+        
+            # 季節性考量
+            def get_seasonal_adjustment(breed_description: str, commitment: str) -> float:
+                """
+                評估季節性掉毛對美容需求的影響
+                """
+                if 'seasonal shedding' in breed_description.lower():
+                    seasonal_penalties = {
+                        'low': -0.15,
+                        'medium': -0.10,
+                        'high': -0.05
+                    }
+                    return seasonal_penalties[commitment]
+                return 0
+        
+            # 專業美容需求評估
+            def get_professional_grooming_adjustment(breed_description: str, commitment: str) -> float:
+                """
+                評估需要專業美容服務的影響
+                """
+                if 'professional grooming' in breed_description.lower():
+                    grooming_penalties = {
+                        'low': -0.20,
+                        'medium': -0.15,
+                        'high': -0.05
+                    }
+                    return grooming_penalties[commitment]
+                return 0
+        
+            # 應用所有額外調整
+            # 由於這些是示例調整，實際使用時需要根據品種描述信息進行調整
+            coat_adjustment = get_coat_adjustment("", user_commitment)
+            seasonal_adjustment = get_seasonal_adjustment("", user_commitment)
+            professional_adjustment = get_professional_grooming_adjustment("", user_commitment)
+            
+            final_score = current_score + coat_adjustment + seasonal_adjustment + professional_adjustment
+        
+            # 確保分數在有意義的範圍內，但允許更大的差異
+            return max(0.1, min(1.0, final_score))
             
 
         # def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
@@ -403,24 +759,29 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
 
         def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
             """
-            計算經驗分數，加強不同經驗等級的區別
+            計算使用者經驗與品種需求的匹配分數，加強經驗等級的影響力
+            
+            重要改進：
+            1. 擴大基礎分數差異
+            2. 加重困難特徵的懲罰
+            3. 更細緻的品種特性評估
             """
-            # 基礎分數矩陣 - 調整分數範圍，讓差異更明顯
+            # 基礎分數矩陣 - 大幅擴大不同經驗等級的分數差異
             base_scores = {
                 "High": {
-                    "beginner": 0.15,     # 從0.12降到0.15，對新手更嚴格
-                    "intermediate": 0.65,  # 保持不變
-                    "advanced": 1.0       
+                    "beginner": 0.10,      # 降低起始分，高難度品種對新手幾乎不推薦
+                    "intermediate": 0.60,   # 中級玩家仍需謹慎
+                    "advanced": 1.0        # 資深者能完全勝任
                 },
                 "Moderate": {
-                    "beginner": 0.45,    # 從0.35提高到0.45，增加區別
-                    "intermediate": 0.82, 
-                    "advanced": 1.0      
+                    "beginner": 0.35,      # 適中難度對新手仍具挑戰
+                    "intermediate": 0.80,   # 中級玩家較適合
+                    "advanced": 1.0        # 資深者完全勝任
                 },
                 "Low": {
-                    "beginner": 0.85,    # 從0.72提高到0.85，更適合新手
-                    "intermediate": 0.92, 
-                    "advanced": 1.0      
+                    "beginner": 0.90,      # 新手友善品種
+                    "intermediate": 0.95,   # 中級玩家幾乎完全勝任
+                    "advanced": 1.0        # 資深者完全勝任
                 }
             }
             
@@ -430,29 +791,31 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             temperament_lower = temperament.lower()
             temperament_adjustments = 0.0
             
+            # 根據經驗等級設定不同的特徵評估標準
             if user_experience == "beginner":
-                # 調整新手的懲罰力度
+                # 新手不適合的特徵 - 更嚴格的懲罰
                 difficult_traits = {
-                    'stubborn': -0.25,      # 從-0.15加重到-0.25
-                    'independent': -0.20,    # 從-0.12加重到-0.20
-                    'dominant': -0.20,       
-                    'strong-willed': -0.18,  
-                    'protective': -0.15,     
-                    'aloof': -0.15,         
-                    'energetic': -0.12      # 從-0.06加重到-0.12
+                    '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.06,          
-                    'friendly': 0.06,        
-                    'eager to please': 0.06, 
-                    'patient': 0.04,         
-                    'adaptable': 0.04,       
-                    'calm': 0.04            
+                    'gentle': 0.05,            # 溫和性格適合新手
+                    'friendly': 0.05,          # 友善性格��易相處
+                    'eager to please': 0.08,   # 願意服從較容易訓練
+                    'patient': 0.05,           # 耐心的特質有助於建立關係
+                    'adaptable': 0.05,         # 適應性強較容易照顧
+                    'calm': 0.06              # 冷靜的性格較好掌握
                 }
                 
-                # 新手的特徵懲罰不再乘以1.2，而是直接使用更重的懲罰值
+                # 計算特徵調整
                 for trait, penalty in difficult_traits.items():
                     if trait in temperament_lower:
                         temperament_adjustments += penalty
@@ -461,19 +824,23 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                     if trait in temperament_lower:
                         temperament_adjustments += bonus
                         
-                # 特定品種類型的懲罰加重
-                if any(term in temperament_lower for term in ['terrier', 'working', 'guard']):
-                    temperament_adjustments -= 0.20  
+                # 品種類型特殊評估
+                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 = {
-                    'intelligent': 0.05,     # 獎勵聰明
-                    'athletic': 0.04,        # 獎勵運動能力
-                    'versatile': 0.04,       # 獎勵多功能性
-                    'stubborn': -0.06,       # 輕微懲罰固執
-                    'independent': -0.05,    # 輕微懲罰獨立性
-                    'protective': -0.04      # 輕微懲罰保護性
+                    '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():
@@ -483,140 +850,447 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             else:  # advanced
                 # 資深玩家能夠應對挑戰性特徵
                 advanced_traits = {
-                    'stubborn': 0.04,        # 反轉為優勢
-                    'independent': 0.04,      # 反轉為優勢
-                    'intelligent': 0.05,      # 獎勵聰明
-                    'protective': 0.04,       # 獎勵保護性
-                    'strong-willed': 0.03    # 獎勵強勢
+                    '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.2, min(1.0, score + temperament_adjustments))
+            # 確保最終分數範圍更大，讓差異更明顯
+            final_score = max(0.05, min(1.0, score + temperament_adjustments))
+            
             return final_score
 
 
-        def calculate_health_score(breed_name: str) -> float:
-            """計算品種健康分數"""
+        # def calculate_health_score(breed_name: str) -> float:
+        #     """計算品種健康分數"""
+        #     if breed_name not in breed_health_info:
+        #         return 0.5
+
+        #     health_notes = breed_health_info[breed_name]['health_notes'].lower()
+            
+        #     # 嚴重健康問題（降低0.15分）
+        #     severe_conditions = [
+        #         'hip dysplasia',
+        #         'heart disease',
+        #         'progressive retinal atrophy',
+        #         'bloat',
+        #         'epilepsy',
+        #         'degenerative myelopathy',
+        #         'von willebrand disease'
+        #     ]
+            
+        #     # 中度健康問題（降低0.1分）
+        #     moderate_conditions = [
+        #         'allergies',
+        #         'eye problems',
+        #         'joint problems',
+        #         'hypothyroidism',
+        #         'ear infections',
+        #         'skin issues'
+        #     ]
+            
+        #     # 輕微健康問題（降低0.05分）
+        #     minor_conditions = [
+        #         'dental issues',
+        #         'weight gain tendency',
+        #         'minor allergies',
+        #         'seasonal allergies'
+        #     ]
+
+        #     # 計算基礎健康分數
+        #     health_score = 1.0
+            
+        #     # 根據問題嚴重程度扣分
+        #     severe_count = sum(1 for condition in severe_conditions if condition in health_notes)
+        #     moderate_count = sum(1 for condition in moderate_conditions if condition in health_notes)
+        #     minor_count = sum(1 for condition in minor_conditions if condition in health_notes)
+            
+        #     health_score -= (severe_count * 0.15)
+        #     health_score -= (moderate_count * 0.1)
+        #     health_score -= (minor_count * 0.05)
+
+        #     # 壽命影響
+        #     try:
+        #         lifespan = breed_health_info[breed_name].get('average_lifespan', '10-12')
+        #         years = float(lifespan.split('-')[0])
+        #         if years < 8:
+        #             health_score *= 0.9
+        #         elif years > 13:
+        #             health_score *= 1.1
+        #     except:
+        #         pass
+
+        #     # 特殊健康優勢
+        #     if 'generally healthy' in health_notes or 'hardy breed' in health_notes:
+        #         health_score *= 1.1
+
+        #     return max(0.2, min(1.0, health_score))
+
+        def calculate_health_score(breed_name: str, user_prefs: UserPreferences) -> float:
+            """
+            計算品種健康分數，加強健康問題的影響力和與使用者敏感度的連結
+            
+            重要改進：
+            1. 根據使用者的健康敏感度調整分數
+            2. 更嚴格的健康問題評估
+            3. 考慮多重健康問題的累積效應
+            4. 加入遺傳疾病的特別考量
+            """
             if breed_name not in breed_health_info:
                 return 0.5
-
+        
             health_notes = breed_health_info[breed_name]['health_notes'].lower()
             
-            # 嚴重健康問題（降低0.15分）
-            severe_conditions = [
-                'hip dysplasia',
-                'heart disease',
-                'progressive retinal atrophy',
-                'bloat',
-                'epilepsy',
-                'degenerative myelopathy',
-                'von willebrand disease'
-            ]
-            
-            # 中度健康問題（降低0.1分）
-            moderate_conditions = [
-                'allergies',
-                'eye problems',
-                'joint problems',
-                'hypothyroidism',
-                'ear infections',
-                'skin issues'
-            ]
-            
-            # 輕微健康問題（降低0.05分）
-            minor_conditions = [
-                'dental issues',
-                'weight gain tendency',
-                'minor allergies',
-                'seasonal allergies'
-            ]
-
+            # 嚴重健康問題 - 加重扣分
+            severe_conditions = {
+                'hip dysplasia': -0.25,           # 髖關節發育不良，影響生活品質
+                'heart disease': -0.25,           # 心臟疾病，需要長期治療
+                'progressive retinal atrophy': -0.20,  # 進行性視網膜萎縮，導致失明
+                'bloat': -0.22,                   # 胃扭轉，致命風險
+                'epilepsy': -0.20,                # 癲癇，需要長期藥物控制
+                'degenerative myelopathy': -0.20,  # 脊髓退化，影響行動能力
+                'von willebrand disease': -0.18    # 血液凝固障礙
+            }
+            
+            # 中度健康問題 - 適度扣分
+            moderate_conditions = {
+                'allergies': -0.12,               # 過敏問題，需要持續關注
+                'eye problems': -0.15,            # 眼睛問題，可能需要手術
+                'joint problems': -0.15,          # 關節問題，影響運動能力
+                'hypothyroidism': -0.12,          # 甲狀腺功能低下，需要藥物治療
+                'ear infections': -0.10,          # 耳道感染，需要定期清理
+                'skin issues': -0.12              # 皮膚問題，需要特殊護理
+            }
+            
+            # 輕微健康問題 - 輕微扣分
+            minor_conditions = {
+                'dental issues': -0.08,           # 牙齒問題，需要定期護理
+                'weight gain tendency': -0.08,     # 易胖體質，需要控制飲食
+                'minor allergies': -0.06,         # 輕微過敏，可控制
+                'seasonal allergies': -0.06       # 季節性過敏
+            }
+        
             # 計算基礎健康分數
             health_score = 1.0
             
-            # 根據問題嚴重程度扣分
-            severe_count = sum(1 for condition in severe_conditions if condition in health_notes)
-            moderate_count = sum(1 for condition in moderate_conditions if condition in health_notes)
-            minor_count = sum(1 for condition in minor_conditions if condition in health_notes)
+            # 健康問題累積效應計算
+            condition_counts = {
+                'severe': 0,
+                'moderate': 0,
+                'minor': 0
+            }
             
-            health_score -= (severe_count * 0.15)
-            health_score -= (moderate_count * 0.1)
-            health_score -= (minor_count * 0.05)
-
-            # 壽命影響
+            # 計算各等級健康問題的數量和影響
+            for condition, penalty in severe_conditions.items():
+                if condition in health_notes:
+                    health_score += penalty
+                    condition_counts['severe'] += 1
+                    
+            for condition, penalty in moderate_conditions.items():
+                if condition in health_notes:
+                    health_score += penalty
+                    condition_counts['moderate'] += 1
+                    
+            for condition, penalty in minor_conditions.items():
+                if condition in health_notes:
+                    health_score += penalty
+                    condition_counts['minor'] += 1
+            
+            # 多重問題的額外懲罰（累積效應）
+            if condition_counts['severe'] > 1:
+                health_score *= (0.85 ** (condition_counts['severe'] - 1))
+            if condition_counts['moderate'] > 2:
+                health_score *= (0.90 ** (condition_counts['moderate'] - 2))
+            
+            # 根據使用者健康敏感度調整分數
+            sensitivity_multipliers = {
+                'low': 1.1,      # 較不在意健康問題
+                'medium': 1.0,   # 標準評估
+                'high': 0.85     # 非常注重健康問題
+            }
+            
+            health_score *= sensitivity_multipliers.get(user_prefs.health_sensitivity, 1.0)
+        
+            # 壽命影響評估
             try:
                 lifespan = breed_health_info[breed_name].get('average_lifespan', '10-12')
                 years = float(lifespan.split('-')[0])
                 if years < 8:
-                    health_score *= 0.9
+                    health_score *= 0.85   # 短壽命顯著降低分數
+                elif years < 10:
+                    health_score *= 0.92   # 較短壽命輕微降低分數
                 elif years > 13:
-                    health_score *= 1.1
+                    health_score *= 1.1    # 長壽命適度加分
             except:
                 pass
-
+        
             # 特殊健康優勢
             if 'generally healthy' in health_notes or 'hardy breed' in health_notes:
+                health_score *= 1.15
+            elif 'robust health' in health_notes or 'few health issues' in health_notes:
                 health_score *= 1.1
+        
+            # 確保分數在合理範圍內，但允許更大的分數差異
+            return max(0.1, min(1.0, health_score))
+            
+
+        # def calculate_noise_score(breed_name: str, user_noise_tolerance: str) -> 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.9, 'high': 0.8},
+        #         'medium': {'low': 0.7, 'medium': 1.0, 'high': 0.9},
+        #         'high': {'low': 0.4, 'medium': 0.7, 'high': 1.0},
+        #         'varies': {'low': 0.6, 'medium': 0.8, 'high': 0.9}
+        #     }
+
+        #     # 獲取基礎分數
+        #     base_score = base_scores.get(noise_level, {'low': 0.7, 'medium': 0.8, 'high': 0.6})[user_noise_tolerance]
+
+        #     # 吠叫原因評估
+        #     barking_reasons_penalty = 0
+        #     problematic_triggers = [
+        #         ('separation anxiety', -0.15),
+        #         ('excessive barking', -0.12),
+        #         ('territorial', -0.08),
+        #         ('alert barking', -0.05),
+        #         ('attention seeking', -0.05)
+        #     ]
 
-            return max(0.2, min(1.0, health_score))
+        #     for trigger, penalty in problematic_triggers:
+        #         if trigger in noise_notes:
+        #             barking_reasons_penalty += penalty
 
-        def calculate_noise_score(breed_name: str, user_noise_tolerance: str) -> float:
-            """計算品種噪音分數"""
+        #     # 可訓練性補償
+        #     trainability_bonus = 0
+        #     if 'responds well to training' in noise_notes:
+        #         trainability_bonus = 0.1
+        #     elif 'can be trained' in noise_notes:
+        #         trainability_bonus = 0.05
+
+        #     # 特殊情況
+        #     special_adjustments = 0
+        #     if 'rarely barks' in noise_notes:
+        #         special_adjustments += 0.1
+        #     if 'howls' in noise_notes and user_noise_tolerance == 'low':
+        #         special_adjustments -= 0.1
+
+        #     final_score = base_score + barking_reasons_penalty + trainability_bonus + special_adjustments
+            
+        #     return max(0.2, min(1.0, final_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.9, 'high': 0.8},
-                'medium': {'low': 0.7, 'medium': 1.0, 'high': 0.9},
-                'high': {'low': 0.4, 'medium': 0.7, 'high': 1.0},
-                'varies': {'low': 0.6, 'medium': 0.8, 'high': 0.9}
+                '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.7, 'medium': 0.8, 'high': 0.6})[user_noise_tolerance]
-
-            # 吠叫原因評估
-            barking_reasons_penalty = 0
-            problematic_triggers = [
-                ('separation anxiety', -0.15),
-                ('excessive barking', -0.12),
-                ('territorial', -0.08),
-                ('alert barking', -0.05),
-                ('attention seeking', -0.05)
-            ]
-
-            for trigger, penalty in problematic_triggers:
+        
+            # 取得基礎分數
+            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_reasons_penalty += penalty
-
-            # 可訓練性補償
+                    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
+                    },
+                    '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)
+        
+            # 訓練性補償評估
             trainability_bonus = 0
             if 'responds well to training' in noise_notes:
-                trainability_bonus = 0.1
+                trainability_bonus = 0.12
             elif 'can be trained' in noise_notes:
-                trainability_bonus = 0.05
+                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))
+            
 
-            # 特殊情況
-            special_adjustments = 0
-            if 'rarely barks' in noise_notes:
-                special_adjustments += 0.1
-            if 'howls' in noise_notes and user_noise_tolerance == 'low':
-                special_adjustments -= 0.1
+        # # 計算所有基礎分數
+        # scores = {
+        #     'space': calculate_space_score(
+        #         breed_info['Size'], 
+        #         user_prefs.living_space,
+        #         user_prefs.space_for_play,
+        #         breed_info.get('Exercise Needs', 'Moderate')
+        #     ),
+        #     'exercise': calculate_exercise_score(
+        #         breed_info.get('Exercise Needs', 'Moderate'),
+        #         user_prefs.exercise_time
+        #     ),
+        #     'grooming': calculate_grooming_score(
+        #         breed_info.get('Grooming Needs', 'Moderate'),
+        #         user_prefs.grooming_commitment.lower(),
+        #         breed_info['Size']
+        #     ),
+        #     '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', '')),
+        #     'noise': calculate_noise_score(breed_info.get('Breed', ''), user_prefs.noise_tolerance)
+        # }
+
+
+    #     # 優化權重配置
+    #     weights = {
+    #         'space': 0.28,      
+    #         'exercise': 0.18,   
+    #         'grooming': 0.12,   
+    #         'experience': 0.22, 
+    #         'health': 0.12,     
+    #         'noise': 0.08      
+    #     }
 
-            final_score = base_score + barking_reasons_penalty + trainability_bonus + special_adjustments
+    #     # 計算加權總分
+    #     weighted_score = sum(score * weights[category] for category, score in scores.items())
+
+    #     def amplify_score(score):
+    #         """
+    #         優化分數放大函數，確保分數範圍合理且結果一致
+    #         """
+    #         # 基礎調整
+    #         adjusted = (score - 0.35) * 1.8
+            
+    #         # 使用 3.2 次方使曲線更平滑
+    #         amplified = pow(adjusted, 3.2) / 5.8 + score
+            
+    #         # 特別處理高分區間，確保不超過95%
+    #         if amplified > 0.90:
+    #             # 壓縮高分區間，確保最高到95%
+    #             amplified = 0.90 + (amplified - 0.90) * 0.5
             
-            return max(0.2, min(1.0, final_score))
+    #         # 確保最終分數在合理範圍內（0.55-0.95）
+    #         final_score = max(0.55, min(0.95, amplified))
+            
+    #         # 四捨五入到小數點後第三位
+    #         return round(final_score, 3)
+        
+    #     final_score = amplify_score(weighted_score)
+
+    #     # 四捨五入所有分數
+    #     scores = {k: round(v, 4) for k, v in scores.items()}
+    #     scores['overall'] = round(final_score, 4)
+
+    #     return scores
+
+    # except Exception as e:
+    #     print(f"Error details: {str(e)}")
+    #     print(f"breed_info: {breed_info}")
+    #     # print(f"Error in calculate_compatibility_score: {str(e)}")
+    #     return {k: 0.6 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}
 
-        # 計算所有基礎分數
         scores = {
             'space': calculate_space_score(
                 breed_info['Size'], 
@@ -642,9 +1316,8 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'noise': calculate_noise_score(breed_info.get('Breed', ''), user_prefs.noise_tolerance)
         }
 
-
-        # 優化權重配置
-        weights = {
+        # 2. 優化權重配置 - 根據使用者情況動態調整權重
+        base_weights = {
             'space': 0.28,      
             'exercise': 0.18,   
             'grooming': 0.12,   
@@ -653,40 +1326,75 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'noise': 0.08      
         }
 
-        # 計算加權總分
-        weighted_score = sum(score * weights[category] for category, score in scores.items())
+        # 根據特殊情況調整權重
+        weights = base_weights.copy()
+        
+        # 有孩童時的權重調整
+        if user_prefs.has_children:
+            if user_prefs.children_age == 'toddler':
+                weights['experience'] *= 1.4  # 幼童需要更有經驗的配對
+                weights['noise'] *= 1.3       # 噪音影響更重要
+                weights['health'] *= 1.2      # 健康因素更關鍵
+            elif user_prefs.children_age == 'school_age':
+                weights['experience'] *= 1.2
+                weights['noise'] *= 1.2
+            
+        # 居住環境的權重調整
+        if user_prefs.living_space == 'apartment':
+            weights['space'] *= 1.3           # 空間限制更重要
+            weights['noise'] *= 1.2           # 噪音影響更顯著
+        
+        # 重新正規化權重
+        total_weight = sum(weights.values())
+        weights = {k: v/total_weight for k, v in weights.items()}
 
+        # 3. 計算加權總分
+        weighted_score = sum(score * weights[category] for category, score in scores.items())
+        
+        # 4. 改進的分數放大函數
         def amplify_score(score):
             """
-            優化分數放大函數，確保分數範圍合理且結果一致
+            改進的分數放大函數，提供更大的分數差異。
+            
+            主要改進：
+            1. 調整基礎計算參數以產生更明顯的差異
+            2. 根據分數區間使用不同的放大策略
+            3. 擴大最終分數範圍
             """
-            # 基礎調整
-            adjusted = (score - 0.35) * 1.8
+            # 基礎調整，擴大差異
+            adjusted = (score - 0.4) * 2.0  # 從0.35調整到0.4，倍數從1.8提高到2.0
             
-            # 使用 3.2 次方使曲線更平滑
-            amplified = pow(adjusted, 3.2) / 5.8 + score
+            # 使用更陡峭的曲線，從3.2降到2.8使曲線不會過於極端
+            amplified = pow(adjusted, 2.8) / 4.5 + score
             
-            # 特別處理高分區間，確保不超過95%
-            if amplified > 0.90:
-                # 壓縮高分區間，確保最高到95%
-                amplified = 0.90 + (amplified - 0.90) * 0.5
+            # 分數區間處理
+            if score < 0.65:  # 低分區間
+                amplified *= 0.85  # 進一步降低不適合的配對
+            elif score > 0.85:  # 高分區間
+                amplified = 0.85 + (amplified - 0.85) * 0.4  # 高分區間的緩和壓縮
             
-            # 確保最終分數在合理範圍內（0.55-0.95）
-            final_score = max(0.55, min(0.95, amplified))
+            # 擴大分數範圍到0.45-0.95，原本是0.55-0.95
+            final_score = max(0.45, min(0.95, amplified))
             
             # 四捨五入到小數點後第三位
             return round(final_score, 3)
-        
+
+        # 5. 計算最終分數並應用關鍵條件檢查
         final_score = amplify_score(weighted_score)
+        
+        # 針對特殊情況的最終調整
+        if user_prefs.has_children and scores['experience'] < 0.4:
+            final_score *= 0.8  # 有孩童但經驗分數過低時大幅降低
+        if user_prefs.living_space == 'apartment' and scores['noise'] < 0.3:
+            final_score *= 0.75  # 住公寓但噪音分數極低時顯著降低
 
-        # 四捨五入所有分數
+        # 6. 準備返回結果
         scores = {k: round(v, 4) for k, v in scores.items()}
         scores['overall'] = round(final_score, 4)
-
+        
         return scores
 
     except Exception as e:
         print(f"Error details: {str(e)}")
         print(f"breed_info: {breed_info}")
-        # print(f"Error in calculate_compatibility_score: {str(e)}")
         return {k: 0.6 for k in ['space', 'exercise', 'grooming', 'experience', 'health', 'noise', 'overall']}