Upload 6 files

refactored description recommendation function and improved UI

breed_recommendation_enhanced.py

@@ -30,6 +30,8 @@ def create_description_examples():
                 gap: 15px;
                 margin-top: 10px;
             '>
+
+                <!-- 左上：冷色（藍） -->
                 <div style='
                     background: white;
                     padding: 12px;
@@ -37,12 +39,13 @@ def create_description_examples():
                     border: 1px solid #e2e8f0;
                     box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                 '>
-                    <strong style='color: #4299e1;'>🏠 Living Environment:</strong><br>
+                    <strong style='color: #4299e1;'>🏡 Active Lifestyle & Space:</strong><br>
                     <span style='color: #4a5568; font-size: 0.9em;'>
-                        "I live in an apartment and need a quiet, small dog that's good with children"
+                        "I live in a large house with a big backyard, and I love hiking and outdoor activities. I don't mind if the dog is noisy, as long as it's active and playful."
                     </span>
                 </div>
 
+                <!-- 右上：暖色（橘） -->
                 <div style='
                     background: white;
                     padding: 12px;
@@ -50,12 +53,13 @@ def create_description_examples():
                     border: 1px solid #e2e8f0;
                     box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                 '>
-                    <strong style='color: #48bb78;'>🎾 Activity Preferences:</strong><br>
+                    <strong style='color: #ed8936;'>🎾 Activity Preferences:</strong><br>
                     <span style='color: #4a5568; font-size: 0.9em;'>
                         "I want an active medium to large dog for hiking and outdoor activities"
                     </span>
                 </div>
 
+                <!-- 左下：冷色（紫） -->
                 <div style='
                     background: white;
                     padding: 12px;
@@ -63,12 +67,13 @@ def create_description_examples():
                     border: 1px solid #e2e8f0;
                     box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                 '>
-                    <strong style='color: #ed8936;'>❤️ Breed Preferences:</strong><br>
+                    <strong style='color: #805ad5;'>🚶 Balanced Daily Routine:</strong><br>
                     <span style='color: #4a5568; font-size: 0.9em;'>
-                        "I love Border Collies most, then Golden Retrievers, followed by Pugs"
+                        "I live in a medium-sized house, walk about 30 minutes every day, and I'm okay with a moderately vocal dog. Looking for a balanced companion."
                     </span>
                 </div>
 
+                <!-- 右下：暖色（琥珀橘） -->
                 <div style='
                     background: white;
                     padding: 12px;
@@ -76,7 +81,7 @@ def create_description_examples():
                     border: 1px solid #e2e8f0;
                     box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                 '>
-                    <strong style='color: #9f7aea;'>👥 Family Situation:</strong><br>
+                    <strong style='color: #276749;'>👥 Family Situation:</strong><br>
                     <span style='color: #4a5568; font-size: 0.9em;'>
                         "Looking for a calm, low-maintenance companion dog for elderly person"
                     </span>
@@ -98,7 +103,6 @@ def create_description_examples():
         </div>
     """
 
-
 def create_recommendation_tab(
     UserPreferences,
     get_breed_recommendations,
@@ -110,7 +114,7 @@ def create_recommendation_tab(
     with gr.TabItem("Breed Recommendation"):
         with gr.Tabs():
             # --------------------------
-            # Tab 1: Find by Criteria
+            # Find by Criteria
             # --------------------------
             with gr.Tab("Find by Criteria"):
                 gr.HTML("""
@@ -334,7 +338,7 @@ def create_recommendation_tab(
                 )
 
             # --------------------------
-            # Tab 2: Find by Description
+            # Find by Description
             # --------------------------
             with gr.Tab("Find by Description") as description_tab:
                 gr.HTML("""
@@ -639,4 +643,4 @@ def create_recommendation_tab(
         'criteria_results': locals().get('criteria_results'),
         'description_results': locals().get('description_results'),
         'description_input': locals().get('description_input')
-    }
+    }

matching_score_calculator.py

@@ -0,0 +1,974 @@
+import random
+import hashlib
+import numpy as np
+import sqlite3
+import re
+import traceback
+from typing import List, Dict, Tuple, Optional, Any
+from dataclasses import dataclass
+from sentence_transformers import SentenceTransformer
+import torch
+from sklearn.metrics.pairwise import cosine_similarity
+from dog_database import get_dog_description
+from breed_health_info import breed_health_info
+from breed_noise_info import breed_noise_info
+from scoring_calculation_system import UserPreferences, calculate_compatibility_score, UnifiedScoringSystem, calculate_unified_breed_scores
+from query_understanding import QueryUnderstandingEngine, analyze_user_query
+from constraint_manager import ConstraintManager, apply_breed_constraints
+from multi_head_scorer import MultiHeadScorer, score_breed_candidates, BreedScore
+from score_calibrator import ScoreCalibrator, calibrate_breed_scores
+from config_manager import get_config_manager, get_standardized_breed_data
+
+class MatchingScoreCalculator:
+    """
+    匹配評分計算器
+    處理多維度匹配計算、約束條件過濾和評分校準
+    """
+
+    def __init__(self, breed_list: List[str]):
+        """初始化匹配評分計算器"""
+        self.breed_list = breed_list
+
+    def apply_size_distribution_correction(self, recommendations: List[Dict]) -> List[Dict]:
+        """應用尺寸分佈修正以防止大型品種偏差"""
+        if len(recommendations) < 10:
+            return recommendations
+
+        # 分析尺寸分佈
+        size_counts = {'toy': 0, 'small': 0, 'medium': 0, 'large': 0, 'giant': 0}
+
+        for rec in recommendations:
+            breed_info = get_dog_description(rec['breed'])
+            if breed_info:
+                size = self._normalize_breed_size(breed_info.get('Size', 'Medium'))
+                size_counts[size] += 1
+
+        total_recs = len(recommendations)
+        large_giant_ratio = (size_counts['large'] + size_counts['giant']) / total_recs
+
+        # 如果超過 70% 是大型/巨型品種，應用修正
+        if large_giant_ratio > 0.7:
+            corrected_recommendations = []
+            size_quotas = {'toy': 2, 'small': 4, 'medium': 6, 'large': 2, 'giant': 1}
+            current_counts = {'toy': 0, 'small': 0, 'medium': 0, 'large': 0, 'giant': 0}
+
+            # 第一輪：在配額內添加品種
+            for rec in recommendations:
+                breed_info = get_dog_description(rec['breed'])
+                if breed_info:
+                    size = self._normalize_breed_size(breed_info.get('Size', 'Medium'))
+                    if current_counts[size] < size_quotas[size]:
+                        corrected_recommendations.append(rec)
+                        current_counts[size] += 1
+
+            # 第二輪：用最佳剩餘候選品種填滿剩餘位置
+            remaining_slots = 15 - len(corrected_recommendations)
+            remaining_breeds = [rec for rec in recommendations if rec not in corrected_recommendations]
+
+            corrected_recommendations.extend(remaining_breeds[:remaining_slots])
+            return corrected_recommendations
+
+        return recommendations
+
+    def _normalize_breed_size(self, size: str) -> str:
+        """標準化品種尺寸到標準分類"""
+        if not isinstance(size, str):
+            return 'medium'
+
+        size_lower = size.lower()
+        if any(term in size_lower for term in ['toy', 'tiny']):
+            return 'toy'
+        elif 'small' in size_lower:
+            return 'small'
+        elif 'medium' in size_lower:
+            return 'medium'
+        elif 'large' in size_lower:
+            return 'large'
+        elif any(term in size_lower for term in ['giant', 'extra large']):
+            return 'giant'
+        else:
+            return 'medium'
+
+    def apply_hard_constraints(self, breed: str, user_input: str, breed_characteristics: Dict[str, Any]) -> float:
+        """增強硬約束，具有更嚴格的懲罰"""
+        penalty = 0.0
+        user_text_lower = user_input.lower()
+
+        # 獲取品種信息
+        breed_info = get_dog_description(breed)
+        if not breed_info:
+            return 0.0
+
+        breed_size = breed_info.get('Size', '').lower()
+        exercise_needs = breed_info.get('Exercise Needs', '').lower()
+
+        # 公寓居住約束 - 更嚴格
+        if any(term in user_text_lower for term in ['apartment', 'flat', 'studio', 'small space']):
+            if 'giant' in breed_size:
+                return -2.0  # 完全淘汰
+            elif 'large' in breed_size:
+                if any(term in exercise_needs for term in ['high', 'very high']):
+                    return -2.0  # 完全淘汰
+                else:
+                    penalty -= 0.5  # 仍有顯著懲罰
+            elif 'medium' in breed_size and 'very high' in exercise_needs:
+                penalty -= 0.6
+
+        # 運動不匹配約束
+        if "don't exercise much" in user_text_lower or "low exercise" in user_text_lower:
+            if any(term in exercise_needs for term in ['very high', 'extreme', 'intense']):
+                return -2.0  # 完全淘汰
+            elif 'high' in exercise_needs:
+                penalty -= 0.8
+
+        # 中等生活方式檢測
+        if any(term in user_text_lower for term in ['moderate', 'balanced', '30 minutes', 'half hour']):
+            # 懲罰極端情況
+            if 'giant' in breed_size:
+                penalty -= 0.7  # 對巨型犬的強懲罰
+            elif 'very high' in exercise_needs:
+                penalty -= 0.5
+
+        # 兒童安全（現有邏輯保持但增強）
+        if any(term in user_text_lower for term in ['child', 'kids', 'family', 'baby']):
+            good_with_children = breed_info.get('Good with Children', '').lower()
+            if good_with_children == 'no':
+                return -2.0  # 為了安全完全淘汰
+
+        return penalty
+
+    def calculate_lifestyle_bonus(self, breed_characteristics: Dict[str, Any],
+                                 lifestyle_keywords: Dict[str, List[str]]) -> float:
+        """增強生活方式匹配獎勵計算"""
+        bonus = 0.0
+        penalties = 0.0
+
+        # 增強尺寸匹配
+        breed_size = breed_characteristics.get('size', '').lower()
+        size_prefs = lifestyle_keywords.get('size_preference', [])
+        for pref in size_prefs:
+            if pref in breed_size:
+                bonus += 0.25  # 尺寸匹配的強獎勵
+            elif (pref == 'small' and 'large' in breed_size) or \
+                 (pref == 'large' and 'small' in breed_size):
+                penalties += 0.15  # 尺寸不匹配的懲罰
+
+        # 增強活動水平匹配
+        breed_exercise = breed_characteristics.get('exercise_needs', '').lower()
+        activity_prefs = lifestyle_keywords.get('activity_level', [])
+
+        if 'high' in activity_prefs:
+            if 'high' in breed_exercise or 'very high' in breed_exercise:
+                bonus += 0.2
+            elif 'low' in breed_exercise:
+                penalties += 0.2
+        elif 'low' in activity_prefs:
+            if 'low' in breed_exercise:
+                bonus += 0.2
+            elif 'high' in breed_exercise or 'very high' in breed_exercise:
+                penalties += 0.25
+        elif 'moderate' in activity_prefs:
+            if 'moderate' in breed_exercise:
+                bonus += 0.15
+
+        # 增強家庭情況匹配
+        good_with_children = breed_characteristics.get('good_with_children', 'Yes')
+        family_prefs = lifestyle_keywords.get('family_situation', [])
+
+        if 'children' in family_prefs:
+            if good_with_children == 'Yes':
+                bonus += 0.15
+            else:
+                penalties += 0.3  # 對非兒童友好品種的強懲罰
+
+        # 增強居住空間匹配
+        living_prefs = lifestyle_keywords.get('living_space', [])
+        if 'apartment' in living_prefs:
+            if 'small' in breed_size:
+                bonus += 0.2
+            elif 'medium' in breed_size and 'low' in breed_exercise:
+                bonus += 0.1
+            elif 'large' in breed_size or 'giant' in breed_size:
+                penalties += 0.2  # 公寓中大型犬的懲罰
+
+        # 噪音偏好匹配
+        noise_prefs = lifestyle_keywords.get('noise_preference', [])
+        temperament = breed_characteristics.get('temperament', '').lower()
+
+        if 'low' in noise_prefs:
+            # 獎勵安靜品種
+            if any(term in temperament for term in ['gentle', 'calm', 'quiet']):
+                bonus += 0.1
+
+        # 照護水平匹配
+        grooming_needs = breed_characteristics.get('grooming_needs', '').lower()
+        care_prefs = lifestyle_keywords.get('care_level', [])
+
+        if 'low' in care_prefs and 'low' in grooming_needs:
+            bonus += 0.1
+        elif 'high' in care_prefs and 'high' in grooming_needs:
+            bonus += 0.1
+        elif 'low' in care_prefs and 'high' in grooming_needs:
+            penalties += 0.15
+
+        # 特殊需求匹配
+        special_needs = lifestyle_keywords.get('special_needs', [])
+
+        if 'guard' in special_needs:
+            if any(term in temperament for term in ['protective', 'alert', 'watchful']):
+                bonus += 0.1
+        elif 'companion' in special_needs:
+            if any(term in temperament for term in ['affectionate', 'gentle', 'loyal']):
+                bonus += 0.1
+
+        # 計算包含懲罰的最終獎勵
+        final_bonus = bonus - penalties
+        return max(-0.3, min(0.5, final_bonus))  # 允許負獎勵但限制範圍
+
+    def apply_intelligent_trait_matching(self, recommendations: List[Dict], user_input: str) -> List[Dict]:
+        """基於增強關鍵字提取和數據庫挖掘應用智能特徵匹配"""
+        try:
+            # 從用戶輸入提取增強關鍵字
+            extracted_keywords = self._extract_enhanced_lifestyle_keywords(user_input)
+
+            # 對每個推薦應用智能特徵匹配
+            enhanced_recommendations = []
+
+            for rec in recommendations:
+                breed_name = rec['breed'].replace(' ', '_')
+
+                # 獲取品種數據庫信息
+                breed_info = get_dog_description(breed_name) or {}
+
+                # 計算智能特徵獎勵
+                intelligence_bonus = 0.0
+                trait_match_details = {}
+
+                # 1. 智力匹配
+                if extracted_keywords.get('intelligence_preference'):
+                    intelligence_pref = extracted_keywords['intelligence_preference'][0]
+                    breed_desc = breed_info.get('Description', '').lower()
+
+                    if intelligence_pref == 'high':
+                        if any(word in breed_desc for word in ['intelligent', 'smart', 'clever', 'quick to learn', 'trainable']):
+                            intelligence_bonus += 0.05
+                            trait_match_details['intelligence_match'] = 'High intelligence match detected'
+                        elif any(word in breed_desc for word in ['stubborn', 'independent', 'difficult']):
+                            intelligence_bonus -= 0.02
+                            trait_match_details['intelligence_warning'] = 'May be challenging to train'
+
+                    elif intelligence_pref == 'independent':
+                        if any(word in breed_desc for word in ['independent', 'stubborn', 'strong-willed']):
+                            intelligence_bonus += 0.03
+                            trait_match_details['independence_match'] = 'Independent nature match'
+
+                # 2. 美容偏好匹配
+                if extracted_keywords.get('grooming_preference'):
+                    grooming_pref = extracted_keywords['grooming_preference'][0]
+                    breed_grooming = breed_info.get('Grooming Needs', '').lower()
+
+                    if grooming_pref == 'low' and 'low' in breed_grooming:
+                        intelligence_bonus += 0.03
+                        trait_match_details['grooming_match'] = 'Low maintenance grooming match'
+                    elif grooming_pref == 'high' and 'high' in breed_grooming:
+                        intelligence_bonus += 0.03
+                        trait_match_details['grooming_match'] = 'High maintenance grooming match'
+                    elif grooming_pref == 'low' and 'high' in breed_grooming:
+                        intelligence_bonus -= 0.04
+                        trait_match_details['grooming_mismatch'] = 'High grooming needs may not suit preferences'
+
+                # 3. 氣質偏好匹配
+                if extracted_keywords.get('temperament_preference'):
+                    temp_prefs = extracted_keywords['temperament_preference']
+                    breed_temperament = breed_info.get('Temperament', '').lower()
+                    breed_desc = breed_info.get('Description', '').lower()
+
+                    temp_text = (breed_temperament + ' ' + breed_desc).lower()
+
+                    for temp_pref in temp_prefs:
+                        if temp_pref == 'gentle' and any(word in temp_text for word in ['gentle', 'calm', 'peaceful', 'mild']):
+                            intelligence_bonus += 0.04
+                            trait_match_details['temperament_match'] = f'Gentle temperament match: {temp_pref}'
+                        elif temp_pref == 'playful' and any(word in temp_text for word in ['playful', 'energetic', 'lively', 'fun']):
+                            intelligence_bonus += 0.04
+                            trait_match_details['temperament_match'] = f'Playful temperament match: {temp_pref}'
+                        elif temp_pref == 'protective' and any(word in temp_text for word in ['protective', 'guard', 'alert', 'watchful']):
+                            intelligence_bonus += 0.04
+                            trait_match_details['temperament_match'] = f'Protective temperament match: {temp_pref}'
+                        elif temp_pref == 'friendly' and any(word in temp_text for word in ['friendly', 'social', 'outgoing', 'people']):
+                            intelligence_bonus += 0.04
+                            trait_match_details['temperament_match'] = f'Friendly temperament match: {temp_pref}'
+
+                # 4. 經驗水平匹配
+                if extracted_keywords.get('experience_level'):
+                    exp_level = extracted_keywords['experience_level'][0]
+                    breed_desc = breed_info.get('Description', '').lower()
+
+                    if exp_level == 'beginner':
+                        # 為初學者偏愛易於處理的品種
+                        if any(word in breed_desc for word in ['easy', 'gentle', 'good for beginners', 'family', 'calm']):
+                            intelligence_bonus += 0.06
+                            trait_match_details['beginner_friendly'] = 'Good choice for first-time owners'
+                        elif any(word in breed_desc for word in ['challenging', 'dominant', 'requires experience', 'strong-willed']):
+                            intelligence_bonus -= 0.08
+                            trait_match_details['experience_warning'] = 'May be challenging for first-time owners'
+
+                    elif exp_level == 'advanced':
+                        # 高級用戶可以處理更具挑戰性的品種
+                        if any(word in breed_desc for word in ['working', 'requires experience', 'intelligent', 'strong']):
+                            intelligence_bonus += 0.03
+                            trait_match_details['advanced_suitable'] = 'Good match for experienced owners'
+
+                # 5. 壽命偏好匹配
+                if extracted_keywords.get('lifespan_preference'):
+                    lifespan_pref = extracted_keywords['lifespan_preference'][0]
+                    breed_lifespan = breed_info.get('Lifespan', '10-12 years')
+
+                    try:
+                        import re
+                        years = re.findall(r'\d+', breed_lifespan)
+                        if years:
+                            avg_years = sum(int(y) for y in years) / len(years)
+                            if lifespan_pref == 'long' and avg_years >= 13:
+                                intelligence_bonus += 0.02
+                                trait_match_details['longevity_match'] = f'Long lifespan match: {breed_lifespan}'
+                            elif lifespan_pref == 'healthy' and avg_years >= 12:
+                                intelligence_bonus += 0.02
+                                trait_match_details['health_match'] = f'Healthy lifespan: {breed_lifespan}'
+                    except:
+                        pass
+
+                # 將智力獎勵應用到總分
+                original_score = rec['overall_score']
+                enhanced_score = min(1.0, original_score + intelligence_bonus)
+
+                # 創建包含特徵匹配詳細信息的增強推薦
+                enhanced_rec = rec.copy()
+                enhanced_rec['overall_score'] = enhanced_score
+                enhanced_rec['intelligence_bonus'] = intelligence_bonus
+                enhanced_rec['trait_match_details'] = trait_match_details
+
+                # 如果發生顯著增強，添加詳細說明
+                if abs(intelligence_bonus) > 0.02:
+                    enhancement_explanation = []
+                    for detail_key, detail_value in trait_match_details.items():
+                        enhancement_explanation.append(detail_value)
+
+                    if enhancement_explanation:
+                        current_explanation = enhanced_rec.get('explanation', '')
+                        enhanced_explanation = current_explanation + f" Enhanced matching: {'; '.join(enhancement_explanation)}"
+                        enhanced_rec['explanation'] = enhanced_explanation
+
+                enhanced_recommendations.append(enhanced_rec)
+
+            # 按增強總分重新排序
+            enhanced_recommendations.sort(key=lambda x: x['overall_score'], reverse=True)
+
+            # 更新排名
+            for i, rec in enumerate(enhanced_recommendations):
+                rec['rank'] = i + 1
+
+            print(f"Applied intelligent trait matching with average bonus: {sum(r['intelligence_bonus'] for r in enhanced_recommendations) / len(enhanced_recommendations):.3f}")
+
+            return enhanced_recommendations
+
+        except Exception as e:
+            print(f"Error in intelligent trait matching: {str(e)}")
+            # 如果特徵匹配失敗，返回原始推薦
+            return recommendations
+
+    def _extract_enhanced_lifestyle_keywords(self, user_input: str) -> Dict[str, List[str]]:
+        """提取增強的生活方式關鍵字（用於智能特徵匹配）"""
+        keywords = {
+            'intelligence_preference': [],
+            'grooming_preference': [],
+            'temperament_preference': [],
+            'experience_level': [],
+            'lifespan_preference': []
+        }
+
+        text = user_input.lower()
+
+        # 智力偏好檢測
+        smart_terms = ['smart', 'intelligent', 'clever', 'bright', 'quick learner', 'easy to train', 'trainable', 'genius', 'brilliant']
+        independent_terms = ['independent', 'stubborn', 'strong-willed', 'less trainable', 'thinks for themselves']
+
+        if any(term in text for term in smart_terms):
+            keywords['intelligence_preference'].append('high')
+        if any(term in text for term in independent_terms):
+            keywords['intelligence_preference'].append('independent')
+
+        # 美容偏好檢測
+        low_grooming_terms = ['low grooming', 'minimal grooming', 'easy care', 'wash and wear', 'no grooming', 'simple coat']
+        high_grooming_terms = ['high grooming', 'professional grooming', 'lots of care', 'high maintenance coat', 'daily brushing', 'regular grooming']
+
+        if any(term in text for term in low_grooming_terms):
+            keywords['grooming_preference'].append('low')
+        if any(term in text for term in high_grooming_terms):
+            keywords['grooming_preference'].append('high')
+
+        # 氣質偏���檢測
+        gentle_terms = ['gentle', 'calm', 'peaceful', 'laid back', 'chill', 'mellow', 'docile']
+        playful_terms = ['playful', 'energetic', 'fun', 'active personality', 'lively', 'spirited', 'bouncy']
+        protective_terms = ['protective', 'guard', 'watchdog', 'alert', 'vigilant', 'defensive']
+        friendly_terms = ['friendly', 'social', 'outgoing', 'loves people', 'sociable', 'gregarious']
+
+        if any(term in text for term in gentle_terms):
+            keywords['temperament_preference'].append('gentle')
+        if any(term in text for term in playful_terms):
+            keywords['temperament_preference'].append('playful')
+        if any(term in text for term in protective_terms):
+            keywords['temperament_preference'].append('protective')
+        if any(term in text for term in friendly_terms):
+            keywords['temperament_preference'].append('friendly')
+
+        # 經驗水平檢測
+        beginner_terms = ['first time', 'beginner', 'new to dogs', 'never had', 'novice', 'inexperienced']
+        advanced_terms = ['experienced', 'advanced', 'dog expert', 'many dogs before', 'professional', 'seasoned']
+
+        if any(term in text for term in beginner_terms):
+            keywords['experience_level'].append('beginner')
+        if any(term in text for term in advanced_terms):
+            keywords['experience_level'].append('advanced')
+
+        # 壽命偏好檢測
+        long_lived_terms = ['long lived', 'long lifespan', 'live long', 'many years', '15+ years', 'longevity']
+        healthy_terms = ['healthy breed', 'few health issues', 'robust', 'hardy', 'strong constitution']
+
+        if any(term in text for term in long_lived_terms):
+            keywords['lifespan_preference'].append('long')
+        if any(term in text for term in healthy_terms):
+            keywords['lifespan_preference'].append('healthy')
+
+        return keywords
+
+    def calculate_enhanced_matching_score(self, breed: str, breed_info: dict, user_description: str, base_similarity: float) -> dict:
+        """計算增強的匹配分數，基於用戶描述和品種特性"""
+        try:
+            user_desc = user_description.lower()
+
+            # 分析用戶需求
+            space_requirements = self._analyze_space_requirements(user_desc)
+            exercise_requirements = self._analyze_exercise_requirements(user_desc)
+            noise_requirements = self._analyze_noise_requirements(user_desc)
+            size_requirements = self._analyze_size_requirements(user_desc)
+            family_requirements = self._analyze_family_requirements(user_desc)
+
+            # 獲取品種特性
+            breed_size = breed_info.get('Size', '').lower()
+            breed_exercise = breed_info.get('Exercise Needs', '').lower()
+            breed_noise = breed_noise_info.get(breed, {}).get('noise_level', 'moderate').lower()
+            breed_temperament = breed_info.get('Temperament', '').lower()
+            breed_good_with_children = breed_info.get('Good with Children', '').lower()
+
+            # 計算各維度匹配分數
+            dimension_scores = {}
+
+            # 空間匹配 (30% 權重)
+            space_score = self._calculate_space_compatibility(space_requirements, breed_size, breed_exercise)
+            dimension_scores['space'] = space_score
+
+            # 運動需求匹配 (25% 權重)
+            exercise_score = self._calculate_exercise_compatibility(exercise_requirements, breed_exercise)
+            dimension_scores['exercise'] = exercise_score
+
+            # 噪音匹配 (20% 權重)
+            noise_score = self._calculate_noise_compatibility(noise_requirements, breed_noise)
+            dimension_scores['noise'] = noise_score
+
+            # 體型匹配 (15% 權重)
+            size_score = self._calculate_size_compatibility(size_requirements, breed_size)
+            dimension_scores['grooming'] = min(0.9, base_similarity + 0.1)  # 美容需求基於語意相似度
+
+            # 家庭相容性 (10% 權重)
+            family_score = self._calculate_family_compatibility(family_requirements, breed_good_with_children, breed_temperament)
+            dimension_scores['family'] = family_score
+            dimension_scores['experience'] = min(0.9, base_similarity + 0.05)  # 經驗需求基於語意相似度
+
+            # 應用硬約束過濾
+            constraint_penalty = self._apply_hard_constraints_enhanced(user_desc, breed_info)
+
+            # 計算加權總分 - 精確化維度權重配置
+            # 根據指導建議重新平衡維度權重
+            weighted_score = (
+                space_score * 0.30 +      # 空間相容性（降低5%）
+                exercise_score * 0.28 +   # 運動需求匹配（降低2%）
+                noise_score * 0.18 +      # 噪音控制（提升3%）
+                family_score * 0.12 +     # 家庭相容性（提升2%）
+                size_score * 0.08 +       # 體型匹配（降低2%）
+                min(0.9, base_similarity + 0.1) * 0.04  # 護理需求（新增獨立���重）
+            )
+
+            # 優化完美匹配獎勵機制 - 降低觸發門檻並增加層次
+            perfect_match_bonus = 0.0
+            if space_score >= 0.88 and exercise_score >= 0.88 and noise_score >= 0.85:
+                perfect_match_bonus = 0.08  # 卓越匹配獎勵
+            elif space_score >= 0.82 and exercise_score >= 0.82 and noise_score >= 0.75:
+                perfect_match_bonus = 0.04  # 優秀匹配獎勵
+            elif space_score >= 0.75 and exercise_score >= 0.75:
+                perfect_match_bonus = 0.02  # 良好匹配獎勵
+
+            # 結合語意相似度與維度匹配 - 調整為75%維度匹配 25%語義相似度
+            base_combined_score = (weighted_score * 0.75 + base_similarity * 0.25) + perfect_match_bonus
+
+            # 應用漸進式約束懲罰，但確保基礎分數保障
+            raw_final_score = base_combined_score + constraint_penalty
+
+            # 實施動態分數保障機制 - 提升至40-42%基礎分數
+            # 根據品種特性動態調整基礎分數
+            base_guaranteed_score = 0.42  # 提升基礎保障分數
+
+            # 特殊品種基礎分數調整
+            high_adaptability_breeds = ['French_Bulldog', 'Pug', 'Golden_Retriever', 'Labrador_Retriever']
+            if any(breed in breed for breed in high_adaptability_breeds):
+                base_guaranteed_score = 0.45  # 高適應性品種更高基礎分數
+
+            # 動態分數分佈優化
+            if raw_final_score >= base_guaranteed_score:
+                # 對於高分品種，實施適度壓縮避免過度集中
+                if raw_final_score > 0.85:
+                    compression_factor = 0.92  # 輕度壓縮高分
+                    final_score = 0.85 + (raw_final_score - 0.85) * compression_factor
+                else:
+                    final_score = raw_final_score
+                final_score = min(0.93, final_score)  # 降低最高分數限制
+            else:
+                # 對於低分品種，使用改進的保障機制
+                normalized_raw_score = max(0.15, raw_final_score)
+                # 基礎保障75% + 實際計算25%，保持一定區分度
+                final_score = base_guaranteed_score * 0.75 + normalized_raw_score * 0.25
+                final_score = max(base_guaranteed_score, min(0.93, final_score))
+
+            lifestyle_bonus = max(0.0, weighted_score - base_similarity)
+
+            return {
+                'final_score': final_score,
+                'weighted_score': weighted_score,
+                'lifestyle_bonus': lifestyle_bonus,
+                'dimension_scores': dimension_scores,
+                'constraint_penalty': constraint_penalty
+            }
+
+        except Exception as e:
+            print(f"Error in enhanced matching calculation for {breed}: {str(e)}")
+            return {
+                'final_score': base_similarity,
+                'weighted_score': base_similarity,
+                'lifestyle_bonus': 0.0,
+                'dimension_scores': {
+                    'space': base_similarity * 0.9,
+                    'exercise': base_similarity * 0.85,
+                    'grooming': base_similarity * 0.8,
+                    'experience': base_similarity * 0.75,
+                    'noise': base_similarity * 0.7,
+                    'family': base_similarity * 0.65
+                },
+                'constraint_penalty': 0.0
+            }
+
+    def _analyze_space_requirements(self, user_desc: str) -> dict:
+        """分析空間需求 - 增強中等活動量識別"""
+        requirements = {'type': 'unknown', 'size': 'medium', 'importance': 0.5}
+
+        if any(word in user_desc for word in ['apartment', 'small apartment', 'small space', 'condo', 'flat']):
+            requirements['type'] = 'apartment'
+            requirements['size'] = 'small'
+            requirements['importance'] = 0.95  # 提高重要性
+        elif any(word in user_desc for word in ['medium-sized house', 'medium house', 'townhouse']):
+            requirements['type'] = 'medium_house'
+            requirements['size'] = 'medium'
+            requirements['importance'] = 0.8  # 中等活動量用戶的特殊標記
+        elif any(word in user_desc for word in ['large house', 'big house', 'yard', 'garden', 'large space', 'backyard']):
+            requirements['type'] = 'house'
+            requirements['size'] = 'large'
+            requirements['importance'] = 0.7
+
+        return requirements
+
+    def _analyze_exercise_requirements(self, user_desc: str) -> dict:
+        """分析運動需求 - 增強中等活動量識別"""
+        requirements = {'level': 'moderate', 'importance': 0.5}
+
+        # 低運動量識別
+        if any(word in user_desc for word in ["don't exercise", "don't exercise much", "low exercise", "minimal", "lazy", "not active"]):
+            requirements['level'] = 'low'
+            requirements['importance'] = 0.95
+        # 中等運動量的精確識別
+        elif any(phrase in user_desc for phrase in ['30 minutes', 'half hour', 'moderate', 'balanced', 'walk about']):
+            if 'walk' in user_desc or 'daily' in user_desc:
+                requirements['level'] = 'moderate'
+                requirements['importance'] = 0.85  # 中等活動量的特殊標記
+        # 高運動量識別
+        elif any(word in user_desc for word in ['active', 'hiking', 'outdoor activities', 'running', 'outdoors', 'love hiking']):
+            requirements['level'] = 'high'
+            requirements['importance'] = 0.9
+
+        return requirements
+
+    def _analyze_noise_requirements(self, user_desc: str) -> dict:
+        """分析噪音需求"""
+        requirements = {'tolerance': 'medium', 'importance': 0.5}
+
+        if any(word in user_desc for word in ['quiet', 'no bark', "won't bark", "doesn't bark", 'silent', 'peaceful']):
+            requirements['tolerance'] = 'low'
+            requirements['importance'] = 0.9
+        elif any(word in user_desc for word in ['loud', 'barking ok', 'noise ok']):
+            requirements['tolerance'] = 'high'
+            requirements['importance'] = 0.7
+
+        return requirements
+
+    def _analyze_size_requirements(self, user_desc: str) -> dict:
+        """分析體型需求"""
+        requirements = {'preferred': 'any', 'importance': 0.5}
+
+        if any(word in user_desc for word in ['small', 'tiny', 'little', 'lap dog', 'compact']):
+            requirements['preferred'] = 'small'
+            requirements['importance'] = 0.8
+        elif any(word in user_desc for word in ['large', 'big', 'giant']):
+            requirements['preferred'] = 'large'
+            requirements['importance'] = 0.8
+
+        return requirements
+
+    def _analyze_family_requirements(self, user_desc: str) -> dict:
+        """分析家庭需求"""
+        requirements = {'children': False, 'importance': 0.3}
+
+        if any(word in user_desc for word in ['children', 'kids', 'family', 'child']):
+            requirements['children'] = True
+            requirements['importance'] = 0.8
+
+        return requirements
+
+    def _calculate_space_compatibility(self, space_req: dict, breed_size: str, breed_exercise: str) -> float:
+        """計算空間相容性分數 - 增強中等活動量處理"""
+        if space_req['type'] == 'apartment':
+            if 'small' in breed_size or 'toy' in breed_size:
+                base_score = 0.95
+            elif 'medium' in breed_size:
+                if 'low' in breed_exercise:
+                    base_score = 0.75
+                else:
+                    base_score = 0.45  # 降低中型犬在公寓的分數
+            elif 'large' in breed_size:
+                base_score = 0.05  # 大型犬極度不適合公寓
+            elif 'giant' in breed_size:
+                base_score = 0.01  # 超大型犬完全不適合公寓
+            else:
+                base_score = 0.7
+        elif space_req['type'] == 'medium_house':
+            # 中型房屋的特殊處理 - 適合中等活動量用戶
+            if 'small' in breed_size or 'toy' in breed_size:
+                base_score = 0.9
+            elif 'medium' in breed_size:
+                base_score = 0.95  # 中型犬在中型房屋很適合
+            elif 'large' in breed_size:
+                if 'moderate' in breed_exercise or 'low' in breed_exercise:
+                    base_score = 0.8  # 低運動量大型犬還可以
+                else:
+                    base_score = 0.6  # 高運動量大型犬不太適合
+            elif 'giant' in breed_size:
+                base_score = 0.3  # 超大型犬在中型房屋不太適合
+            else:
+                base_score = 0.85
+        else:
+            # 大型房屋的情況
+            if 'small' in breed_size or 'toy' in breed_size:
+                base_score = 0.85
+            elif 'medium' in breed_size:
+                base_score = 0.9
+            elif 'large' in breed_size or 'giant' in breed_size:
+                base_score = 0.95
+            else:
+                base_score = 0.8
+
+        return min(0.95, base_score)
+
+    def _calculate_exercise_compatibility(self, exercise_req: dict, breed_exercise: str) -> float:
+        """計算運動需求相容性分數 - 增強中等活動量處理"""
+        if exercise_req['level'] == 'low':
+            if 'low' in breed_exercise or 'minimal' in breed_exercise:
+                return 0.95
+            elif 'moderate' in breed_exercise:
+                return 0.5  # 降低不匹配分數
+            elif 'high' in breed_exercise:
+                return 0.1  # 進一步降低高運動需求的匹配
+            else:
+                return 0.7
+        elif exercise_req['level'] == 'high':
+            if 'high' in breed_exercise:
+                return 0.95
+            elif 'moderate' in breed_exercise:
+                return 0.8
+            elif 'low' in breed_exercise:
+                return 0.6
+            else:
+                return 0.7
+        else:  # moderate - 中等活動量的精確處理
+            if 'moderate' in breed_exercise:
+                return 0.95  # 完美匹配
+            elif 'low' in breed_exercise:
+                return 0.85  # 低運動需求的品種對中等活動量用戶也不錯
+            elif 'high' in breed_exercise:
+                return 0.5  # 中等活動量用戶不太適合高運動需求品種
+            else:
+                return 0.75
+
+        return 0.6
+
+    def _calculate_noise_compatibility(self, noise_req: dict, breed_noise: str) -> float:
+        """計算噪音相容性分數，更好處理複合等級"""
+        breed_noise_lower = breed_noise.lower()
+
+        if noise_req['tolerance'] == 'low':
+            if 'low' in breed_noise_lower and 'moderate' not in breed_noise_lower:
+                return 0.95  # 純低噪音
+            elif 'low-moderate' in breed_noise_lower or 'low to moderate' in breed_noise_lower:
+                return 0.8   # 低到中等噪音，還可接受
+            elif breed_noise_lower in ['moderate']:
+                return 0.4   # 中等噪音有些問題
+            elif 'high' in breed_noise_lower:
+                return 0.1   # 高噪音不適合
+            else:
+                return 0.6   # 未知噪音水平，保守估計
+        elif noise_req['tolerance'] == 'high':
+            if 'high' in breed_noise_lower:
+                return 0.9
+            elif 'moderate' in breed_noise_lower:
+                return 0.85
+            elif 'low' in breed_noise_lower:
+                return 0.8   # 安靜犬對高容忍度的人也很好
+            else:
+                return 0.8
+        else:  # moderate tolerance
+            if 'moderate' in breed_noise_lower:
+                return 0.9
+            elif 'low' in breed_noise_lower:
+                return 0.85
+            elif 'high' in breed_noise_lower:
+                return 0.6
+            else:
+                return 0.75
+
+        return 0.7
+
+    def _calculate_size_compatibility(self, size_req: dict, breed_size: str) -> float:
+        """計算體型相容性分數"""
+        if size_req['preferred'] == 'small':
+            if any(word in breed_size for word in ['small', 'toy', 'tiny']):
+                return 0.9
+            elif 'medium' in breed_size:
+                return 0.6
+            else:
+                return 0.3
+        elif size_req['preferred'] == 'large':
+            if any(word in breed_size for word in ['large', 'giant']):
+                return 0.9
+            elif 'medium' in breed_size:
+                return 0.7
+            else:
+                return 0.4
+
+        return 0.7  # 無特別偏好
+
+    def _calculate_family_compatibility(self, family_req: dict, good_with_children: str, temperament: str) -> float:
+        """計算家庭相容性分數"""
+        if family_req['children']:
+            if 'yes' in good_with_children.lower():
+                return 0.9
+            elif any(word in temperament for word in ['gentle', 'patient', 'friendly']):
+                return 0.8
+            elif 'no' in good_with_children.lower():
+                return 0.2
+            else:
+                return 0.6
+
+        return 0.7
+
+    def _apply_hard_constraints_enhanced(self, user_desc: str, breed_info: dict) -> float:
+        """應用品種特性感知的動態懲罰機制"""
+        penalty = 0.0
+
+        # 建立懲罰衰減係數和補償機制
+        penalty_decay_factor = 0.7
+        breed_adaptability_bonus = 0.0
+        breed_size = breed_info.get('Size', '').lower()
+        breed_exercise = breed_info.get('Exercise Needs', '').lower()
+        breed_name = breed_info.get('Breed', '').replace(' ', '_')
+
+        # 公寓空間約束 - 品種特性感知懲罰機制
+        if 'apartment' in user_desc or 'small apartment' in user_desc:
+            if 'giant' in breed_size:
+                base_penalty = -0.35  # 減少基礎懲罰
+                # 特定品種適應性補償
+                adaptable_giants = ['Mastiff', 'Great Dane']  # 相對安靜的巨型犬
+                if any(adapt_breed in breed_name for adapt_breed in adaptable_giants):
+                    breed_adaptability_bonus += 0.08
+                penalty += base_penalty * penalty_decay_factor
+            elif 'large' in breed_size:
+                base_penalty = -0.25  # 減少大型犬懲罰
+                # 適合公寓的大型犬補償
+                apartment_friendly_large = ['Greyhound', 'Great_Dane']
+                if any(apt_breed in breed_name for apt_breed in apartment_friendly_large):
+                    breed_adaptability_bonus += 0.06
+                penalty += base_penalty * penalty_decay_factor
+            elif 'medium' in breed_size and 'high' in breed_exercise:
+                penalty += -0.15 * penalty_decay_factor  # 進一步減少懲罰
+
+        # 運動需求不匹配 - 品種特性感知懲罰機制
+        if any(phrase in user_desc for phrase in ["don't exercise", "not active", "low exercise", "don't exercise much"]):
+            if 'high' in breed_exercise:
+                base_penalty = -0.28  # 減少基礎懲罰
+                # 低維護高運動犬種補償
+                adaptable_high_energy = ['Greyhound', 'Whippet']  # 運動爆發型，平時安靜
+                if any(adapt_breed in breed_name for adapt_breed in adaptable_high_energy):
+                    breed_adaptability_bonus += 0.10
+                penalty += base_penalty * penalty_decay_factor
+            elif 'moderate' in breed_exercise:
+                penalty += -0.08 * penalty_decay_factor  # 進一步減少懲罰
+
+        # 噪音控制需求不匹配 - 品種特性感知懲罰機制
+        if any(phrase in user_desc for phrase in ['quiet', "won't bark", "doesn't bark", "silent"]):
+            breed_noise = breed_noise_info.get(breed_name, {}).get('noise_level', 'moderate').lower()
+            if 'high' in breed_noise:
+                base_penalty = -0.18  # 減少基礎懲罰
+                # 訓練性良好的高噪音品種補償
+                trainable_vocal_breeds = ['German_Shepherd', 'Golden_Retriever']
+                if any(train_breed in breed_name for train_breed in trainable_vocal_breeds):
+                    breed_adaptability_bonus += 0.05
+                penalty += base_penalty * penalty_decay_factor
+            elif 'moderate' in breed_noise and 'low' not in breed_noise:
+                penalty += -0.05 * penalty_decay_factor
+
+        # 體型偏好不匹配 - 漸進式懲罰
+        if any(phrase in user_desc for phrase in ['small', 'tiny', 'little']):
+            if 'giant' in breed_size:
+                penalty -= 0.35  # 超大型犬懲罰
+            elif 'large' in breed_size:
+                penalty -= 0.20  # 大型犬懲罰
+
+        # 中等活動量用戶的特殊約束處理 - 漸進式懲罰
+        moderate_activity_terms = ['30 minutes', 'half hour', 'moderate', 'balanced', 'medium-sized house']
+        if any(term in user_desc for term in moderate_activity_terms):
+            # 超大型犬對中等活動量用戶的適度懲罰
+            giant_breeds = ['Saint Bernard', 'Tibetan Mastiff', 'Great Dane', 'Mastiff', 'Newfoundland']
+            if any(giant in breed_name for giant in giant_breeds) or 'giant' in breed_size:
+                penalty -= 0.35  # 適度懲罰，不完全排除
+
+            # 中型房屋 + 超大型犬的額外考量
+            if 'medium-sized house' in user_desc and any(giant in breed_name for giant in giant_breeds):
+                if not any(high_activity in user_desc for high_activity in ['hiking', 'running', 'active', 'outdoor activities']):
+                    penalty -= 0.15  # 輕度額外懲罰
+
+        # 30分鐘散步對極高運動需求品種的懲罰
+        if any(term in user_desc for term in ['30 minutes', 'half hour']) and 'walk' in user_desc:
+            high_energy_breeds = ['Siberian Husky', 'Border Collie', 'Jack Russell Terrier', 'Weimaraner']
+            if any(he_breed in breed_name for he_breed in high_energy_breeds) and 'high' in breed_exercise:
+                penalty -= 0.25  # 適度懲罰極高運動需求品種
+
+        # 添加特殊品種適應性補償機制
+        # 對於邊界適配品種，給予適度補償
+        boundary_adaptable_breeds = {
+            'Italian_Greyhound': 0.08,  # 安靜、低維護的小型犬
+            'Boston_Bull': 0.06,        # 適應性強的小型犬
+            'Havanese': 0.05,           # 友好適應的小型犬
+            'Silky_terrier': 0.04,      # 安靜的玩具犬
+            'Basset': 0.07              # 低能量但友好的中型犬
+        }
+
+        if breed_name in boundary_adaptable_breeds:
+            breed_adaptability_bonus += boundary_adaptable_breeds[breed_name]
+
+        # 應用品種適應性補償並設置懲罰上限
+        final_penalty = penalty + breed_adaptability_bonus
+        # 限制最大懲罰，避免單一約束主導評分
+        final_penalty = max(-0.4, final_penalty)
+
+        return final_penalty
+
+    def get_breed_characteristics_enhanced(self, breed: str) -> Dict[str, Any]:
+        """獲取品種特徵"""
+        breed_info = get_dog_description(breed)
+        if not breed_info:
+            return {}
+
+        characteristics = {
+            'size': breed_info.get('Size', 'Unknown'),
+            'temperament': breed_info.get('Temperament', ''),
+            'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'),
+            'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'),
+            'good_with_children': breed_info.get('Good with Children', 'Unknown'),
+            'lifespan': breed_info.get('Lifespan', '10-12 years'),
+            'description': breed_info.get('Description', '')
+        }
+
+        # 添加噪音資訊
+        noise_info = breed_noise_info.get(breed, {})
+        characteristics['noise_level'] = noise_info.get('noise_level', 'moderate')
+
+        return characteristics
+
+    def get_breed_info_from_standardized(self, standardized_info) -> Dict[str, Any]:
+        """將標準化品種信息轉換為字典���式"""
+        try:
+            size_map = {1: 'Tiny', 2: 'Small', 3: 'Medium', 4: 'Large', 5: 'Giant'}
+            exercise_map = {1: 'Low', 2: 'Moderate', 3: 'High', 4: 'Very High'}
+            care_map = {1: 'Low', 2: 'Moderate', 3: 'High'}
+
+            return {
+                'Size': size_map.get(standardized_info.size_category, 'Medium'),
+                'Exercise Needs': exercise_map.get(standardized_info.exercise_level, 'Moderate'),
+                'Grooming Needs': care_map.get(standardized_info.care_complexity, 'Moderate'),
+                'Good with Children': 'Yes' if standardized_info.child_compatibility >= 0.8 else
+                                     'No' if standardized_info.child_compatibility <= 0.2 else 'Unknown',
+                'Temperament': 'Varies by individual',
+                'Lifespan': '10-12 years',
+                'Description': f'A {size_map.get(standardized_info.size_category, "medium")} sized breed'
+            }
+        except Exception as e:
+            print(f"Error converting standardized info: {str(e)}")
+            return {}
+
+    def get_fallback_recommendations(self, top_k: int = 15) -> List[Dict[str, Any]]:
+        """當增強系統失敗時獲取備用推薦"""
+        try:
+            safe_breeds = [
+                ('Labrador Retriever', 0.85),
+                ('Golden Retriever', 0.82),
+                ('Cavalier King Charles Spaniel', 0.80),
+                ('French Bulldog', 0.78),
+                ('Boston Terrier', 0.76),
+                ('Bichon Frise', 0.74),
+                ('Pug', 0.72),
+                ('Cocker Spaniel', 0.70)
+            ]
+
+            recommendations = []
+            for i, (breed, score) in enumerate(safe_breeds[:top_k]):
+                breed_info = get_dog_description(breed.replace(' ', '_')) or {}
+
+                recommendation = {
+                    'breed': breed,
+                    'rank': i + 1,
+                    'overall_score': score,
+                    'final_score': score,
+                    'semantic_score': score * 0.8,
+                    'comparative_bonus': 0.0,
+                    'lifestyle_bonus': 0.0,
+                    'size': breed_info.get('Size', 'Unknown'),
+                    'temperament': breed_info.get('Temperament', ''),
+                    'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'),
+                    'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'),
+                    'good_with_children': breed_info.get('Good with Children', 'Yes'),
+                    'lifespan': breed_info.get('Lifespan', '10-12 years'),
+                    'description': breed_info.get('Description', ''),
+                    'search_type': 'fallback'
+                }
+                recommendations.append(recommendation)
+
+            return recommendations
+
+        except Exception as e:
+            print(f"Error generating fallback recommendations: {str(e)}")
+            return []

recommendation_formatter.py

@@ -28,6 +28,10 @@ def get_breed_recommendations(user_prefs: UserPreferences, top_n: int = 15) -> L
             breed = breed_tuple[0]
             base_breed = breed.split('(')[0].strip()
 
+            # 過濾掉野生動物品種
+            if base_breed == 'Dhole':
+                continue
+
             if base_breed in seen_breeds:
                 continue
             seen_breeds.add(base_breed)
@@ -127,7 +131,7 @@ def get_breed_recommendations(user_prefs: UserPreferences, top_n: int = 15) -> L
 
         print(f"Breeds after filtering: {len(recommendations)}")
 
-        # 嚴格按照 final_score 排序
+        # 按照 final_score 排序
         recommendations.sort(key=lambda x: (round(-x['final_score'], 4), x['breed']))
 
         # 修正後的推薦選擇邏輯，移除有問題的分數比較

semantic_vector_manager.py

@@ -0,0 +1,385 @@
+import random
+import hashlib
+import numpy as np
+import sqlite3
+import re
+import traceback
+from typing import List, Dict, Tuple, Optional, Any
+from dataclasses import dataclass
+from sentence_transformers import SentenceTransformer
+import torch
+from sklearn.metrics.pairwise import cosine_similarity
+from dog_database import get_dog_description
+from breed_health_info import breed_health_info
+from breed_noise_info import breed_noise_info
+
+@dataclass
+class BreedDescriptionVector:
+    """品種描述向量的資料結構"""
+    breed_name: str
+    description_text: str
+    embedding: np.ndarray
+    characteristics: Dict[str, Any]
+
+class SemanticVectorManager:
+    """
+    語義向量管理器
+    處理 SBERT 模型初始化、品種向量化建構和品種描述生成
+    """
+
+    def __init__(self):
+        """初始化語義向量管理器"""
+        self.model_name = 'all-MiniLM-L6-v2'  
+        self.sbert_model = None
+        self._sbert_loading_attempted = False
+        self.breed_vectors = {}
+        self.breed_list = self._get_breed_list()
+        # 延遲SBERT模型載入直到需要時才在GPU環境中進行
+        print("SemanticVectorManager initialized (SBERT loading deferred)")
+
+    def _get_breed_list(self) -> List[str]:
+        """從資料庫獲取品種清單"""
+        try:
+            conn = sqlite3.connect('animal_detector.db')
+            cursor = conn.cursor()
+            cursor.execute("SELECT DISTINCT Breed FROM AnimalCatalog")
+            breeds = [row[0] for row in cursor.fetchall()]
+            cursor.close()
+            conn.close()
+            # 過濾掉野生動物品種
+            breeds = [breed for breed in breeds if breed != 'Dhole']
+            return breeds
+        except Exception as e:
+            print(f"Error getting breed list: {str(e)}")
+            return ['Labrador_Retriever', 'German_Shepherd', 'Golden_Retriever',
+                   'Bulldog', 'Poodle', 'Beagle', 'Rottweiler', 'Yorkshire_Terrier']
+
+    def _initialize_model(self):
+        """初始化 SBERT 模型，包含容錯機制 - 設計用於ZeroGPU相容性"""
+        if self.sbert_model is not None or self._sbert_loading_attempted:
+            return self.sbert_model
+            
+        try:
+            print("Loading SBERT model in GPU context...")
+            # 如果主要模型失敗，嘗試不同的模型名稱
+            model_options = ['all-MiniLM-L6-v2', 'all-mpnet-base-v2', 'all-MiniLM-L12-v2']
+
+            for model_name in model_options:
+                try:
+                    # 明確指定設備以處理ZeroGPU環境
+                    import torch
+                    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+                    self.sbert_model = SentenceTransformer(model_name, device=device)
+                    self.model_name = model_name
+                    print(f"SBERT model {model_name} loaded successfully on {device}")
+                    return self.sbert_model
+                except Exception as model_e:
+                    print(f"Failed to load {model_name}: {str(model_e)}")
+                    continue
+
+            # 如果所有模型都失敗
+            print("All SBERT models failed to load. Using basic text matching fallback.")
+            self.sbert_model = None
+            return None
+
+        except Exception as e:
+            print(f"Failed to initialize any SBERT model: {str(e)}")
+            print(traceback.format_exc())
+            print("Will provide basic text-based recommendations without embeddings")
+            self.sbert_model = None
+            return None
+        finally:
+            self._sbert_loading_attempted = True
+
+    def _create_breed_description(self, breed: str) -> str:
+        """為品種創建包含所有關鍵特徵的全面自然語言描述"""
+        try:
+            # 獲取所有信息來源
+            breed_info = get_dog_description(breed) or {}
+            health_info = breed_health_info.get(breed, {}) if breed_health_info else {}
+            noise_info = breed_noise_info.get(breed, {}) if breed_noise_info else {}
+
+            breed_display_name = breed.replace('_', ' ')
+            description_parts = []
+
+            # 1. 基本尺寸和身體特徵
+            size = breed_info.get('Size', 'medium').lower()
+            description_parts.append(f"{breed_display_name} is a {size} sized dog breed")
+
+            # 2. 氣質和個性（匹配的關鍵因素）
+            temperament = breed_info.get('Temperament', '')
+            if temperament:
+                description_parts.append(f"with a {temperament.lower()} temperament")
+
+            # 3. 運動和活動水平（公寓居住的關鍵因素）
+            exercise_needs = breed_info.get('Exercise Needs', 'moderate').lower()
+            if 'high' in exercise_needs or 'very high' in exercise_needs:
+                description_parts.append("requiring high daily exercise and mental stimulation")
+            elif 'low' in exercise_needs or 'minimal' in exercise_needs:
+                description_parts.append("with minimal exercise requirements, suitable for apartment living")
+            else:
+                description_parts.append("with moderate exercise needs")
+
+            # 4. 噪音特徵（安靜需求的關鍵因素）
+            noise_level = noise_info.get('noise_level', 'moderate').lower()
+            if 'low' in noise_level or 'quiet' in noise_level:
+                description_parts.append("known for being quiet and rarely barking")
+            elif 'high' in noise_level or 'loud' in noise_level:
+                description_parts.append("tends to be vocal and bark frequently")
+            else:
+                description_parts.append("with moderate barking tendencies")
+
+            # 5. 居住空間相容性
+            if size in ['small', 'tiny']:
+                description_parts.append("excellent for small apartments and limited spaces")
+            elif size in ['large', 'giant']:
+                description_parts.append("requiring large living spaces and preferably a yard")
+            else:
+                description_parts.append("adaptable to various living situations")
+
+            # 6. 美容和維護
+            grooming_needs = breed_info.get('Grooming Needs', 'moderate').lower()
+            if 'high' in grooming_needs:
+                description_parts.append("requiring regular professional grooming")
+            elif 'low' in grooming_needs:
+                description_parts.append("with minimal grooming requirements")
+            else:
+                description_parts.append("with moderate grooming needs")
+
+            # 7. 家庭相容性
+            good_with_children = breed_info.get('Good with Children', 'Yes')
+            if good_with_children == 'Yes':
+                description_parts.append("excellent with children and families")
+            else:
+                description_parts.append("better suited for adult households")
+
+            # 8. 智力和可訓練性（從資料庫描述中提取）
+            intelligence_keywords = []
+            description_text = breed_info.get('Description', '').lower()
+
+            if description_text:
+                # 從描述中提取智力指標
+                if any(word in description_text for word in ['intelligent', 'smart', 'clever', 'quick to learn']):
+                    intelligence_keywords.extend(['highly intelligent', 'trainable', 'quick learner'])
+                elif any(word in description_text for word in ['stubborn', 'independent', 'difficult to train']):
+                    intelligence_keywords.extend(['independent minded', 'requires patience', 'challenging to train'])
+                else:
+                    intelligence_keywords.extend(['moderate intelligence', 'trainable with consistency'])
+
+                # 從描述中提取工作/用途特徵
+                if any(word in description_text for word in ['working', 'herding', 'guard', 'hunting']):
+                    intelligence_keywords.extend(['working breed', 'purpose-driven', 'task-oriented'])
+                elif any(word in description_text for word in ['companion', 'lap', 'toy', 'decorative']):
+                    intelligence_keywords.extend(['companion breed', 'affectionate', 'people-focused'])
+
+                # 添加智力背景到描述中
+                if intelligence_keywords:
+                    description_parts.append(f"characterized as {', '.join(intelligence_keywords[:2])}")
+
+            # 9. 特殊特徵和用途（使用資料庫挖掘進行增強）
+            if breed_info.get('Description'):
+                desc = breed_info.get('Description', '')[:150]  # 增加到 150 字元以提供更多背景
+                if desc:
+                    # 從描述中提取關鍵特徵以便更好的語義匹配
+                    desc_lower = desc.lower()
+                    key_traits = []
+
+                    # 從描述中提取關鍵行為特徵
+                    if 'friendly' in desc_lower:
+                        key_traits.append('friendly')
+                    if 'gentle' in desc_lower:
+                        key_traits.append('gentle')
+                    if 'energetic' in desc_lower or 'active' in desc_lower:
+                        key_traits.append('energetic')
+                    if 'calm' in desc_lower or 'peaceful' in desc_lower:
+                        key_traits.append('calm')
+                    if 'protective' in desc_lower or 'guard' in desc_lower:
+                        key_traits.append('protective')
+
+                    trait_text = f" and {', '.join(key_traits)}" if key_traits else ""
+                    description_parts.append(f"Known for: {desc.lower()}{trait_text}")
+
+            # 10. 照護水平需求
+            try:
+                care_level = breed_info.get('Care Level', 'moderate')
+                if isinstance(care_level, str):
+                    description_parts.append(f"requiring {care_level.lower()} overall care level")
+                else:
+                    description_parts.append("requiring moderate overall care level")
+            except Exception as e:
+                print(f"Error processing care level for {breed}: {str(e)}")
+                description_parts.append("requiring moderate overall care level")
+
+            # 11. 壽命資訊
+            try:
+                lifespan = breed_info.get('Lifespan', '10-12 years')
+                if lifespan and isinstance(lifespan, str) and lifespan.strip():
+                    description_parts.append(f"with a typical lifespan of {lifespan}")
+                else:
+                    description_parts.append("with a typical lifespan of 10-12 years")
+            except Exception as e:
+                print(f"Error processing lifespan for {breed}: {str(e)}")
+                description_parts.append("with a typical lifespan of 10-12 years")
+
+            # 創建全面的描述
+            full_description = '. '.join(description_parts) + '.'
+
+            # 添加全面的關鍵字以便更好的語義匹配
+            keywords = []
+
+            # 基本品種名稱關鍵字
+            keywords.extend([word.lower() for word in breed_display_name.split()])
+
+            # 氣質關鍵字
+            if temperament:
+                keywords.extend([word.lower().strip(',') for word in temperament.split()])
+
+            # 基於尺寸的關鍵字
+            if 'small' in size or 'tiny' in size:
+                keywords.extend(['small', 'tiny', 'compact', 'little', 'apartment', 'indoor', 'lap'])
+            elif 'large' in size or 'giant' in size:
+                keywords.extend(['large', 'big', 'giant', 'huge', 'yard', 'space', 'outdoor'])
+            else:
+                keywords.extend(['medium', 'moderate', 'average', 'balanced'])
+
+            # 活動水平關鍵字
+            exercise_needs = breed_info.get('Exercise Needs', 'moderate').lower()
+            if 'high' in exercise_needs:
+                keywords.extend(['active', 'energetic', 'exercise', 'outdoor', 'hiking', 'running', 'athletic'])
+            elif 'low' in exercise_needs:
+                keywords.extend(['calm', 'low-energy', 'indoor', 'relaxed', 'couch', 'sedentary'])
+            else:
+                keywords.extend(['moderate', 'balanced', 'walks', 'regular'])
+
+            # 噪音水平關鍵字
+            noise_level = noise_info.get('noise_level', 'moderate').lower()
+            if 'quiet' in noise_level or 'low' in noise_level:
+                keywords.extend(['quiet', 'silent', 'calm', 'peaceful', 'low-noise'])
+            elif 'high' in noise_level or 'loud' in noise_level:
+                keywords.extend(['vocal', 'barking', 'loud', 'alert', 'watchdog'])
+
+            # 居住情況關鍵字
+            if size in ['small', 'tiny'] and 'low' in exercise_needs:
+                keywords.extend(['apartment', 'city', 'urban', 'small-space'])
+            if size in ['large', 'giant'] or 'high' in exercise_needs:
+                keywords.extend(['house', 'yard', 'suburban', 'rural', 'space'])
+
+            # 家庭關鍵字
+            good_with_children = breed_info.get('Good with Children', 'Yes')
+            if good_with_children == 'Yes':
+                keywords.extend(['family', 'children', 'kids', 'friendly', 'gentle'])
+
+            # 智力和可訓練性關鍵字（從資料庫描述挖掘）
+            if intelligence_keywords:
+                keywords.extend([word.lower() for phrase in intelligence_keywords for word in phrase.split()])
+
+            # 美容相關關鍵字（增強）
+            grooming_needs = breed_info.get('Grooming Needs', 'moderate').lower()
+            if 'high' in grooming_needs:
+                keywords.extend(['high-maintenance', 'professional-grooming', 'daily-brushing', 'coat-care'])
+            elif 'low' in grooming_needs:
+                keywords.extend(['low-maintenance', 'minimal-grooming', 'easy-care', 'wash-and-go'])
+            else:
+                keywords.extend(['moderate-grooming', 'weekly-brushing', 'regular-care'])
+
+            # 基於壽命的關鍵字
+            lifespan = breed_info.get('Lifespan', '10-12 years')
+            if lifespan and isinstance(lifespan, str):
+                try:
+                    # 從壽命字符串中提取年數（例如 "10-12 years" 或 "12-15 years"）
+                    import re
+                    years = re.findall(r'\d+', lifespan)
+                    if years:
+                        avg_years = sum(int(y) for y in years) / len(years)
+                        if avg_years >= 14:
+                            keywords.extend(['long-lived', 'longevity', 'durable', 'healthy-lifespan'])
+                        elif avg_years <= 8:
+                            keywords.extend(['shorter-lifespan', 'health-considerations', 'special-care'])
+                        else:
+                            keywords.extend(['average-lifespan', 'moderate-longevity'])
+                except:
+                    keywords.extend(['average-lifespan'])
+
+            # 將關鍵字添加到描述中���便更好的語義匹配
+            unique_keywords = list(set(keywords))
+            keyword_text = ' '.join(unique_keywords)
+            full_description += f" Additional context: {keyword_text}"
+
+            return full_description
+
+        except Exception as e:
+            print(f"Error creating description for {breed}: {str(e)}")
+            return f"{breed.replace('_', ' ')} is a dog breed with unique characteristics."
+
+    def _build_breed_vectors(self):
+        """為所有品種建立向量表示 - 延遲調用當需要時"""
+        try:
+            print("Building breed vector database...")
+
+            # 初始化模型如果尚未完成
+            if self.sbert_model is None:
+                self._initialize_model()
+                
+            # 如果模型不可用則跳過
+            if self.sbert_model is None:
+                print("SBERT model not available, skipping vector building")
+                return
+
+            for breed in self.breed_list:
+                description = self._create_breed_description(breed)
+
+                # 生成嵌入向量
+                embedding = self.sbert_model.encode(description, convert_to_tensor=False)
+
+                # 獲取品種特徵
+                breed_info = get_dog_description(breed)
+                characteristics = {
+                    'size': breed_info.get('Size', 'Medium') if breed_info else 'Medium',
+                    'exercise_needs': breed_info.get('Exercise Needs', 'Moderate') if breed_info else 'Moderate',
+                    'grooming_needs': breed_info.get('Grooming Needs', 'Moderate') if breed_info else 'Moderate',
+                    'good_with_children': breed_info.get('Good with Children', 'Yes') if breed_info else 'Yes',
+                    'temperament': breed_info.get('Temperament', '') if breed_info else ''
+                }
+
+                self.breed_vectors[breed] = BreedDescriptionVector(
+                    breed_name=breed,
+                    description_text=description,
+                    embedding=embedding,
+                    characteristics=characteristics
+                )
+
+            print(f"Successfully built {len(self.breed_vectors)} breed vectors")
+
+        except Exception as e:
+            print(f"Error building breed vectors: {str(e)}")
+            print(traceback.format_exc())
+            raise
+
+    def get_breed_vectors(self) -> Dict[str, BreedDescriptionVector]:
+        """獲取所有品種向量"""
+        # 確保向量已建構
+        if not self.breed_vectors:
+            self._build_breed_vectors()
+        return self.breed_vectors
+
+    def get_sbert_model(self) -> Optional[SentenceTransformer]:
+        """獲取 SBERT 模型"""
+        return self.sbert_model
+
+    def get_breed_list(self) -> List[str]:
+        """獲取品種清單"""
+        return self.breed_list
+
+    def is_model_available(self) -> bool:
+        """檢查 SBERT 模型是否可用"""
+        return self.sbert_model is not None
+
+    def encode_text(self, text: str) -> np.ndarray:
+        """使用 SBERT 模型編碼文本"""
+        # 初始化模型如果尚未完成
+        if self.sbert_model is None:
+            self._initialize_model()
+            
+        if self.sbert_model is None:
+            raise RuntimeError("SBERT model not available")
+        return self.sbert_model.encode(text, convert_to_tensor=False)

user_query_analyzer.py

@@ -0,0 +1,511 @@
+import random
+import hashlib
+import numpy as np
+import sqlite3
+import re
+import traceback
+from typing import List, Dict, Tuple, Optional, Any
+from dataclasses import dataclass
+from sentence_transformers import SentenceTransformer
+import torch
+from sklearn.metrics.pairwise import cosine_similarity
+from dog_database import get_dog_description
+from breed_health_info import breed_health_info
+from breed_noise_info import breed_noise_info
+from scoring_calculation_system import UserPreferences, calculate_compatibility_score, UnifiedScoringSystem, calculate_unified_breed_scores
+from query_understanding import QueryUnderstandingEngine, analyze_user_query
+from constraint_manager import ConstraintManager, apply_breed_constraints
+from multi_head_scorer import MultiHeadScorer, score_breed_candidates, BreedScore
+from score_calibrator import ScoreCalibrator, calibrate_breed_scores
+from config_manager import get_config_manager, get_standardized_breed_data
+
+class UserQueryAnalyzer:
+    """
+    用戶查詢分析器
+    專門處理用戶輸入分析、生活方式關鍵字提取和偏好解析
+    """
+
+    def __init__(self, breed_list: List[str]):
+        """初始化用戶查詢分析器"""
+        self.breed_list = breed_list
+        self.comparative_keywords = {
+            'most': 1.0, 'love': 1.0, 'prefer': 0.9, 'like': 0.8,
+            'then': 0.7, 'second': 0.7, 'followed': 0.6,
+            'third': 0.5, 'least': 0.3, 'dislike': 0.2
+        }
+        self.stop_words = {
+            'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by',
+            'from', 'up', 'about', 'into', 'through', 'during', 'before', 'after', 'above', 'below',
+            'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did',
+            'will', 'would', 'could', 'should', 'may', 'might', 'must', 'can', 'i', 'me', 'my', 'myself',
+            'we', 'our', 'ours', 'ourselves', 'you', 'your', 'yours', 'yourself', 'yourselves', 'he',
+            'him', 'his', 'himself', 'she', 'her', 'hers', 'herself', 'it', 'its', 'itself', 'they',
+            'them', 'their', 'theirs', 'themselves'
+        }
+
+    def parse_comparative_preferences(self, user_input: str) -> Dict[str, float]:
+        """解析比較性偏好表達"""
+        breed_scores = {}
+
+        # 標準化輸入
+        text = user_input.lower()
+
+        # 找到品種名稱和偏好關鍵字
+        for breed in self.breed_list:
+            breed_display = breed.replace('_', ' ').lower()
+            breed_words = breed_display.split()
+
+            # 檢查是否提到此品種
+            breed_mentioned = False
+            for word in breed_words:
+                if word in text:
+                    breed_mentioned = True
+                    break
+
+            if breed_mentioned:
+                # 在附近找到偏好關鍵字
+                breed_score = 0.5  # 預設分數
+
+                # 在品種名稱 50 字符內尋找關鍵字
+                breed_pos = text.find(breed_words[0])
+                if breed_pos != -1:
+                    # 檢查背景中的關鍵字
+                    context_start = max(0, breed_pos - 50)
+                    context_end = min(len(text), breed_pos + 50)
+                    context = text[context_start:context_end]
+
+                    for keyword, score in self.comparative_keywords.items():
+                        if keyword in context:
+                            breed_score = max(breed_score, score)
+
+                breed_scores[breed] = breed_score
+
+        return breed_scores
+
+    def extract_lifestyle_keywords(self, user_input: str) -> Dict[str, List[str]]:
+        """增強的生活方式關鍵字提取，具有更好的模式匹配"""
+        keywords = {
+            'living_space': [],
+            'activity_level': [],
+            'family_situation': [],
+            'noise_preference': [],
+            'size_preference': [],
+            'care_level': [],
+            'special_needs': [],
+            'intelligence_preference': [],
+            'grooming_preference': [],
+            'lifespan_preference': [],
+            'temperament_preference': [],
+            'experience_level': []
+        }
+
+        text = user_input.lower()
+
+        # 增強居住空間檢測
+        apartment_terms = ['apartment', 'flat', 'condo', 'small space', 'city living', 'urban', 'no yard', 'indoor']
+        house_terms = ['house', 'yard', 'garden', 'backyard', 'large space', 'suburban', 'rural', 'farm']
+
+        if any(term in text for term in apartment_terms):
+            keywords['living_space'].append('apartment')
+        if any(term in text for term in house_terms):
+            keywords['living_space'].append('house')
+
+        # 增強活動水平檢測
+        high_activity = ['active', 'energetic', 'exercise', 'hiking', 'running', 'outdoor', 'sports', 'jogging',
+                        'athletic', 'adventure', 'vigorous', 'high energy', 'workout']
+        low_activity = ['calm', 'lazy', 'indoor', 'low energy', 'couch', 'sedentary', 'relaxed',
+                       'peaceful', 'quiet lifestyle', 'minimal exercise']
+        moderate_activity = ['moderate', 'walk', 'daily walks', 'light exercise']
+
+        if any(term in text for term in high_activity):
+            keywords['activity_level'].append('high')
+        if any(term in text for term in low_activity):
+            keywords['activity_level'].append('low')
+        if any(term in text for term in moderate_activity):
+            keywords['activity_level'].append('moderate')
+
+        # 增強家庭情況檢測
+        children_terms = ['children', 'kids', 'family', 'child', 'toddler', 'baby', 'teenage', 'school age']
+        elderly_terms = ['elderly', 'senior', 'old', 'retirement', 'aged', 'mature']
+        single_terms = ['single', 'alone', 'individual', 'solo', 'myself']
+
+        if any(term in text for term in children_terms):
+            keywords['family_situation'].append('children')
+        if any(term in text for term in elderly_terms):
+            keywords['family_situation'].append('elderly')
+        if any(term in text for term in single_terms):
+            keywords['family_situation'].append('single')
+
+        # 增強噪音偏好檢測
+        quiet_terms = ['quiet', 'silent', 'noise-sensitive', 'peaceful', 'no barking', 'minimal noise',
+                      'soft-spoken', 'calm', 'tranquil']
+        noise_ok_terms = ['loud', 'barking ok', 'noise tolerant', 'vocal', 'doesn\'t matter']
+
+        if any(term in text for term in quiet_terms):
+            keywords['noise_preference'].append('low')
+        if any(term in text for term in noise_ok_terms):
+            keywords['noise_preference'].append('high')
+
+        # 增強體型偏好檢測
+        small_terms = ['small', 'tiny', 'little', 'compact', 'miniature', 'toy', 'lap dog']
+        large_terms = ['large', 'big', 'giant', 'huge', 'massive', 'great']
+        medium_terms = ['medium', 'moderate size', 'average', 'mid-sized']
+
+        if any(term in text for term in small_terms):
+            keywords['size_preference'].append('small')
+        if any(term in text for term in large_terms):
+            keywords['size_preference'].append('large')
+        if any(term in text for term in medium_terms):
+            keywords['size_preference'].append('medium')
+
+        # 增強照護水平檢測
+        low_care = ['low maintenance', 'easy care', 'simple', 'minimal grooming', 'wash and go']
+        high_care = ['high maintenance', 'grooming', 'care intensive', 'professional grooming', 'daily brushing']
+
+        if any(term in text for term in low_care):
+            keywords['care_level'].append('low')
+        if any(term in text for term in high_care):
+            keywords['care_level'].append('high')
+
+        # 智力偏好檢測（新增）
+        smart_terms = ['smart', 'intelligent', 'clever', 'bright', 'quick learner', 'easy to train', 'trainable', 'genius', 'brilliant']
+        independent_terms = ['independent', 'stubborn', 'strong-willed', 'less trainable', 'thinks for themselves']
+
+        if any(term in text for term in smart_terms):
+            keywords['intelligence_preference'].append('high')
+        if any(term in text for term in independent_terms):
+            keywords['intelligence_preference'].append('independent')
+
+        # 美容偏好檢測（新增）
+        low_grooming_terms = ['low grooming', 'minimal grooming', 'easy care', 'wash and wear', 'no grooming', 'simple coat']
+        high_grooming_terms = ['high grooming', 'professional grooming', 'lots of care', 'high maintenance coat', 'daily brushing', 'regular grooming']
+
+        if any(term in text for term in low_grooming_terms):
+            keywords['grooming_preference'].append('low')
+        if any(term in text for term in high_grooming_terms):
+            keywords['grooming_preference'].append('high')
+
+        # 壽命偏好檢測（新增）
+        long_lived_terms = ['long lived', 'long lifespan', 'live long', 'many years', '15+ years', 'longevity']
+        healthy_terms = ['healthy breed', 'few health issues', 'robust', 'hardy', 'strong constitution']
+
+        if any(term in text for term in long_lived_terms):
+            keywords['lifespan_preference'].append('long')
+        if any(term in text for term in healthy_terms):
+            keywords['lifespan_preference'].append('healthy')
+
+        # 氣質偏好檢測（新增）
+        gentle_terms = ['gentle', 'calm', 'peaceful', 'laid back', 'chill', 'mellow', 'docile']
+        playful_terms = ['playful', 'energetic', 'fun', 'active personality', 'lively', 'spirited', 'bouncy']
+        protective_terms = ['protective', 'guard', 'watchdog', 'alert', 'vigilant', 'defensive']
+        friendly_terms = ['friendly', 'social', 'outgoing', 'loves people', 'sociable', 'gregarious']
+
+        if any(term in text for term in gentle_terms):
+            keywords['temperament_preference'].append('gentle')
+        if any(term in text for term in playful_terms):
+            keywords['temperament_preference'].append('playful')
+        if any(term in text for term in protective_terms):
+            keywords['temperament_preference'].append('protective')
+        if any(term in text for term in friendly_terms):
+            keywords['temperament_preference'].append('friendly')
+
+        # 經驗水平檢測（新增）
+        beginner_terms = ['first time', 'beginner', 'new to dogs', 'never had', 'novice', 'inexperienced']
+        advanced_terms = ['experienced', 'advanced', 'dog expert', 'many dogs before', 'professional', 'seasoned']
+
+        if any(term in text for term in beginner_terms):
+            keywords['experience_level'].append('beginner')
+        if any(term in text for term in advanced_terms):
+            keywords['experience_level'].append('advanced')
+
+        # 增強特殊需求檢測
+        guard_terms = ['guard', 'protection', 'security', 'watchdog', 'protective', 'defender']
+        companion_terms = ['therapy', 'emotional support', 'companion', 'comfort', 'lap dog', 'cuddly']
+        hypoallergenic_terms = ['hypoallergenic', 'allergies', 'non-shedding', 'allergy-friendly', 'no shed']
+        multi_pet_terms = ['good with cats', 'cat friendly', 'multi-pet', 'other animals']
+
+        if any(term in text for term in guard_terms):
+            keywords['special_needs'].append('guard')
+        if any(term in text for term in companion_terms):
+            keywords['special_needs'].append('companion')
+        if any(term in text for term in hypoallergenic_terms):
+            keywords['special_needs'].append('hypoallergenic')
+        if any(term in text for term in multi_pet_terms):
+            keywords['special_needs'].append('multi_pet')
+
+        return keywords
+
+    def preprocess_text(self, text: str) -> str:
+        """預處理文本"""
+        # 轉換為小寫
+        text = text.lower()
+
+        # 移除特殊字符，保留字母、數字和基本標點
+        text = re.sub(r'[^\w\s\-\']', ' ', text)
+
+        # 標準化空格
+        text = ' '.join(text.split())
+
+        return text
+
+    def generate_search_keywords(self, text: str) -> List[str]:
+        """
+        為語義搜索生成關鍵字
+
+        Args:
+            text: 輸入文本
+
+        Returns:
+            關鍵字列表
+        """
+        text = self.preprocess_text(text)
+        keywords = []
+
+        try:
+            # 分詞並過濾停用詞
+            words = text.split()
+            for word in words:
+                if len(word) > 2 and word not in self.stop_words:
+                    keywords.append(word)
+
+            # 提取重要短語
+            phrases = self._extract_phrases(text)
+            keywords.extend(phrases)
+
+            # 移除重複項
+            keywords = list(set(keywords))
+
+            return keywords
+
+        except Exception as e:
+            print(f"Error generating search keywords: {str(e)}")
+            return []
+
+    def _extract_phrases(self, text: str) -> List[str]:
+        """
+        提取重要短語
+
+        Args:
+            text: 輸入文本
+
+        Returns:
+            短語列表
+        """
+        phrases = []
+
+        # 定義重要短語模式
+        phrase_patterns = [
+            r'good with \w+',
+            r'apartment \w+',
+            r'family \w+',
+            r'exercise \w+',
+            r'grooming \w+',
+            r'noise \w+',
+            r'training \w+',
+            r'health \w+',
+            r'\w+ friendly',
+            r'\w+ tolerant',
+            r'\w+ maintenance',
+            r'\w+ energy',
+            r'\w+ barking',
+            r'\w+ shedding'
+        ]
+
+        for pattern in phrase_patterns:
+            matches = re.findall(pattern, text)
+            phrases.extend(matches)
+
+        return phrases
+
+    def analyze_sentiment(self, text: str) -> Dict[str, float]:
+        """
+        分析文本情感
+
+        Args:
+            text: 輸入文本
+
+        Returns:
+            情感分析結果
+        """
+        # 簡化的情感分析實現
+        positive_words = [
+            'love', 'like', 'prefer', 'enjoy', 'want', 'need', 'looking for',
+            'good', 'great', 'excellent', 'perfect', 'wonderful', 'amazing'
+        ]
+
+        negative_words = [
+            'hate', 'dislike', 'avoid', 'don\'t want', 'no', 'not',
+            'bad', 'terrible', 'awful', 'horrible', 'worst', 'never'
+        ]
+
+        words = text.lower().split()
+        positive_count = sum(1 for word in words if word in positive_words)
+        negative_count = sum(1 for word in words if word in negative_words)
+        total_words = len(words)
+
+        if total_words == 0:
+            return {'positive': 0.5, 'negative': 0.5, 'neutral': 0.0}
+
+        positive_score = positive_count / total_words
+        negative_score = negative_count / total_words
+        neutral_score = max(0, 1 - positive_score - negative_score)
+
+        return {
+            'positive': positive_score,
+            'negative': negative_score,
+            'neutral': neutral_score
+        }
+
+    def parse_user_requirements(self, user_input: str) -> Dict[str, Any]:
+        """更準確地解析用戶需求"""
+        requirements = {
+            'living_space': None,
+            'exercise_level': None,
+            'preferred_size': None,
+            'noise_tolerance': None
+        }
+
+        input_lower = user_input.lower()
+
+        # 居住空間檢測
+        if 'apartment' in input_lower or 'small' in input_lower:
+            requirements['living_space'] = 'apartment'
+        elif 'large house' in input_lower or 'big' in input_lower:
+            requirements['living_space'] = 'large_house'
+        elif 'medium' in input_lower:
+            requirements['living_space'] = 'medium_house'
+
+        # 運動水平檢測
+        if "don't exercise" in input_lower or 'low exercise' in input_lower:
+            requirements['exercise_level'] = 'low'
+        elif any(term in input_lower for term in ['hiking', 'running', 'active']):
+            requirements['exercise_level'] = 'high'
+        elif '30 minutes' in input_lower or 'moderate' in input_lower:
+            requirements['exercise_level'] = 'moderate'
+
+        # 體型偏好檢測
+        if any(term in input_lower for term in ['small dog', 'tiny', 'toy']):
+            requirements['preferred_size'] = 'small'
+        elif any(term in input_lower for term in ['large dog', 'big dog']):
+            requirements['preferred_size'] = 'large'
+        elif 'medium' in input_lower:
+            requirements['preferred_size'] = 'medium'
+
+        return requirements
+
+    def analyze_user_description_enhanced(self, user_description: str) -> Dict[str, Any]:
+        """增強用戶描述分析"""
+        text = user_description.lower()
+        analysis = {
+            'mentioned_breeds': [],
+            'lifestyle_keywords': {},
+            'preference_strength': {},
+            'constraint_requirements': [],
+            'user_context': {}
+        }
+
+        # 提取提及的品種
+        for breed in self.breed_list:
+            breed_display = breed.replace('_', ' ').lower()
+            if breed_display in text or any(word in text for word in breed_display.split()):
+                analysis['mentioned_breeds'].append(breed)
+                # 簡單偏好強度分析
+                if any(word in text for word in ['love', 'prefer', 'like', '喜歡', '最愛']):
+                    analysis['preference_strength'][breed] = 0.8
+                else:
+                    analysis['preference_strength'][breed] = 0.5
+
+        # 提取約束要求
+        if any(word in text for word in ['quiet', 'silent', 'no barking', '安靜']):
+            analysis['constraint_requirements'].append('low_noise')
+        if any(word in text for word in ['apartment', 'small space', '公寓']):
+            analysis['constraint_requirements'].append('apartment_suitable')
+        if any(word in text for word in ['children', 'kids', 'family', '小孩']):
+            analysis['constraint_requirements'].append('child_friendly')
+
+        # 提取用戶背景
+        analysis['user_context'] = {
+            'has_children': any(word in text for word in ['children', 'kids', '小孩']),
+            'living_space': 'apartment' if any(word in text for word in ['apartment', '公寓']) else 'house',
+            'activity_level': 'high' if any(word in text for word in ['active', 'energetic', '活躍']) else 'moderate',
+            'noise_sensitive': any(word in text for word in ['quiet', 'silent', '安靜']),
+            'experience_level': 'beginner' if any(word in text for word in ['first time', 'beginner', '新手']) else 'intermediate'
+        }
+
+        return analysis
+
+    def create_user_preferences_from_analysis_enhanced(self, analysis: Dict[str, Any]) -> 'UserPreferences':
+        """從分析結果創建用戶偏好物件"""
+        context = analysis['user_context']
+
+        # 推斷居住空間類型
+        living_space = 'apartment' if context.get('living_space') == 'apartment' else 'house_small'
+
+        # 推斷院子權限
+        yard_access = 'no_yard' if living_space == 'apartment' else 'shared_yard'
+
+        # 推斷運動時間
+        activity_level = context.get('activity_level', 'moderate')
+        exercise_time_map = {'high': 120, 'moderate': 60, 'low': 30}
+        exercise_time = exercise_time_map.get(activity_level, 60)
+
+        # 推斷運動類型
+        exercise_type_map = {'high': 'active_training', 'moderate': 'moderate_activity', 'low': 'light_walks'}
+        exercise_type = exercise_type_map.get(activity_level, 'moderate_activity')
+
+        # 推斷噪音容忍度
+        noise_tolerance = 'low' if context.get('noise_sensitive', False) else 'medium'
+
+        return UserPreferences(
+            living_space=living_space,
+            yard_access=yard_access,
+            exercise_time=exercise_time,
+            exercise_type=exercise_type,
+            grooming_commitment='medium',
+            experience_level=context.get('experience_level', 'intermediate'),
+            time_availability='moderate',
+            has_children=context.get('has_children', False),
+            children_age='school_age' if context.get('has_children', False) else None,
+            noise_tolerance=noise_tolerance,
+            space_for_play=(living_space != 'apartment'),
+            other_pets=False,
+            climate='moderate',
+            health_sensitivity='medium',
+            barking_acceptance=noise_tolerance,
+            size_preference='no_preference'
+        )
+
+    def get_candidate_breeds_enhanced(self, analysis: Dict[str, Any]) -> List[str]:
+        """獲取候選品種列表"""
+        candidate_breeds = set()
+
+        # 如果提及特定品種，優先包含
+        if analysis['mentioned_breeds']:
+            candidate_breeds.update(analysis['mentioned_breeds'])
+
+        # 根據約束要求過濾品種
+        if 'apartment_suitable' in analysis['constraint_requirements']:
+            apartment_suitable = [
+                'French_Bulldog', 'Cavalier_King_Charles_Spaniel', 'Boston_Terrier',
+                'Pug', 'Bichon_Frise', 'Cocker_Spaniel', 'Yorkshire_Terrier', 'Shih_Tzu'
+            ]
+            candidate_breeds.update(breed for breed in apartment_suitable if breed in self.breed_list)
+
+        if 'child_friendly' in analysis['constraint_requirements']:
+            child_friendly = [
+                'Labrador_Retriever', 'Golden_Retriever', 'Beagle', 'Cavalier_King_Charles_Spaniel',
+                'Bichon_Frise', 'Poodle', 'Cocker_Spaniel'
+            ]
+            candidate_breeds.update(breed for breed in child_friendly if breed in self.breed_list)
+
+        # 如果候選品種不足，添加更多通用品種
+        if len(candidate_breeds) < 20:
+            general_breeds = [
+                'Labrador_Retriever', 'German_Shepherd', 'Golden_Retriever', 'French_Bulldog',
+                'Bulldog', 'Poodle', 'Beagle', 'Rottweiler', 'Yorkshire_Terrier', 'Boston_Terrier',
+                'Border_Collie', 'Siberian_Husky', 'Cavalier_King_Charles_Spaniel', 'Boxer',
+                'Bichon_Frise', 'Cocker_Spaniel', 'Shih_Tzu', 'Pug', 'Chihuahua'
+            ]
+            candidate_breeds.update(breed for breed in general_breeds if breed in self.breed_list)
+
+        return list(candidate_breeds)[:30]  # 限制候選數量以提高效率