Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -28,11 +28,113 @@ 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:
-    """計算品種額外加分"""
+    """
+    計算品種額外加分，考慮多個維度但不包含家庭相容性評分
+    """
     bonus = 0.0
     temperament = breed_info.get('Temperament', '').lower()
+    description = breed_info.get('Description', '').lower()
     
     # 1. 壽命加分（最高0.05）
     try:
@@ -55,13 +157,20 @@ def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> fl
         'calm': 0.03                
     }
     
+    # 根據經驗等級調整負面特徵的懲罰程度
+    experience_multiplier = {
+        'beginner': 1.3,      
+        'intermediate': 1.0,
+        'advanced': 0.8       
+    }.get(user_prefs.experience_level, 1.0)
+    
     negative_traits = {
-        'aggressive': -0.08,        
-        'stubborn': -0.06,
-        'dominant': -0.06,
-        'aloof': -0.04,
-        'nervous': -0.05,           
-        'protective': -0.04         
+        'aggressive': -0.08 * experience_multiplier,        
+        'stubborn': -0.06 * experience_multiplier,
+        'dominant': -0.06 * experience_multiplier,
+        'aloof': -0.04 * experience_multiplier,
+        'nervous': -0.05 * experience_multiplier,           
+        'protective': -0.04 * experience_multiplier         
     }
     
     personality_score = sum(value for trait, value in positive_traits.items() if trait in temperament)
@@ -74,56 +183,76 @@ def calculate_breed_bonus(breed_info: dict, user_prefs: 'UserPreferences') -> fl
         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']
+    # 考慮更多環境適應因素
+    if user_prefs.yard_access == "no_yard":
+        if "needs space" in description or "requires yard" in description:
+            adaptability_bonus -= 0.05
+    elif user_prefs.yard_access == "private_yard":
+        if "active" in description or "energetic" in description:
+            adaptability_bonus += 0.03
+            
+    # 氣候適應性
+    climate_terms = {
+        'cold': ['thick coat', 'winter', 'cold climate'],
+        'hot': ['short coat', 'warm climate', 'heat tolerant'],
+        'moderate': ['adaptable', 'all climate']
+    }
+    if any(term in description for term in climate_terms[user_prefs.climate]):
+        adaptability_bonus += 0.02
         
-        bonus += min(0.15, max(-0.2, family_bonus + family_penalty))
+    bonus += min(0.1, adaptability_bonus)
 
-    
-    # 5. 專門技能加分（最高0.1）
+    # 4. 專門技能評估（最高0.1）
     skill_bonus = 0.0
+    exercise_level = user_prefs.exercise_time / 60.0  # 轉換為小時
+    
     special_abilities = {
-        'working': 0.03,
-        'herding': 0.03,
-        'hunting': 0.03,
-        'tracking': 0.03,
-        'agility': 0.02
+        'working': 0.03 if exercise_level >= 1.5 else 0.01,
+        'herding': 0.03 if exercise_level >= 1.5 else 0.01,
+        'hunting': 0.03 if exercise_level >= 1.5 else 0.01,
+        'tracking': 0.03 if exercise_level >= 1.0 else 0.02,
+        'agility': 0.02 if exercise_level >= 1.0 else 0.01,
+        'sporting': 0.02 if exercise_level >= 1.2 else 0.01  # 新增運動犬種考量
     }
+    
     for ability, value in special_abilities.items():
-        if ability in temperament.lower():
-            skill_bonus += value
+        if ability in temperament.lower() or ability in description:
+            # 根據使用者經驗和時間可用性調整技能加分
+            time_multiplier = 1.2 if user_prefs.time_availability == 'flexible' else 0.8
+            if user_prefs.experience_level == 'advanced':
+                skill_bonus += value * 1.2 * time_multiplier
+            elif user_prefs.experience_level == 'beginner':
+                skill_bonus += value * 0.7 * time_multiplier
+            else:
+                skill_bonus += value * time_multiplier
+                
     bonus += min(0.1, skill_bonus)
 
+    # 5. 特殊需求評估（最高0.1/-0.15）
+    special_needs_score = 0.0
+    
+    # 檢查特殊訓練需求
+    if any(term in description for term in ['requires extensive training', 'needs firm training']):
+        if user_prefs.experience_level == 'beginner':
+            special_needs_score -= 0.08
+        elif user_prefs.experience_level == 'intermediate':
+            special_needs_score -= 0.04
+            
+    # 檢查社交需求
+    if 'social needs' in description or 'requires companionship' in description:
+        if user_prefs.time_availability == 'limited':
+            special_needs_score -= 0.06
+        elif user_prefs.time_availability == 'flexible':
+            special_needs_score += 0.02
+            
+    # 檢查獨立性
+    if 'independent' in temperament:
+        if user_prefs.time_availability == 'limited':
+            special_needs_score += 0.03
+    
+    bonus += max(-0.15, min(0.1, special_needs_score))
+
     return min(0.5, max(-0.25, bonus))
 
 
@@ -205,6 +334,116 @@ def calculate_additional_factors(breed_info: dict, user_prefs: 'UserPreferences'
     return factors
 
 
+@staticmethod
+def calculate_family_safety_score(breed_info: dict, children_age: str) -> float:
+    """
+    計算品種與家庭/兒童的安全相容性分數，作為calculate_compatibility_score的一部分
+    
+    參數:
+    breed_info (dict): 品種資訊
+    children_age (str): 兒童年齡組別 ('toddler', 'school_age', 'teenager')
+    
+    返回:
+    float: 0.2-0.95之間的安全分數
+    """
+    temperament = breed_info.get('Temperament', '').lower()
+    size = breed_info.get('Size', 'Medium')
+    
+    # 基礎安全分數（根據體型）
+    base_safety_scores = {
+        "Small": 0.85,    
+        "Medium": 0.75,   
+        "Large": 0.65,    
+        "Giant": 0.55     
+    }
+    safety_score = base_safety_scores.get(size, 0.70)
+    
+    # 年齡相關的調整
+    age_factors = {
+        'toddler': {
+            'base_modifier': -0.15,
+            'size_penalty': {
+                "Small": -0.05,
+                "Medium": -0.10,
+                "Large": -0.20,
+                "Giant": -0.25
+            }
+        },
+        'school_age': {
+            'base_modifier': -0.08,
+            'size_penalty': {
+                "Small": -0.02,
+                "Medium": -0.05,
+                "Large": -0.10,
+                "Giant": -0.15
+            }
+        },
+        'teenager': {
+            'base_modifier': -0.05,
+            'size_penalty': {
+                "Small": 0,
+                "Medium": -0.02,
+                "Large": -0.05,
+                "Giant": -0.08
+            }
+        }
+    }
+    
+    # 應用年齡相關調整
+    age_adjustment = age_factors.get(children_age, age_factors['school_age'])
+    safety_score += age_adjustment['base_modifier']
+    safety_score += age_adjustment['size_penalty'].get(size, -0.10)
+    
+    # 正面特徵評估
+    positive_traits = {
+        'gentle': 0.10,
+        'patient': 0.10,
+        'good with children': 0.15,
+        'friendly': 0.08,
+        'calm': 0.08,
+        'tolerant': 0.08,
+        'playful': 0.05
+    }
+    
+    # 危險特徵評估（更嚴格的懲罰）
+    dangerous_traits = {
+        'aggressive': -0.25,
+        'territorial': -0.20,
+        'protective': -0.15,
+        'nervous': -0.15,
+        'dominant': -0.15,
+        'strong-willed': -0.12,
+        'independent': -0.10,
+        'energetic': -0.08
+    }
+    
+    # 計算特徵分數
+    for trait, bonus in positive_traits.items():
+        if trait in temperament:
+            safety_score += bonus * 0.8  # 降低正面特徵的影響力
+            
+    for trait, penalty in dangerous_traits.items():
+        if trait in temperament:
+            # 對幼童加重懲罰
+            if children_age == 'toddler':
+                safety_score += penalty * 1.3
+            # 對青少年略微減輕懲罰
+            elif children_age == 'teenager':
+                safety_score += penalty * 0.8
+            else:
+                safety_score += penalty
+    
+    # 特殊風險評估
+    description = breed_info.get('Description', '').lower()
+    if 'history of' in description:
+        safety_score -= 0.15
+    if 'requires experienced' in description:
+        safety_score -= 0.10
+    
+    # 將分數限制在合理範圍內
+    return max(0.2, min(0.95, safety_score))
+
+
 def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences) -> dict:
     """計算品種與使用者條件的相容性分數的優化版本"""
     try:
@@ -293,88 +532,192 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             return base_score
             
 
-        def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
-            """
-            計算使用者經驗與品種需求的匹配分數
+        # def calculate_experience_score(care_level: str, user_experience: str, temperament: str) -> float:
+        #     """
+        #     計算使用者經驗與品種需求的匹配分數
+            
+        #     參數說明:
+        #     care_level: 品種的照顧難度 ("High", "Moderate", "Low")
+        #     user_experience: 使用者經驗等級 ("beginner", "intermediate", "advanced") 
+        #     temperament: 品種的性格特徵描述
+            
+        #     返回:
+        #     float: 0.2-1.0 之間的匹配分數
+        #     """
+        #     # 基礎分數矩陣 - 更大的分數差異來反映經驗重要性
+        #     base_scores = {
+        #         "High": {
+        #             "beginner": 0.12,     # 降低起始分，反映高難度品種對新手的挑戰
+        #             "intermediate": 0.65,  # 中級玩家可以應付，但仍有改善空間
+        #             "advanced": 1.0       # 資深者能完全勝任
+        #         },
+        #         "Moderate": {
+        #             "beginner": 0.35,    # 適中難度對新手來說仍具挑戰
+        #             "intermediate": 0.82, # 中級玩家有很好的勝任能���
+        #             "advanced": 1.0      # 資深者完全勝任
+        #         },
+        #         "Low": {
+        #             "beginner": 0.72,    # 低難度品種適合新手
+        #             "intermediate": 0.92, # 中級玩家幾乎完全勝任
+        #             "advanced": 1.0      # 資深者完全勝任
+        #         }
+        #     }
+            
+        #     # 取得基礎分數
+        #     score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
             
-            參數說明:
-            care_level: 品種的照顧難度 ("High", "Moderate", "Low")
-            user_experience: 使用者經驗等級 ("beginner", "intermediate", "advanced") 
-            temperament: 品種的性格特徵描述
+        #     # 性格特徵評估 - 根據經驗等級調整權重
+        #     temperament_lower = temperament.lower()
+        #     temperament_adjustments = 0.0
+            
+        #     if user_experience == "beginner":
+        #         # 新手不適合的特徵 - 更嚴格的懲罰
+        #         difficult_traits = {
+        #             'stubborn': -0.15,      # 加重固執的懲罰
+        #             'independent': -0.12,    # 加重獨立性的懲罰
+        #             'dominant': -0.12,       # 加重支配性的懲罰
+        #             'strong-willed': -0.10,  # 加重強勢的懲罰
+        #             'protective': -0.08,     # 加重保護性的懲罰
+        #             'aloof': -0.08,         # 加重冷漠的懲罰
+        #             'energetic': -0.06      # 輕微懲罰高能量
+        #         }
+                
+        #         # 新手友善的特徵 - 提供更多獎勵
+        #         easy_traits = {
+        #             'gentle': 0.08,          # 增加溫和的獎勵
+        #             'friendly': 0.08,        # 增加友善的獎勵
+        #             'eager to please': 0.08, # 增加順從的獎勵
+        #             'patient': 0.06,         # 獎勵耐心
+        #             'adaptable': 0.06,       # 獎勵適應性
+        #             'calm': 0.05            # 獎勵冷靜
+        #         }
+                
+        #         # 計算特徵調整
+        #         for trait, penalty in difficult_traits.items():
+        #             if trait in temperament_lower:
+        #                 temperament_adjustments += penalty * 1.2  # 加重新手的懲罰
+                
+        #         for trait, bonus in easy_traits.items():
+        #             if trait in temperament_lower:
+        #                 temperament_adjustments += bonus
+                        
+        #         # 品種特殊調整
+        #         if any(term in temperament_lower for term in ['terrier', 'working', 'guard']):
+        #             temperament_adjustments -= 0.12  # 加重對特定類型品種的懲罰
+                    
+        #     elif user_experience == "intermediate":
+        #         # 中級玩家的調整更加平衡
+        #         moderate_traits = {
+        #             'intelligent': 0.05,     # 獎勵聰明
+        #             'athletic': 0.04,        # 獎勵運動能力
+        #             'versatile': 0.04,       # 獎勵多功能性
+        #             'stubborn': -0.06,       # 輕微懲罰固執
+        #             'independent': -0.05,    # 輕微懲罰獨立性
+        #             'protective': -0.04      # 輕微懲罰保護性
+        #         }
+                
+        #         for trait, adjustment in moderate_traits.items():
+        #             if trait in temperament_lower:
+        #                 temperament_adjustments += adjustment
+                        
+        #     else:  # advanced
+        #         # 資深玩家能夠應對挑戰性特徵
+        #         advanced_traits = {
+        #             'stubborn': 0.04,        # 反轉為優勢
+        #             'independent': 0.04,      # 反轉為優勢
+        #             'intelligent': 0.05,      # 獎勵聰明
+        #             'protective': 0.04,       # 獎勵保護性
+        #             'strong-willed': 0.03    # 獎勵強勢
+        #         }
+                
+        #         for trait, bonus in advanced_traits.items():
+        #             if trait in temperament_lower:
+        #                 temperament_adjustments += bonus
             
-            返回:
-            float: 0.2-1.0 之間的匹配分數
+        #     # 確保最終分數在合理範圍內
+        #     final_score = max(0.2, min(1.0, score + temperament_adjustments))
+        #     return final_score
+
+        def calculate_experience_score(care_level: str, user_experience: str, temperament: str, has_children: bool = False) -> float:
+            """
+            計算使用者經驗與品種需求的匹配分數，加入了更嚴格的評估標準
             """
-            # 基礎分數矩陣 - 更大的分數差異來反映經驗重要性
+            # 即使是進階使用者也不應該完全無視品種難���
             base_scores = {
                 "High": {
-                    "beginner": 0.12,     # 降低起始分，反映高難度品種對新手的挑戰
-                    "intermediate": 0.65,  # 中級玩家可以應付，但仍有改善空間
-                    "advanced": 1.0       # 資深者能完全勝任
+                    "beginner": 0.12,
+                    "intermediate": 0.65,
+                    "advanced": 0.85  
                 },
                 "Moderate": {
-                    "beginner": 0.35,    # 適中難度對新手來說仍具挑戰
-                    "intermediate": 0.82, # 中級玩家有很好的勝任能力
-                    "advanced": 1.0      # 資深者完全勝任
+                    "beginner": 0.35,
+                    "intermediate": 0.75,
+                    "advanced": 0.90
                 },
                 "Low": {
-                    "beginner": 0.72,    # 低難度品種適合新手
-                    "intermediate": 0.92, # 中級玩家幾乎完全勝任
-                    "advanced": 1.0      # 資深者完全勝任
+                    "beginner": 0.65,
+                    "intermediate": 0.85,
+                    "advanced": 0.92
                 }
             }
             
             # 取得基礎分數
             score = base_scores.get(care_level, base_scores["Moderate"])[user_experience]
             
-            # 性格特徵評估 - 根據經驗等級調整權重
+            # 品種難度評估 
+            breed_difficulty_penalty = 0.0
+            difficult_characteristics = {
+                'working': 0.08,
+                'guardian': 0.10,
+                'primitive': 0.12,
+                'independent': 0.08,
+                'strong-willed': 0.07
+            }
+            
+            for trait, penalty in difficult_characteristics.items():
+                if trait in temperament.lower():
+                    # 即使是進階使用者也會受到一定程度的懲罰
+                    if user_experience == "advanced":
+                        breed_difficulty_penalty += penalty * 0.4
+                    elif user_experience == "intermediate":
+                        breed_difficulty_penalty += penalty * 0.7
+                    else:
+                        breed_difficulty_penalty += penalty
+        
+            # 性格特徵評估 
             temperament_lower = temperament.lower()
             temperament_adjustments = 0.0
             
             if user_experience == "beginner":
-                # 新手不適合的特徵 - 更嚴格的懲罰
                 difficult_traits = {
-                    'stubborn': -0.15,      # 加重固執的懲罰
-                    'independent': -0.12,    # 加重獨立性的懲罰
-                    'dominant': -0.12,       # 加重支配性的懲罰
-                    'strong-willed': -0.10,  # 加重強勢的懲罰
-                    'protective': -0.08,     # 加重保護性的懲罰
-                    'aloof': -0.08,         # 加重冷漠的懲罰
-                    'energetic': -0.06      # 輕微懲罰高能量
+                    'stubborn': -0.15,
+                    'independent': -0.12,
+                    'dominant': -0.12,
+                    'protective': -0.10,
+                    'aloof': -0.08
                 }
-                
-                # 新手友善的特徵 - 提供更多獎勵
                 easy_traits = {
-                    'gentle': 0.08,          # 增加溫和的獎勵
-                    'friendly': 0.08,        # 增加友善的獎勵
-                    'eager to please': 0.08, # 增加順從的獎勵
-                    'patient': 0.06,         # 獎勵耐心
-                    'adaptable': 0.06,       # 獎勵適應性
-                    'calm': 0.05            # 獎勵冷靜
+                    'gentle': 0.08,
+                    'friendly': 0.08,
+                    'eager to please': 0.08,
+                    'patient': 0.06
                 }
                 
-                # 計算特徵調整
                 for trait, penalty in difficult_traits.items():
                     if trait in temperament_lower:
-                        temperament_adjustments += penalty * 1.2  # 加重新手的懲罰
+                        temperament_adjustments += penalty * 1.2
                 
                 for trait, bonus in easy_traits.items():
                     if trait in temperament_lower:
                         temperament_adjustments += bonus
                         
-                # 品種特殊調整
-                if any(term in temperament_lower for term in ['terrier', 'working', 'guard']):
-                    temperament_adjustments -= 0.12  # 加重對特定類型品種的懲罰
-                    
             elif user_experience == "intermediate":
-                # 中級玩家的調整更加平衡
                 moderate_traits = {
-                    'intelligent': 0.05,     # 獎勵聰明
-                    'athletic': 0.04,        # 獎勵運動能力
-                    'versatile': 0.04,       # 獎勵多功能性
-                    'stubborn': -0.06,       # 輕微懲罰固執
-                    'independent': -0.05,    # 輕微懲罰獨立性
-                    'protective': -0.04      # 輕微懲罰保護性
+                    'intelligent': 0.04,
+                    'athletic': 0.03,
+                    'versatile': 0.03,
+                    'stubborn': -0.06,
+                    'independent': -0.05
                 }
                 
                 for trait, adjustment in moderate_traits.items():
@@ -382,22 +725,43 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
                         temperament_adjustments += adjustment
                         
             else:  # advanced
-                # 資深玩家能夠應對挑戰性特徵
+                # 即使是進階使用者，某些特徵也應該被視為挑戰而非優勢
                 advanced_traits = {
-                    'stubborn': 0.04,        # 反轉為優勢
-                    'independent': 0.04,      # 反轉為優勢
-                    'intelligent': 0.05,      # 獎勵聰明
-                    'protective': 0.04,       # 獎勵保護性
-                    'strong-willed': 0.03    # 獎勵強勢
+                    'stubborn': 0.02,        
+                    'independent': 0.02,
+                    'intelligent': 0.04,
+                    'protective': -0.02,      
+                    'strong-willed': -0.02
                 }
                 
-                for trait, bonus in advanced_traits.items():
+                for trait, adjustment in advanced_traits.items():
                     if trait in temperament_lower:
-                        temperament_adjustments += bonus
-            
-            # 確保最終分數在合理範圍內
-            final_score = max(0.2, min(1.0, score + temperament_adjustments))
-            return final_score
+                        temperament_adjustments += adjustment
+        
+            # 如果有小孩，增加額外的安全考量
+            if has_children:
+                safety_penalty = 0.0
+                risky_traits = {
+                    'protective': 0.05,
+                    'territorial': 0.06,
+                    'dominant': 0.07,
+                    'aggressive': 0.10,
+                    'strong-willed': 0.05
+                }
+                
+                for trait, penalty in risky_traits.items():
+                    if trait in temperament_lower:
+                        # 即使是進階使用者，有小孩的情況下也要特別注意
+                        if user_experience == "advanced":
+                            safety_penalty += penalty * 0.7  
+                        else:
+                            safety_penalty += penalty
+                
+                temperament_adjustments -= safety_penalty
+        
+            # 確保最終分數在合理範圍內，且有適當的上限
+            final_score = score - breed_difficulty_penalty + temperament_adjustments
+            return max(0.2, min(0.92, final_score))  
 
         def calculate_health_score(breed_name: str) -> float:
             """計算品種健康分數"""
@@ -542,6 +906,14 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'noise': calculate_noise_score(breed_info.get('Breed', ''), user_prefs.noise_tolerance)
         }
 
+        breed_bonus = calculate_breed_bonus(breed_info, user_prefs)
+        scores['breed_bonus'] = breed_bonus
+        
+        # 如果有小孩，加入 family_safety 分數
+        if user_prefs.has_children:
+            scores['family_safety'] = calculate_family_safety_score(breed_info, user_prefs.children_age)
+            
+
         # 優化權重配置
         weights = {
             'space': 0.28,      
@@ -552,6 +924,18 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'noise': 0.08      
         }
 
+        if user_prefs.has_children:          
+            weights = {
+                'space': 0.20,
+                'exercise': 0.13,
+                'grooming': 0.08,
+                'experience': 0.15,
+                'health': 0.10,
+                'noise': 0.06,
+                'breed_bonus': 0.08,
+                'family_safety': 0.20  # 給予家庭安全較高權重
+            }
+
         # 計算加權總分
         weighted_score = sum(score * weights[category] for category, score in scores.items())