Update scoring_calculation_system.py

scoring_calculation_system.py

@@ -1813,93 +1813,33 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
                     
             return multiplier
         
-        # def evaluate_breed_specific_requirements():
-        #     """評估品種特定的要求，加強運動需求的判斷"""
-        #     multiplier = 1.0
-        #     exercise_time = user_prefs.exercise_time
-        #     exercise_type = user_prefs.exercise_type
-            
-        #     # 檢查品種的基本特性
-        #     temperament = breed_info.get('Temperament', '').lower()
-        #     description = breed_info.get('Description', '').lower()
-        #     exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-            
-        #     # 加強運動需求的匹配判斷
-        #     if exercise_needs == 'LOW':
-        #         if exercise_time > 90:  # 如果用戶運動時間過長
-        #             multiplier *= 0.5   # 給予更強的懲罰
-        #     elif exercise_needs == 'VERY HIGH':
-        #         if exercise_time < 60:  # 如果用戶運動時間過短
-        #             multiplier *= 0.5
-                    
-        #     if 'sprint' in temperament:
-        #         if exercise_time > 120 and exercise_type != 'active_training':
-        #             multiplier *= 0.7
-                    
-        #     if any(trait in temperament for trait in ['working', 'herding']):
-        #         if exercise_time < 90 or exercise_type == 'light_walks':
-        #             multiplier *= 0.7
-                    
-        #     return multiplier
-
         def evaluate_breed_specific_requirements():
-            """
-            1. 嚴格的運動需求匹配
-            2. 細緻的品種特性評估
-            3. 強化經驗要求的判斷
-            """
+            """評估品種特定的要求，加強運動需求的判斷"""
             multiplier = 1.0
             exercise_time = user_prefs.exercise_time
             exercise_type = user_prefs.exercise_type
             
-            # 獲取品種的關鍵特性
+            # 檢查品種的基本特性
             temperament = breed_info.get('Temperament', '').lower()
             description = breed_info.get('Description', '').lower()
             exercise_needs = breed_info.get('Exercise Needs', 'MODERATE').upper()
-            care_level = breed_info.get('Care Level', 'MODERATE').upper()
-            
-            # 運動需求匹配評估 
-            exercise_mismatch = {
-                'VERY HIGH': {
-                    'min_time': 60,
-                    'penalty_rate': 0.4 if exercise_time < 60 else 0.0
-                },
-                'HIGH': {
-                    'min_time': 45,
-                    'penalty_rate': 0.35 if exercise_time < 45 else 0.0
-                },
-                'LOW': {
-                    'max_time': 90,
-                    'penalty_rate': 0.4 if exercise_time > 90 else 0.0
-                }
-            }
-            
-            if exercise_needs in exercise_mismatch:
-                match_info = exercise_mismatch[exercise_needs]
-                if 'min_time' in match_info and exercise_time < match_info['min_time']:
-                    multiplier *= (1 - match_info['penalty_rate'])
-                elif 'max_time' in match_info and exercise_time > match_info['max_time']:
-                    multiplier *= (1 - match_info['penalty_rate'])
-        
-            # 品種特性專門評估
-            breed_traits = {
-                'working_dog': ['working', 'herding', 'intelligent', 'active'],
-                'family_dog': ['gentle', 'friendly', 'good with children', 'patient'],
-                'guard_dog': ['protective', 'territorial', 'alert', 'watchdog']
-            }
-            
-            # 根據用戶條件評估特殊特性
-            for trait_type, traits in breed_traits.items():
-                if any(trait in temperament for trait in traits):
-                    if trait_type == 'working_dog':
-                        if user_prefs.experience_level == 'beginner':
-                            multiplier *= 0.7
-                        if exercise_time < 90:
-                            multiplier *= 0.75
-                    elif trait_type == 'guard_dog':
-                        if user_prefs.has_children and user_prefs.experience_level != 'advanced':
-                            multiplier *= 0.8
             
+            # 加強運動需求的匹配判斷
+            if exercise_needs == 'LOW':
+                if exercise_time > 90:  # 如果用戶運動時間過長
+                    multiplier *= 0.5   # 給予更強的懲罰
+            elif exercise_needs == 'VERY HIGH':
+                if exercise_time < 60:  # 如果用戶運動時間過短
+                    multiplier *= 0.5
+                    
+            if 'sprint' in temperament:
+                if exercise_time > 120 and exercise_type != 'active_training':
+                    multiplier *= 0.7
+                    
+            if any(trait in temperament for trait in ['working', 'herding']):
+                if exercise_time < 90 or exercise_type == 'light_walks':
+                    multiplier *= 0.7
+                    
             return multiplier
         
         def evaluate_environmental_impact():
@@ -1929,76 +1869,40 @@ def calculate_breed_compatibility_score(scores: dict, user_prefs: UserPreference
         final_score = score * severity_multiplier
         return max(0.2, min(1.0, final_score))
 
-    # def calculate_base_score(scores: dict, weights: dict) -> float:
-    #     """
-    #     計算基礎分數，更寬容地處理極端組合
-    #     """
-    #     # 進一步降低關鍵指標閾值，使系統更包容極端組合
-    #     critical_thresholds = {
-    #     'space': 0.45,     # 進一步降低閾值
-    #     'exercise': 0.45,
-    #     'experience': 0.55,
-    #     'noise': 0.55
-    #     }
-        
-    #     critical_failures = []
-    #     for metric, threshold in critical_thresholds.items():
-    #         if scores[metric] < threshold:
-    #             critical_failures.append((metric, scores[metric]))
-        
-    #     base_score = sum(scores[k] * weights[k] for k in scores.keys())
-        
-    #     if critical_failures:
-    #         space_exercise_penalty = 0
-    #         other_penalty = 0
-            
-    #         for metric, score in critical_failures:
-    #             if metric in ['space', 'exercise']:
-    #                 space_exercise_penalty += (critical_thresholds[metric] - score) * 0.15  # 降低懲罰
-    #             else:
-    #                 other_penalty += (critical_thresholds[metric] - score) * 0.3
-            
-    #         total_penalty = (space_exercise_penalty + other_penalty) / 2
-    #         base_score *= (1 - total_penalty)
-            
-    #         if len(critical_failures) > 1:
-    #             base_score *= (0.98 ** (len(critical_failures) - 1))  # 進一步降低多重失敗懲罰
-        
-    #     return base_score
-
     def calculate_base_score(scores: dict, weights: dict) -> float:
         """
-        計算基礎分數，加強訓練需求評估
+        計算基礎分數，更寬容地處理極端組合
         """
-        # 基礎閾值保持不變
+        # 進一步降低關鍵指標閾值，使系統更包容極端組合
         critical_thresholds = {
-            'space': 0.5,
-            'exercise': 0.5,
-            'experience': 0.55,
-            'noise': 0.55
+        'space': 0.45,     # 進一步降低閾值
+        'exercise': 0.45,
+        'experience': 0.55,
+        'noise': 0.55
         }
         
-        # 評估訓練需求
-        training_level = breed_info.get('Training', 'MODERATE').upper()
-        if training_level == 'HIGH' and user_prefs.experience_level == 'beginner':
-            # 對需要大量訓練的品種給予較低的基礎分數
-            base_score = sum(scores[k] * weights[k] for k in scores.keys()) * 0.85
-        else:
-            base_score = sum(scores[k] * weights[k] for k in scores.keys())
-        
-        # 其他評估邏輯保持不變...
         critical_failures = []
         for metric, threshold in critical_thresholds.items():
             if scores[metric] < threshold:
                 critical_failures.append((metric, scores[metric]))
         
+        base_score = sum(scores[k] * weights[k] for k in scores.keys())
+        
         if critical_failures:
-            penalty = sum((critical_thresholds[metric] - score) * 0.3 
-                         for metric, score in critical_failures) / len(critical_failures)
-            base_score *= (1 - penalty)
+            space_exercise_penalty = 0
+            other_penalty = 0
+            
+            for metric, score in critical_failures:
+                if metric in ['space', 'exercise']:
+                    space_exercise_penalty += (critical_thresholds[metric] - score) * 0.15  # 降低懲罰
+                else:
+                    other_penalty += (critical_thresholds[metric] - score) * 0.3
+            
+            total_penalty = (space_exercise_penalty + other_penalty) / 2
+            base_score *= (1 - total_penalty)
             
             if len(critical_failures) > 1:
-                base_score *= (0.98 ** (len(critical_failures) - 1))
+                base_score *= (0.98 ** (len(critical_failures) - 1))  # 進一步降低多重失敗懲罰
         
         return base_score