Upload 19 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+animal_detector.db filter=lfs diff=lfs merge=lfs -text

adaptive_score_distribution.py

@@ -0,0 +1,448 @@
+# %%writefile adaptive_score_distribution.py
+import numpy as np
+from typing import List, Tuple, Dict, Optional, Any
+from dataclasses import dataclass, field
+import traceback
+
+
+@dataclass
+class GradientAnalysis:
+    """梯度分析結果"""
+    top_score: float
+    bottom_score: float
+    score_range: float
+    top5_std: float
+    top5_range: float
+    gradient_type: str  # 'steep', 'moderate', 'flat'
+    score_distribution: List[float] = field(default_factory=list)
+
+
+@dataclass
+class ScenarioClassification:
+    """情境分類結果"""
+    scenario_type: str  # 'perfect_match', 'good_choices', 'moderate_fit', 'challenging'
+    confidence: float
+    reasoning: str
+
+
+@dataclass
+class DistributionResult:
+    """分數分佈結果"""
+    final_scores: List[Tuple[str, float]] = field(default_factory=list)
+    gradient_analysis: Optional[GradientAnalysis] = None
+    scenario_classification: Optional[ScenarioClassification] = None
+    adjustment_applied: str = 'none'
+    adjustment_notes: List[str] = field(default_factory=list)
+
+
+class AdaptiveScoreDistribution:
+    """
+    自適應分數分佈系統
+    根據情境梯度自然形成分數分佈，不強制固定範圍
+
+    核心理念:
+    - 完美匹配 → 自然高分 (90+)
+    - 多個選擇 → 自然接近 (差距2-5分)
+    - 不適合 → 自然偏低 (60-70)
+    - 保證最低分 >= 60
+    """
+
+    def __init__(self):
+        """初始化自適應分數分佈系統"""
+        self.min_score = 0.60  # 全域最低分（觸底保護）
+        self.no_intervention_threshold = 0.10
+        self.gradient_thresholds = {
+            'steep_std': 0.04,
+            'steep_range': 0.12,
+            'flat_std': 0.02,
+            'flat_range': 0.05
+        }
+
+    def distribute_scores(self,
+                         raw_scores: List[Tuple[str, float]]) -> DistributionResult:
+        """
+        自適應分數分佈
+
+        Args:
+            raw_scores: 原始分數列表 [(breed_name, score), ...]
+
+        Returns:
+            DistributionResult: 分佈結果
+        """
+        try:
+            if not raw_scores:
+                return DistributionResult()
+
+            # Step 1: 分析梯度
+            gradient_analysis = self._analyze_gradient(raw_scores)
+
+            # Step 2: 判斷情境
+            scenario = self._classify_scenario(gradient_analysis)
+
+            # Step 3: 決定調整策略
+            adjusted_scores, adjustment_type, notes = self._apply_adaptive_strategy(
+                raw_scores, scenario, gradient_analysis
+            )
+
+            # Step 4: 應用最低分保護
+            final_scores = self._apply_floor_protection(adjusted_scores)
+
+            return DistributionResult(
+                final_scores=final_scores,
+                gradient_analysis=gradient_analysis,
+                scenario_classification=scenario,
+                adjustment_applied=adjustment_type,
+                adjustment_notes=notes
+            )
+
+        except Exception as e:
+            print(f"Error distributing scores: {str(e)}")
+            print(traceback.format_exc())
+            return DistributionResult(
+                final_scores=raw_scores,
+                adjustment_applied='error_fallback'
+            )
+
+    def _analyze_gradient(self,
+                         scores: List[Tuple[str, float]]) -> GradientAnalysis:
+        """
+        分析分數梯度特徵
+
+        Args:
+            scores: 分數列表
+
+        Returns:
+            GradientAnalysis: 梯度分析結果
+        """
+        try:
+            sorted_scores = sorted(scores, key=lambda x: x[1], reverse=True)
+            score_values = [s[1] for s in sorted_scores]
+
+            top_score = score_values[0] if score_values else 0.5
+            bottom_score = score_values[-1] if score_values else 0.5
+            score_range = top_score - bottom_score
+
+            # 前5名統計
+            top5_scores = score_values[:min(5, len(score_values))]
+            top5_std = float(np.std(top5_scores)) if len(top5_scores) > 1 else 0.0
+            top5_range = top5_scores[0] - top5_scores[-1] if len(top5_scores) >= 2 else 0.0
+
+            # 梯度類型判斷
+            if top5_std > self.gradient_thresholds['steep_std'] or \
+               top5_range > self.gradient_thresholds['steep_range']:
+                gradient_type = 'steep'
+            elif top5_std < self.gradient_thresholds['flat_std'] or \
+                 top5_range < self.gradient_thresholds['flat_range']:
+                gradient_type = 'flat'
+            else:
+                gradient_type = 'moderate'
+
+            return GradientAnalysis(
+                top_score=top_score,
+                bottom_score=bottom_score,
+                score_range=score_range,
+                top5_std=top5_std,
+                top5_range=top5_range,
+                gradient_type=gradient_type,
+                score_distribution=score_values
+            )
+
+        except Exception as e:
+            print(f"Error analyzing gradient: {str(e)}")
+            return GradientAnalysis(
+                top_score=0.5,
+                bottom_score=0.5,
+                score_range=0.0,
+                top5_std=0.0,
+                top5_range=0.0,
+                gradient_type='moderate',
+                score_distribution=[]
+            )
+
+    def _classify_scenario(self,
+                          gradient_analysis: GradientAnalysis) -> ScenarioClassification:
+        """
+        根據梯度分析分類情境
+
+        情境類型:
+        1. perfect_match: 完美匹配（第1名分數高且梯度陡峭）
+        2. good_choices: 多個好選擇（前5名分數都高且梯度平坦）
+        3. moderate_fit: 中等匹配（第1名分數中等）
+        4. challenging: 挑戰情境（第1名分數偏低）
+
+        Args:
+            gradient_analysis: 梯度分析結果
+
+        Returns:
+            ScenarioClassification: 情境分類結果
+        """
+        top_score = gradient_analysis.top_score
+        gradient_type = gradient_analysis.gradient_type
+
+        if top_score >= 0.88 and gradient_type == 'steep':  # Increased from 0.85
+            return ScenarioClassification(
+                scenario_type='perfect_match',
+                confidence=0.9,
+                reasoning="High top score with clear differentiation indicates perfect match"
+            )
+
+        elif top_score >= 0.78 and gradient_type == 'flat':  # Increased from 0.75
+            return ScenarioClassification(
+                scenario_type='good_choices',
+                confidence=0.85,
+                reasoning="Multiple high-scoring breeds with similar fitness"
+            )
+
+        elif top_score >= 0.68:  # Reduced from 0.70 to be less inflating
+            return ScenarioClassification(
+                scenario_type='moderate_fit',
+                confidence=0.75,
+                reasoning="Moderate match quality with acceptable options"
+            )
+
+        else:
+            return ScenarioClassification(
+                scenario_type='challenging',
+                confidence=0.65,
+                reasoning="Lower overall match quality, may need requirement adjustment"
+            )
+
+    def _apply_adaptive_strategy(self,
+                                raw_scores: List[Tuple[str, float]],
+                                scenario: ScenarioClassification,
+                                gradient_analysis: GradientAnalysis) -> Tuple[List[Tuple[str, float]], str, List[str]]:
+        """
+        根據情境類型應用不同的調整策略
+
+        Args:
+            raw_scores: 原始分數
+            scenario: 情境分類
+            gradient_analysis: 梯度分析
+
+        Returns:
+            Tuple: (調整後分數, 調整類型, 調整註記)
+        """
+        sorted_scores = sorted(raw_scores, key=lambda x: x[1], reverse=True)
+        notes = []
+
+        if scenario.scenario_type == 'perfect_match':
+            # 完美匹配: 不調整，保持自然
+            notes.append("Perfect match scenario: No adjustment needed")
+            return sorted_scores, 'no_adjustment', notes
+
+        elif scenario.scenario_type == 'good_choices':
+            # 多個好選擇: 確保最小區分度
+            adjusted, adjustment_notes = self._ensure_minimum_differentiation(
+                sorted_scores, gradient_analysis
+            )
+            notes.extend(adjustment_notes)
+            return adjusted, 'minimum_differentiation', notes
+
+        elif scenario.scenario_type == 'moderate_fit':
+            # 中等匹配: 溫和提升
+            adjusted, adjustment_notes = self._gentle_uplift(
+                sorted_scores, target_top=0.80
+            )
+            notes.extend(adjustment_notes)
+            return adjusted, 'gentle_uplift', notes
+
+        elif scenario.scenario_type == 'challenging':
+            # 挑戰情境: 適度提升但不過度
+            adjusted, adjustment_notes = self._moderate_uplift(
+                sorted_scores, target_top=0.72
+            )
+            notes.extend(adjustment_notes)
+            return adjusted, 'moderate_uplift', notes
+
+        return sorted_scores, 'no_adjustment', notes
+
+    def _ensure_minimum_differentiation(self,
+                                       scores: List[Tuple[str, float]],
+                                       gradient_analysis: GradientAnalysis) -> Tuple[List[Tuple[str, float]], List[str]]:
+        """
+        確保最小區分度（當分數過於接近時）
+
+        Args:
+            scores: 分數列表
+            gradient_analysis: 梯度分析
+
+        Returns:
+            Tuple: (調整後分數, 註記)
+        """
+        notes = []
+        top5_range = gradient_analysis.top5_range
+
+        # 如果前5名差距 >= 5%，不需要調整
+        if top5_range >= 0.05:
+            notes.append(f"Differentiation sufficient (range: {top5_range:.3f})")
+            return scores, notes
+
+        # 需要擴展區分度
+        top5 = scores[:5]
+        rest = scores[5:]
+
+        target_range = 0.05
+        current_top = top5[0][1] if top5 else 0.5
+        current_bottom = top5[-1][1] if len(top5) > 0 else 0.5
+
+        adjusted_top5 = []
+        for i, (breed, score) in enumerate(top5):
+            if len(top5) > 1:
+                position = i / (len(top5) - 1)
+                new_score = current_top - (position * target_range)
+            else:
+                new_score = score
+            adjusted_top5.append((breed, new_score))
+
+        notes.append(f"Expanded top 5 differentiation to {target_range:.1%}")
+        return adjusted_top5 + rest, notes
+
+    def _gentle_uplift(self,
+                      scores: List[Tuple[str, float]],
+                      target_top: float = 0.75) -> Tuple[List[Tuple[str, float]], List[str]]:
+        """
+        溫和提升（保持分數分佈形狀）
+
+        Args:
+            scores: 分數列表
+            target_top: 目標第1名分數 (reduced from 0.80 to 0.75)
+
+        Returns:
+            Tuple: (調整後分數, 註記)
+        """
+        notes = []
+
+        if not scores:
+            return scores, notes
+
+        current_top = scores[0][1]
+
+        if current_top >= target_top:
+            notes.append(f"Top score already sufficient ({current_top:.3f})")
+            return scores, notes
+
+        # 計算提升量
+        uplift = target_top - current_top
+
+        # 所有品種統一提升
+        adjusted = [(breed, min(1.0, score + uplift)) for breed, score in scores]
+
+        notes.append(f"Applied gentle uplift: +{uplift:.3f} to all breeds")
+        return adjusted, notes
+
+    def _moderate_uplift(self,
+                        scores: List[Tuple[str, float]],
+                        target_top: float = 0.68) -> Tuple[List[Tuple[str, float]], List[str]]:
+        """
+        適度提升（挑戰情境）
+
+        Args:
+            scores: 分數列表
+            target_top: 目標第1名分數 (reduced from 0.72 to 0.68)
+
+        Returns:
+            Tuple: (調整後分數, 註記)
+        """
+        notes = []
+
+        if not scores:
+            return scores, notes
+
+        current_top = scores[0][1]
+        current_bottom = scores[-1][1] if scores else 0.5
+
+        adjusted = []
+        for breed, score in scores:
+            # 非線性提升: 分數越高提升越多
+            if current_top > current_bottom:
+                relative_position = (score - current_bottom) / (current_top - current_bottom + 0.001)
+            else:
+                relative_position = 1.0
+
+            uplift_factor = 1.0 + (relative_position * 0.12)  # 最多提升12% (reduced from 15%)
+            new_score = min(1.0, score * uplift_factor)
+            adjusted.append((breed, new_score))
+
+        notes.append("Applied moderate uplift with position-based scaling")
+        return adjusted, notes
+
+    def _apply_floor_protection(self,
+                               scores: List[Tuple[str, float]]) -> List[Tuple[str, float]]:
+        """
+        應用最低分保護（確保沒有品種低於60分）
+
+        Args:
+            scores: 分數列表
+
+        Returns:
+            List[Tuple[str, float]]: 保護後分數
+        """
+        protected = []
+        for breed, score in scores:
+            protected_score = max(self.min_score, score)
+            protected.append((breed, protected_score))
+
+        return protected
+
+    def get_distribution_summary(self, result: DistributionResult) -> Dict[str, Any]:
+        """
+        獲取分佈摘要
+
+        Args:
+            result: 分佈結果
+
+        Returns:
+            Dict[str, Any]: 分佈摘要
+        """
+        if not result.final_scores:
+            return {'error': 'No scores to summarize'}
+
+        score_values = [s[1] for s in result.final_scores]
+
+        return {
+            'scenario_type': result.scenario_classification.scenario_type if result.scenario_classification else 'unknown',
+            'adjustment_applied': result.adjustment_applied,
+            'score_statistics': {
+                'top_score': max(score_values) if score_values else 0,
+                'bottom_score': min(score_values) if score_values else 0,
+                'mean_score': float(np.mean(score_values)) if score_values else 0,
+                'std_score': float(np.std(score_values)) if score_values else 0,
+                'range': max(score_values) - min(score_values) if score_values else 0
+            },
+            'gradient_info': {
+                'type': result.gradient_analysis.gradient_type if result.gradient_analysis else 'unknown',
+                'top5_std': result.gradient_analysis.top5_std if result.gradient_analysis else 0,
+                'top5_range': result.gradient_analysis.top5_range if result.gradient_analysis else 0
+            },
+            'adjustment_notes': result.adjustment_notes,
+            'top_3_breeds': result.final_scores[:3] if result.final_scores else []
+        }
+
+
+def distribute_breed_scores(raw_scores: List[Tuple[str, float]]) -> DistributionResult:
+    """
+    便利函數: 分佈品種分數
+
+    Args:
+        raw_scores: 原始分數列表
+
+    Returns:
+        DistributionResult: 分佈結果
+    """
+    distributor = AdaptiveScoreDistribution()
+    return distributor.distribute_scores(raw_scores)
+
+
+def get_distribution_summary(raw_scores: List[Tuple[str, float]]) -> Dict[str, Any]:
+    """
+    便利函數: 獲取分佈摘要
+
+    Args:
+        raw_scores: 原始分數列表
+
+    Returns:
+        Dict[str, Any]: 分佈摘要
+    """
+    distributor = AdaptiveScoreDistribution()
+    result = distributor.distribute_scores(raw_scores)
+    return distributor.get_distribution_summary(result)

breed_recommendation_enhanced.py

@@ -1,3 +1,4 @@
+# %%writefile breed_recommendation_enhanced.py
 import gradio as gr
 from typing import Dict, List, Any, Optional
 import traceback
@@ -23,14 +24,12 @@ def create_description_examples():
                 font-size: 1.1em;
                 font-weight: 600;
             '>💡 Example Descriptions - Try These Expression Styles:</h4>
-
             <div style='
                 display: grid;
                 grid-template-columns: 1fr 1fr;
                 gap: 15px;
                 margin-top: 10px;
             '>
-
                 <!-- 左上：冷色（藍） -->
                 <div style='
                     background: white;
@@ -39,12 +38,11 @@ def create_description_examples():
                     border: 1px solid #e2e8f0;
                     box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                 '>
-                    <strong style='color: #4299e1;'>🏡 Active Lifestyle & Space:</strong><br>
+                    <strong style='color: #4299e1;'>🏡 Priority: Quiet Environment</strong><br>
                     <span style='color: #4a5568; font-size: 0.9em;'>
-                        "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."
+                        "Most importantly I need a quiet dog. I live in a small apartment with thin walls, and my neighbors are very noise sensitive."
                     </span>
                 </div>
-
                 <!-- 右上：暖色（橘） -->
                 <div style='
                     background: white;
@@ -53,12 +51,11 @@ def create_description_examples():
                     border: 1px solid #e2e8f0;
                     box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                 '>
-                    <strong style='color: #ed8936;'>🎾 Activity Preferences:</strong><br>
+                    <strong style='color: #ed8936;'>🎾 Multiple Priorities:</strong><br>
                     <span style='color: #4a5568; font-size: 0.9em;'>
-                        "I want an active medium to large dog for hiking and outdoor activities"
+                        "First I need a dog that's good with kids, second prefer low maintenance grooming, and third would like an active breed for weekend hiking."
                     </span>
                 </div>
-
                 <!-- 左下：冷色（紫） -->
                 <div style='
                     background: white;
@@ -67,12 +64,11 @@ def create_description_examples():
                     border: 1px solid #e2e8f0;
                     box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                 '>
-                    <strong style='color: #805ad5;'>🚶 Balanced Daily Routine:</strong><br>
+                    <strong style='color: #805ad5;'>🏠 Beginner Owner:</strong><br>
                     <span style='color: #4a5568; font-size: 0.9em;'>
-                        "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."
+                        "This is my first dog. I live in a house with a small yard, work full time, and really want a low-maintenance breed that's easy to train."
                     </span>
                 </div>
-
                 <!-- 右下：暖色（琥珀橘） -->
                 <div style='
                     background: white;
@@ -81,13 +77,12 @@ def create_description_examples():
                     border: 1px solid #e2e8f0;
                     box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                 '>
-                    <strong style='color: #276749;'>🤫 Low-Noise Preference:</strong><br>
+                    <strong style='color: #276749;'>🤫 Active Lifestyle Priority:</strong><br>
                     <span style='color: #4a5568; font-size: 0.9em;'>
-                        "I live in a small apartment and don't exercise much, so I need a small, quiet dog that won't bark too often"
+                        "I absolutely need an energetic dog for daily running and hiking. Size doesn't matter, but the dog must be able to keep up with intense exercise."
                     </span>
                 </div>
             </div>
-
             <div style='
                 margin-top: 15px;
                 padding: 12px;
@@ -126,7 +121,6 @@ def create_recommendation_tab(
                         background: linear-gradient(to right, rgba(66, 153, 225, 0.1), rgba(72, 187, 120, 0.1));
                         border-radius: 10px;
                     '>
-
                         <p style='
                             font-size: 1.2em;
                             margin: 0;

constraint_manager.py

@@ -1,3 +1,4 @@
+# %%writefile constraint_manager.py
 import sqlite3
 import json
 import numpy as np
@@ -138,6 +139,22 @@ class ConstraintManager:
                 relaxation_allowed=False,
                 safety_critical=True
             ),
+            ConstraintRule(
+                name="beginner_critical_exclusion",
+                priority=ConstraintPriority.CRITICAL,
+                description="Exclude breeds absolutely unsuitable for beginners",
+                filter_function="filter_beginner_critical",
+                relaxation_allowed=False,
+                safety_critical=True
+            ),
+            ConstraintRule(
+                name="senior_friendly_constraint",
+                priority=ConstraintPriority.CRITICAL,
+                description="Exclude breeds unsuitable for senior owners",
+                filter_function="filter_senior_friendly",
+                relaxation_allowed=False,
+                safety_critical=True
+            ),
 
             # Priority 2: High priority constraints
             ConstraintRule(
@@ -309,6 +326,15 @@ class ConstraintManager:
         if rule.name == "severe_allergy_constraint":
             return 'hypoallergenic' in dimensions.special_requirements
 
+        # Beginner critical exclusion - applies when user is a beginner
+        if rule.name == "beginner_critical_exclusion":
+            return ('beginner' in dimensions.experience_level or
+                    'first_time' in dimensions.special_requirements)
+
+        # Senior friendly constraint - applies when user is elderly
+        if rule.name == "senior_friendly_constraint":
+            return 'senior' in dimensions.special_requirements
+
         # Low activity constraint
         if rule.name == "low_activity_constraint":
             return 'low' in dimensions.activity_level
@@ -452,19 +478,46 @@ class ConstraintManager:
 
     def filter_child_safety(self, candidates: Set[str],
                           dimensions: QueryDimensions) -> Dict[str, str]:
-        """Child safety filtering"""
+        """Child safety filtering - enhanced for young children"""
         filtered = {}
 
+        # 檢查是否有兒童相關需求
+        has_children = 'children' in dimensions.family_context
+
+        # 如果沒有偵測到，也不執行過濾
+        if not has_children:
+            return filtered
+
+        # 假設有提到 children/kids 就可能有幼童風險，對巨型犬保守處理
+        # 這是安全優先的設計
+        has_young_children = True  # 保守假設
+
         for breed in list(candidates):
             breed_info = self.breed_cache.get(breed, {})
             good_with_children = breed_info.get('good_with_children', 'Yes')
-            size = breed_info.get('size', '')
-            temperament = breed_info.get('temperament', '')
+            size = breed_info.get('size', '').lower()
+            temperament = breed_info.get('temperament', '').lower()
 
-            # Breeds explicitly not suitable for children
+            # 1. Breeds explicitly not suitable for children
             if good_with_children == 'No':
                 filtered[breed] = "Not suitable for children"
-            # Large breeds without clear child compatibility indicators should be cautious
+                continue
+
+            # 2. 對幼童家庭，排除巨型犬（體型風險）
+            if has_young_children:
+                if 'giant' in size:
+                    filtered[breed] = "Giant breed poses physical risk to young children"
+                    continue
+                # 大型犬需要額外檢查性格
+                if 'large' in size:
+                    # 如果沒有明確標示適合兒童，且沒有溫和性格特徵
+                    gentle_traits = ['gentle', 'patient', 'calm', 'friendly']
+                    has_gentle_trait = any(t in temperament for t in gentle_traits)
+                    if good_with_children != 'Yes' and not has_gentle_trait:
+                        filtered[breed] = "Large breed without confirmed child-friendly temperament"
+                        continue
+
+            # 3. Large breeds without clear child compatibility indicators should be cautious
             elif ('large' in size and good_with_children != 'Yes' and
                   any(trait in temperament for trait in ['aggressive', 'dominant', 'protective'])):
                 filtered[breed] = "Large breed with uncertain child compatibility"
@@ -566,6 +619,159 @@ class ConstraintManager:
 
         return filtered
 
+    def filter_beginner_critical(self, candidates: Set[str],
+                                dimensions: QueryDimensions) -> Dict[str, str]:
+        """
+        Critical filtering for beginner owners - absolute exclusion rules
+
+        This filter removes breeds that are absolutely unsuitable for first-time owners
+        based on temperament traits that require experienced handling.
+
+        通用性設計原則：
+        1. 基於品種特性（性格、照護需求），不針對特定品種名稱
+        2. 只排除���明確危險或極度不適合的品種
+        3. 同時考慮多個負面因素的組合效應
+        """
+        filtered = {}
+
+        # 定義對新手絕對危險或極度不適合的特徵
+        # 這些是基於行為學和犬隻專家共識的特徵
+        critical_negative_traits = {
+            'aggressive': 'Aggressive temperament requires experienced handling',
+            'dominant': 'Dominant personality requires firm, experienced leadership',
+        }
+
+        # 需要特殊技能的特徵組合
+        challenging_trait_combinations = [
+            # (特徵列表, 最少需要匹配數量, 排除原因)
+            (['sensitive', 'nervous', 'timid', 'shy'], 2,
+             'Multiple anxiety-related traits require experienced behavioral management'),
+            (['stubborn', 'independent', 'strong-willed'], 2,
+             'Strong-willed combination requires advanced training experience'),
+            (['protective', 'territorial', 'alert'], 2,
+             'Guard dog traits require experienced socialization and control'),
+        ]
+
+        # 絕對排除：高照護 + 敏感性格的組合（如 Italian Greyhound）
+        high_care_sensitive_exclusion = True
+
+        for breed in list(candidates):
+            breed_info = self.breed_cache.get(breed, {})
+            temperament = breed_info.get('temperament', '').lower()
+            care_level = breed_info.get('care_level', '').lower()
+            good_with_children = breed_info.get('good_with_children', 'Yes')
+
+            # 檢查 1: 單一致命特徵
+            for trait, reason in critical_negative_traits.items():
+                if trait in temperament:
+                    filtered[breed] = reason
+                    break
+
+            if breed in filtered:
+                continue
+
+            # 檢查 2: 危險特徵組合
+            for traits, min_count, reason in challenging_trait_combinations:
+                matched_count = sum(1 for t in traits if t in temperament)
+                if matched_count >= min_count:
+                    filtered[breed] = reason
+                    break
+
+            if breed in filtered:
+                continue
+
+            # 檢查 3: 敏感性格 + 其他負面因素的組合
+            # 這是針對如 Italian Greyhound 這類品種的通用規則
+            if 'sensitive' in temperament:
+                negative_factors = 0
+                exclusion_reasons = []
+
+                # 敏感 + 不適合兒童（暗示難以處理）
+                if good_with_children == 'No':
+                    negative_factors += 1
+                    exclusion_reasons.append('not child-friendly')
+
+                # 敏感 + 警覺性高（容易過度反應）
+                if 'alert' in temperament:
+                    negative_factors += 1
+                    exclusion_reasons.append('high alertness')
+
+                # 敏感 + 需要中高照護
+                if care_level in ['moderate', 'high']:
+                    negative_factors += 0.5
+
+                # 敏感 + 緊張/害羞
+                if any(t in temperament for t in ['nervous', 'shy', 'timid']):
+                    negative_factors += 1
+                    exclusion_reasons.append('anxiety tendencies')
+
+                # 累積超過閾值則排除
+                if negative_factors >= 1.5:
+                    reason = f"Sensitive breed with {', '.join(exclusion_reasons)} - challenging for beginners"
+                    filtered[breed] = reason
+                    continue
+
+            # 檢查 4: 需要專業訓練的工作犬
+            working_dog_indicators = ['working', 'herding', 'guard', 'protection']
+            if any(ind in temperament for ind in working_dog_indicators):
+                if care_level in ['high', 'expert']:
+                    filtered[breed] = "Working/guard breed with high care needs - requires experienced owner"
+
+        return filtered
+
+    def filter_senior_friendly(self, candidates: Set[str],
+                              dimensions: QueryDimensions) -> Dict[str, str]:
+        """
+        Filter breeds unsuitable for senior owners
+
+        通用性設計原則：
+        1. 基於品種體型、力量、運動需求等客觀特性
+        2. 考慮老年人的身體限制（力量、敏捷度、體力）
+        3. 優先推薦易於處理、低運動需求的品種
+        """
+        filtered = {}
+
+        for breed in list(candidates):
+            breed_info = self.breed_cache.get(breed, {})
+            size = breed_info.get('size', '').lower()
+            exercise_needs = breed_info.get('exercise_needs', '').lower()
+            temperament = breed_info.get('temperament', '').lower()
+            care_level = breed_info.get('care_level', '').lower()
+
+            # 1. 排除巨型犬 - 對老年人太難控制
+            if 'giant' in size:
+                filtered[breed] = "Giant breed too difficult for senior to handle physically"
+                continue
+
+            # 2. 排除大型犬 - 對老年人通常太難處理
+            if 'large' in size:
+                filtered[breed] = "Large breed may be difficult for senior to handle"
+                continue
+
+            # 3. 排除需要大量運動的品種
+            if 'very high' in exercise_needs or 'high' in exercise_needs:
+                filtered[breed] = "High exercise needs exceed typical senior lifestyle"
+                continue
+
+            # 4. 排除敏感/焦慮品種 - 對老年人心理負擔大
+            anxiety_traits = ['sensitive', 'nervous', 'anxious', 'timid', 'shy']
+            if any(t in temperament for t in anxiety_traits):
+                filtered[breed] = "Sensitive/anxious breed requires more emotional attention than ideal for senior"
+                continue
+
+            # 5. 排除需要專業訓練的難以控制品種
+            difficult_traits = ['dominant', 'stubborn', 'independent', 'strong-willed']
+            if any(t in temperament for t in difficult_traits):
+                filtered[breed] = "Strong-willed breed may be challenging for senior to manage"
+                continue
+
+            # 6. 排除高照護需求品種
+            if care_level in ['high', 'expert']:
+                filtered[breed] = "High care needs challenging for senior lifestyle"
+                continue
+
+        return filtered
+
     def filter_experience_level(self, candidates: Set[str],
                               dimensions: QueryDimensions) -> Dict[str, str]:
         """Experience level filtering"""

dimension_score_calculator.py

@@ -1,3 +1,4 @@
+# %%writefile dimension_score_calculator.py
 import traceback
 from typing import Dict, Any
 from breed_health_info import breed_health_info
@@ -318,10 +319,11 @@ class DimensionScoreCalculator:
 
         return max(0.1, min(1.0, final_score))
 
-    def calculate_grooming_score(self, breed_needs: str, user_commitment: str, breed_size: str) -> float:
+    def calculate_grooming_score(self, breed_needs: str, user_commitment: str, breed_size: str, breed_name: str = "", temperament: str = "") -> float:
         """
         計算美容需求分數，強化美容維護需求與使用者承諾度的匹配評估。
         這個函數特別注意品種大小對美容工作的影響，以及不同程度的美容需求對時間投入的要求。
+        新增：考慮品種特殊護理需求（如敏感皮膚、需保暖等）
         """
         # 重新設計基礎分數矩陣，讓美容需求的差異更加明顯
         base_scores = {
@@ -436,7 +438,31 @@ class DimensionScoreCalculator:
         seasonal_adjustment = get_seasonal_adjustment("", user_commitment)
         professional_adjustment = get_professional_grooming_adjustment("", user_commitment)
 
-        final_score = current_score + coat_adjustment + seasonal_adjustment + professional_adjustment
+        # 新增：特殊護理需求評估（針對敏感品種、需保暖品種等）
+        special_care_adjustment = 0.0
+        temperament_lower = temperament.lower()
+        breed_name_lower = breed_name.lower()
+
+        # 對於低承諾使用者，敏感品種需要額外懲罰
+        if user_commitment == "low":
+            # 敏感性格需要更多細心照顧
+            if 'sensitive' in temperament_lower:
+                special_care_adjustment -= 0.15
+
+            # 某些品種需要特殊護理（保暖、皮膚護理等）
+            # Italian Greyhound, Whippet等細瘦品種需要保暖衣物
+            if any(keyword in breed_name_lower for keyword in ['italian', 'greyhound', 'whippet', 'hairless']):
+                special_care_adjustment -= 0.12
+
+            # 皺褶皮膚品種需要特殊清潔
+            if any(keyword in breed_name_lower for keyword in ['bulldog', 'pug', 'shar pei']):
+                special_care_adjustment -= 0.10
+
+            # 白色毛髮品種容易髒，需要更頻繁清潔
+            if 'white' in breed_name_lower or 'maltese' in breed_name_lower:
+                special_care_adjustment -= 0.08
+
+        final_score = current_score + coat_adjustment + seasonal_adjustment + professional_adjustment + special_care_adjustment
 
         # 確保分數在有意義的範圍內，但允許更大的差異
         return max(0.1, min(1.0, final_score))
@@ -486,16 +512,24 @@ class DimensionScoreCalculator:
                 'protective': -0.10,
                 'aloof': -0.08,
                 'energetic': -0.08,
-                'aggressive': -0.20        # 保持較高懲罰，因為安全考慮
+                'aggressive': -0.20,       # 保持較高懲罰，因為安全考慮
+                'sensitive': -0.18,        # 敏感品種對新手很具挑戰性（需小心對待、易受驚）
+                'alert': -0.05,            # 過度警覺可能導致過度吠叫
+                'nervous': -0.15,          # 緊張性格對新手困難
+                'shy': -0.12,              # 害羞需要耐心社會化
+                'timid': -0.12             # 膽小需要特殊處理
             }
 
             easy_traits = {
                 'gentle': 0.08,           # 提高獎勵以平衡
-                'friendly': 0.08,
-                'eager to please': 0.10,
-                'patient': 0.08,
-                'adaptable': 0.08,
-                'calm': 0.08
+                'friendly': 0.10,         # 友善對新手很重要
+                'eager to please': 0.12,  # 渴望取悅主人，容易訓練
+                'patient': 0.10,
+                'adaptable': 0.10,
+                'calm': 0.10,
+                'outgoing': 0.08,         # 外向性格easier for beginners
+                'confident': 0.08,        # 自信的狗對新手較友善
+                'tolerant': 0.10          # 容忍度高對新手很重要
             }
 
             # 計算特徵調整

dynamic_weight_calculator.py

@@ -0,0 +1,415 @@
+# %%writefile dynamic_weight_calculator.py
+import numpy as np
+from typing import Dict, List, Tuple, Set, Optional, Any
+from dataclasses import dataclass, field
+import traceback
+
+
+@dataclass
+class WeightAllocationResult:
+    """權重分配結果"""
+    dynamic_weights: Dict[str, float] = field(default_factory=dict)
+    allocation_method: str = 'balanced'
+    high_priority_count: int = 0
+    mentioned_dimensions: Set[str] = field(default_factory=set)
+    weight_sum: float = 1.0
+    allocation_notes: List[str] = field(default_factory=list)
+
+
+class DynamicWeightCalculator:
+    """
+    動態權重計算器
+    根據使用者優先級動態調整維度權重
+
+    策略:
+    - 1個高優先級 → 固定預留 40%
+    - 2個高優先級 → 固定預留 40% + 25%
+    - 3個高優先級 → 固定預留 30% + 27% + 23%
+    - 4+個高優先級 → 倍數正規化法
+    """
+
+    def __init__(self):
+        """初始化動態權重計算器"""
+        self.default_weights = self._initialize_default_weights()
+        self.dimension_name_mapping = self._initialize_dimension_mapping()
+        self.high_priority_threshold = 1.4  # Balanced threshold (not too high, not too low)
+        self.min_weight_floor = 0.05
+        self.contextual_weight_distribution = {
+            'critical_dimensions_weight': 0.50,  # Moderate emphasis on critical dimensions
+            'mentioned_dimensions_weight': 0.35,  # Good weight for mentioned dimensions
+            'other_dimensions_weight': 0.15      # Reasonable baseline for other dimensions
+        }
+
+    def _initialize_default_weights(self) -> Dict[str, float]:
+        """初始化預設權重（平衡配置）"""
+        return {
+            'activity_compatibility': 0.18,
+            'noise_compatibility': 0.16,
+            'spatial_compatibility': 0.13,
+            'family_compatibility': 0.13,
+            'maintenance_compatibility': 0.13,
+            'experience_compatibility': 0.15,  # 新增獨立的experience維度
+            'health_compatibility': 0.12
+        }
+
+    def _initialize_dimension_mapping(self) -> Dict[str, str]:
+        """初始化維度名稱映射"""
+        return {
+            'noise': 'noise_compatibility',
+            'size': 'spatial_compatibility',  # size更適合映射到spatial
+            'exercise': 'activity_compatibility',
+            'activity': 'activity_compatibility',
+            'grooming': 'maintenance_compatibility',
+            'maintenance': 'maintenance_compatibility',
+            'family': 'family_compatibility',
+            'experience': 'experience_compatibility',  # 獨立映射
+            'health': 'health_compatibility',  # 獨立映射
+            'spatial': 'spatial_compatibility',
+            'space': 'spatial_compatibility'
+        }
+
+    def calculate_dynamic_weights(self,
+                                 dimension_priorities: Dict[str, float],
+                                 user_mentions: Optional[Set[str]] = None,
+                                 use_contextual: bool = True) -> WeightAllocationResult:
+        """
+        計算動態權重
+
+        Args:
+            dimension_priorities: 維度優先級 {dimension: priority_score}
+            user_mentions: 使用者明確提到的維度
+            use_contextual: 是否使用情境相對評分（關鍵維度80%）
+
+        Returns:
+            WeightAllocationResult: 權重分配結果
+        """
+        try:
+            if user_mentions is None:
+                user_mentions = set()
+
+            # Step 1: 標準化維度名稱
+            normalized_priorities = self._normalize_dimension_names(dimension_priorities)
+
+            # Step 2: 分類維度
+            high_priority_dims = {
+                dim: score for dim, score in normalized_priorities.items()
+                if score >= self.high_priority_threshold
+            }
+            high_count = len(high_priority_dims)
+
+            # Step 3: 根據高優先級數量選擇策略
+            if high_count == 0:
+                # 無優先級 → 使用預設權重
+                result = self._allocate_default_weights(user_mentions)
+                result.allocation_method = 'default_balanced'
+
+            elif use_contextual:
+                # 使用情境相對評分（關鍵維度80%）
+                result = self._allocate_contextual_weights(
+                    normalized_priorities, user_mentions
+                )
+                result.allocation_method = 'contextual_relative'
+
+            elif high_count == 1:
+                # 單一高優先級 → 固定預留40%
+                result = self._allocate_single_priority(
+                    normalized_priorities, user_mentions
+                )
+                result.allocation_method = 'single_fixed'
+
+            elif high_count <= 3:
+                # 2-3個高優先級 → 階梯固定預留法
+                result = self._allocate_multiple_priorities_fixed(
+                    normalized_priorities, user_mentions, high_count
+                )
+                result.allocation_method = f'multiple_fixed_{high_count}'
+
+            else:
+                # 4+個高優先級 → 倍數正規化法
+                result = self._allocate_multiple_priorities_proportional(
+                    normalized_priorities, user_mentions
+                )
+                result.allocation_method = 'proportional'
+
+            # Step 4: 應用最低權重保護
+            result.dynamic_weights = self._apply_weight_floor(result.dynamic_weights)
+
+            # Step 5: 正規化確保總和為1.0
+            result.dynamic_weights = self._normalize_weights(result.dynamic_weights)
+            result.weight_sum = sum(result.dynamic_weights.values())
+
+            result.high_priority_count = high_count
+            result.mentioned_dimensions = user_mentions
+
+            return result
+
+        except Exception as e:
+            print(f"Error calculating dynamic weights: {str(e)}")
+            print(traceback.format_exc())
+            return WeightAllocationResult(
+                dynamic_weights=self.default_weights.copy(),
+                allocation_method='fallback'
+            )
+
+    def _normalize_dimension_names(self,
+                                   priorities: Dict[str, float]) -> Dict[str, float]:
+        """標準化維度名稱"""
+        normalized = {}
+        for dim, score in priorities.items():
+            mapped_dim = self.dimension_name_mapping.get(dim, dim)
+            # 如果mapped_dim不在default_weights中，保留原維度名
+            if mapped_dim not in self.default_weights:
+                mapped_dim = dim
+            normalized[mapped_dim] = max(normalized.get(mapped_dim, 1.0), score)
+        return normalized
+
+    def _allocate_default_weights(self,
+                                 user_mentions: Set[str]) -> WeightAllocationResult:
+        """分配預設平衡權重"""
+        weights = self.default_weights.copy()
+        notes = ["Using default balanced weights (no priorities detected)"]
+
+        return WeightAllocationResult(
+            dynamic_weights=weights,
+            allocation_notes=notes
+        )
+
+    def _allocate_contextual_weights(self,
+                                    priorities: Dict[str, float],
+                                    user_mentions: Set[str]) -> WeightAllocationResult:
+        """
+        情境相對權重分配（關鍵維度50%）
+        """
+        weights = {}
+        notes = []
+
+        # 標準化user_mentions維度名稱
+        normalized_mentions = set()
+        for mention in user_mentions:
+            normalized_name = self.dimension_name_mapping.get(mention, mention)
+            if normalized_name in self.default_weights:
+                normalized_mentions.add(normalized_name)
+
+        # 分類維度
+        critical_dims = [d for d, s in priorities.items() if s >= self.high_priority_threshold]
+        mentioned_dims = [d for d in normalized_mentions if d not in critical_dims]
+        other_dims = [d for d in self.default_weights.keys()
+                     if d not in critical_dims and d not in mentioned_dims]
+
+        # 權重分配
+        total_critical = self.contextual_weight_distribution['critical_dimensions_weight']
+        total_mentioned = self.contextual_weight_distribution['mentioned_dimensions_weight']
+        total_other = self.contextual_weight_distribution['other_dimensions_weight']
+
+        # 關鍵維度：按優先級比例分配50%
+        if critical_dims:
+            critical_priority_sum = sum(priorities.get(d, 1.0) for d in critical_dims)
+            for dim in critical_dims:
+                weight = (priorities.get(dim, 1.0) / critical_priority_sum) * total_critical
+                weights[dim] = weight
+            notes.append(f"Critical dimensions ({len(critical_dims)}): {total_critical:.0%} weight")
+
+        # 提及維度：平均分配35%
+        if mentioned_dims:
+            for dim in mentioned_dims:
+                weights[dim] = total_mentioned / len(mentioned_dims)
+            notes.append(f"Mentioned dimensions ({len(mentioned_dims)}): {total_mentioned:.0%} weight")
+
+        # 其他維度：平均分配15%
+        if other_dims:
+            for dim in other_dims:
+                weights[dim] = total_other / len(other_dims)
+            notes.append(f"Other dimensions ({len(other_dims)}): {total_other:.0%} weight")
+
+        # 填充未覆蓋的維度
+        for dim in self.default_weights.keys():
+            if dim not in weights:
+                weights[dim] = 0.05
+
+        return WeightAllocationResult(
+            dynamic_weights=weights,
+            allocation_notes=notes
+        )
+
+    def _allocate_single_priority(self,
+                                 priorities: Dict[str, float],
+                                 user_mentions: Set[str]) -> WeightAllocationResult:
+        """單一高優先級：固定預留40%"""
+        weights = {}
+        notes = []
+
+        # 找到高優先級維度
+        high_priority_dim = None
+        max_priority = 0
+        for dim, score in priorities.items():
+            if score >= self.high_priority_threshold and score > max_priority:
+                high_priority_dim = dim
+                max_priority = score
+
+        if high_priority_dim:
+            # 高優先級維度：40%
+            weights[high_priority_dim] = 0.40
+            notes.append(f"{high_priority_dim}: 40% (high priority)")
+
+            # 其他維度：平均分配剩餘60%
+            other_dims = [d for d in self.default_weights.keys() if d != high_priority_dim]
+            remaining_weight = 0.60
+            for dim in other_dims:
+                weights[dim] = remaining_weight / len(other_dims)
+        else:
+            weights = self.default_weights.copy()
+
+        return WeightAllocationResult(
+            dynamic_weights=weights,
+            allocation_notes=notes
+        )
+
+    def _allocate_multiple_priorities_fixed(self,
+                                          priorities: Dict[str, float],
+                                          user_mentions: Set[str],
+                                          high_count: int) -> WeightAllocationResult:
+        """2-3個高優先級：階梯固定預留法"""
+        weights = {}
+        notes = []
+
+        # 排序高優先級維度
+        high_priority_dims = sorted(
+            [(dim, score) for dim, score in priorities.items()
+             if score >= self.high_priority_threshold],
+            key=lambda x: x[1],
+            reverse=True
+        )
+
+        # 根據數量分配固定權重
+        if high_count == 2:
+            # 2個高優先級：40% + 25%
+            fixed_weights = [0.40, 0.25]
+            remaining = 0.35
+            notes.append("2 high priorities: 40% + 25%, others share 35%")
+        elif high_count == 3:
+            # 3個高優先級：30% + 27% + 23%
+            fixed_weights = [0.30, 0.27, 0.23]
+            remaining = 0.20
+            notes.append("3 high priorities: 30% + 27% + 23%, others share 20%")
+        else:
+            # 降級處理
+            return self._allocate_multiple_priorities_proportional(
+                priorities, user_mentions
+            )
+
+        # 分配固定權重
+        for i, (dim, score) in enumerate(high_priority_dims[:high_count]):
+            weights[dim] = fixed_weights[i]
+
+        # 其他維度：平均分配剩餘
+        other_dims = [d for d in self.default_weights.keys()
+                     if d not in [dim for dim, _ in high_priority_dims[:high_count]]]
+        if other_dims:
+            for dim in other_dims:
+                weights[dim] = remaining / len(other_dims)
+
+        return WeightAllocationResult(
+            dynamic_weights=weights,
+            allocation_notes=notes
+        )
+
+    def _allocate_multiple_priorities_proportional(self,
+                                                  priorities: Dict[str, float],
+                                                  user_mentions: Set[str]) -> WeightAllocationResult:
+        """4+個高優先級：倍數正規化法"""
+        weights = {}
+        notes = []
+
+        # 計算原始權重（基於優先級倍數）
+        raw_weights = {}
+        for dim in self.default_weights.keys():
+            priority_score = priorities.get(dim, 1.0)
+            raw_weights[dim] = 1.0 * priority_score
+
+        # 正規化
+        total_raw = sum(raw_weights.values())
+        for dim, raw_weight in raw_weights.items():
+            weights[dim] = raw_weight / total_raw
+
+        notes.append(f"Proportional allocation for {len([d for d, s in priorities.items() if s >= self.high_priority_threshold])} high priorities")
+
+        return WeightAllocationResult(
+            dynamic_weights=weights,
+            allocation_notes=notes
+        )
+
+    def _apply_weight_floor(self, weights: Dict[str, float]) -> Dict[str, float]:
+        """應用最低權重保護"""
+        protected_weights = {}
+        for dim, weight in weights.items():
+            protected_weights[dim] = max(self.min_weight_floor, weight)
+        return protected_weights
+
+    def _normalize_weights(self, weights: Dict[str, float]) -> Dict[str, float]:
+        """正規化權重確保總和為1.0"""
+        total = sum(weights.values())
+        if total == 0:
+            return self.default_weights.copy()
+
+        normalized = {dim: weight / total for dim, weight in weights.items()}
+        return normalized
+
+    def get_weight_summary(self, result: WeightAllocationResult) -> Dict[str, Any]:
+        """
+        獲取權重分配摘要
+
+        Args:
+            result: 權重分配結果
+
+        Returns:
+            Dict[str, Any]: 權重摘要
+        """
+        return {
+            'allocation_method': result.allocation_method,
+            'high_priority_count': result.high_priority_count,
+            'weight_sum': result.weight_sum,
+            'weights': result.dynamic_weights,
+            'top_3_dimensions': sorted(
+                result.dynamic_weights.items(),
+                key=lambda x: x[1],
+                reverse=True
+            )[:3],
+            'allocation_notes': result.allocation_notes
+        }
+
+
+def calculate_weights_from_priorities(dimension_priorities: Dict[str, float],
+                                     user_mentions: Optional[Set[str]] = None,
+                                     use_contextual: bool = True) -> WeightAllocationResult:
+    """
+    便利函數: 從優先級計算權重
+
+    Args:
+        dimension_priorities: 維度優先級
+        user_mentions: 使用者提及的維度
+        use_contextual: 使用情境相對評分
+
+    Returns:
+        WeightAllocationResult: 權重分配結果
+    """
+    calculator = DynamicWeightCalculator()
+    return calculator.calculate_dynamic_weights(
+        dimension_priorities, user_mentions, use_contextual
+    )
+
+
+def get_weight_summary(dimension_priorities: Dict[str, float],
+                      user_mentions: Optional[Set[str]] = None) -> Dict[str, Any]:
+    """
+    便利函數: 獲取權重摘要
+
+    Args:
+        dimension_priorities: 維度優先級
+        user_mentions: 使用者提及的維度
+
+    Returns:
+        Dict[str, Any]: 權重摘要
+    """
+    calculator = DynamicWeightCalculator()
+    result = calculator.calculate_dynamic_weights(dimension_priorities, user_mentions)
+    return calculator.get_weight_summary(result)

inference_engine.py

@@ -0,0 +1,408 @@
+# %%writefile inference_engine.py
+import re
+import numpy as np
+from typing import Dict, List, Tuple, Set, Optional, Any, Callable
+from dataclasses import dataclass, field
+import traceback
+
+
+@dataclass
+class InferenceRule:
+    """推理規則結構"""
+    name: str
+    condition: Callable[[str, Dict[str, Any]], bool]
+    imply: Callable[[str, Dict[str, Any]], Dict[str, float]]
+    reasoning: str
+    priority: int = 1  # 規則優先級
+
+
+@dataclass
+class InferenceResult:
+    """推理結果結構"""
+    implicit_priorities: Dict[str, float] = field(default_factory=dict)
+    triggered_rules: List[str] = field(default_factory=list)
+    reasoning_chains: List[str] = field(default_factory=list)
+    confidence: float = 1.0
+
+
+class BreedRecommendationInferenceEngine:
+    """
+    品種推薦推理引擎
+    從使用者明確輸入中推斷隱含需求，補充優先級設定
+
+    核心邏輯:
+    1. 居住環境推理 (公寓 → 安靜、中小型)
+    2. 家庭情況推理 (有小孩 → 溫和、耐心)
+    3. 經驗程度推理 (新手 → 易照顧)
+    4. 生活方式推理 (忙碌 → 低維護)
+    """
+
+    def __init__(self):
+        """初始化推理引擎"""
+        self.inference_rules = self._build_inference_rules()
+        self.spatial_keywords = self._initialize_spatial_keywords()
+        self.lifestyle_keywords = self._initialize_lifestyle_keywords()
+
+    def _initialize_spatial_keywords(self) -> Dict[str, List[str]]:
+        """初始化空間相關關鍵字"""
+        return {
+            'apartment': [
+                'apartment', 'flat', 'condo', 'studio',
+                'small space', 'limited space', 'city living', 'urban'
+            ],
+            'small_house': [
+                'small house', 'townhouse', 'small home'
+            ],
+            'large_house': [
+                'large house', 'big house', 'spacious home',
+                'yard', 'garden', 'backyard', 'outdoor space'
+            ]
+        }
+
+    def _initialize_lifestyle_keywords(self) -> Dict[str, List[str]]:
+        """初始化生活方式關鍵字"""
+        return {
+            'has_children': [
+                'kids', 'children', 'toddler', 'baby', 'school age',
+                'child', 'son', 'daughter', 'family with kids'
+            ],
+            'beginner': [
+                'first dog', 'first time', 'beginner', 'never had',
+                'new to dogs', 'inexperienced', 'no experience'
+            ],
+            'busy': [
+                'busy', 'limited time', 'work full time', 'not much time',
+                'long hours', 'busy schedule', 'hectic lifestyle'
+            ],
+            'active': [
+                'active', 'athletic', 'outdoor', 'hiking', 'running',
+                'jogging', 'sports', 'exercise enthusiast'
+            ]
+        }
+
+    def _build_inference_rules(self) -> List[InferenceRule]:
+        """構建推理規則庫"""
+        return [
+            # 規則1: 公寓居住推理
+            InferenceRule(
+                name="apartment_living",
+                condition=lambda input_text, ctx: self._check_apartment(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'noise': 1.3,      # 公寓暗示需要安靜 (reduced from 1.4)
+                    'size': 1.2,       # 公寓暗示偏好中小型 (reduced from 1.3)
+                    'exercise': 1.15   # 公寓暗示可能運動空間有限 (reduced from 1.2)
+                },
+                reasoning="Apartment living typically requires quieter, smaller dogs with moderate exercise needs",
+                priority=1
+            ),
+
+            # 規則2: 有小孩推理
+            InferenceRule(
+                name="has_children",
+                condition=lambda input_text, ctx: self._check_children(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'family': 1.4,     # 明確需要家庭友善 (reduced from 1.5)
+                    'experience': 1.15, # 暗示希望容易訓練 (reduced from 1.2)
+                    'noise': 1.15      # 有小孩通常希望狗較安靜 (reduced from 1.2)
+                },
+                reasoning="Families with children need gentle, patient, child-safe breeds",
+                priority=1
+            ),
+
+            # 規則3: 新手飼主推理
+            InferenceRule(
+                name="beginner_owner",
+                condition=lambda input_text, ctx: self._check_beginner(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'experience': 1.3,  # 需要容易照顧 (reduced from 1.4)
+                    'grooming': 1.25,   # 偏好低維護 (reduced from 1.3)
+                    'health': 1.15      # 希望健康問題少 (reduced from 1.2)
+                },
+                reasoning="Beginners benefit from easier-to-care-for, low-maintenance breeds",
+                priority=1
+            ),
+
+            # 規則4: 忙碌生活方式推理
+            InferenceRule(
+                name="busy_lifestyle",
+                condition=lambda input_text, ctx: self._check_busy(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'grooming': 1.3,    # 需要低維護 (reduced from 1.4)
+                    'exercise': 1.25,   # 不能需要太多運動 (reduced from 1.3)
+                    'experience': 1.15  # 希望獨立性強 (reduced from 1.2)
+                },
+                reasoning="Busy owners need lower-maintenance breeds with moderate exercise needs",
+                priority=1
+            ),
+
+            # 規則5: 大型住宅推理
+            InferenceRule(
+                name="large_house",
+                condition=lambda input_text, ctx: self._check_large_house(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'size': 1.15,      # 可以接受大型犬 (reduced from 1.2)
+                    'exercise': 1.2    # 可能有更多運動空間 (reduced from 1.3)
+                },
+                reasoning="Large homes can accommodate more active, larger breeds",
+                priority=2
+            ),
+
+            # 規則6: 有院子推理
+            InferenceRule(
+                name="has_yard",
+                condition=lambda input_text, ctx: self._check_yard(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'exercise': 1.2,   # 有院子可以支持更活躍的品種 (reduced from 1.3)
+                    'size': 1.15       # 可以考慮較大的品種 (reduced from 1.2)
+                },
+                reasoning="Yards provide exercise space for more active breeds",
+                priority=2
+            ),
+
+            # 規則7: 噪音敏感環境推理
+            InferenceRule(
+                name="noise_sensitive",
+                condition=lambda input_text, ctx: self._check_noise_sensitive(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'noise': 1.5       # 強調需要安靜 (reduced from 1.6)
+                },
+                reasoning="Noise-sensitive environments require quieter breeds",
+                priority=1
+            ),
+
+            # 規則8: 過敏體質推理
+            InferenceRule(
+                name="allergy_concerns",
+                condition=lambda input_text, ctx: self._check_allergies(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'grooming': 1.4,   # 需要低掉毛品種 (reduced from 1.5)
+                    'health': 1.25     # 關注健康問題 (reduced from 1.3)
+                },
+                reasoning="Allergy concerns require hypoallergenic, low-shedding breeds",
+                priority=1
+            ),
+
+            # 規則9: 活躍生活方式推理
+            InferenceRule(
+                name="active_lifestyle",
+                condition=lambda input_text, ctx: self._check_active(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'exercise': 1.3,   # 需要高運動量品種 (reduced from 1.4)
+                    'size': 1.15       # 可能偏好中大型犬 (reduced from 1.2)
+                },
+                reasoning="Active lifestyle matches well with energetic, athletic breeds",
+                priority=1
+            ),
+
+            # 規則10: 小型空間推理
+            InferenceRule(
+                name="small_space",
+                condition=lambda input_text, ctx: self._check_small_space(input_text, ctx),
+                imply=lambda input_text, ctx: {
+                    'size': 1.3,       # 強調需要小型犬 (reduced from 1.4)
+                    'noise': 1.25,     # 小空間需要安靜 (reduced from 1.3)
+                    'exercise': 1.15   # 運動需求不宜過高 (reduced from 1.2)
+                },
+                reasoning="Small spaces require compact, quiet dogs with moderate energy",
+                priority=1
+            )
+        ]
+
+    def _check_apartment(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否提到公寓"""
+        text_lower = input_text.lower()
+        return (any(keyword in text_lower for keyword in self.spatial_keywords['apartment']) or
+                ctx.get('living_space') == 'apartment')
+
+    def _check_children(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否有小孩"""
+        text_lower = input_text.lower()
+        return (any(keyword in text_lower for keyword in self.lifestyle_keywords['has_children']) or
+                ctx.get('has_children') == True)
+
+    def _check_beginner(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否為新手"""
+        text_lower = input_text.lower()
+        return (any(keyword in text_lower for keyword in self.lifestyle_keywords['beginner']) or
+                ctx.get('experience_level') == 'beginner')
+
+    def _check_busy(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否為忙碌��活方式"""
+        text_lower = input_text.lower()
+        return (any(keyword in text_lower for keyword in self.lifestyle_keywords['busy']) or
+                ctx.get('time_availability') == 'limited')
+
+    def _check_large_house(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否有大房子"""
+        text_lower = input_text.lower()
+        return (any(keyword in text_lower for keyword in self.spatial_keywords['large_house']) or
+                ctx.get('living_space') in ['house_large', 'house'])
+
+    def _check_yard(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否有院子"""
+        text_lower = input_text.lower()
+        return (any(keyword in text_lower for keyword in ['yard', 'garden', 'backyard', 'outdoor space']) or
+                ctx.get('yard_access') in ['shared_yard', 'private_yard'])
+
+    def _check_noise_sensitive(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否為噪音敏感環境"""
+        text_lower = input_text.lower()
+        noise_keywords = ['noise sensitive', 'thin walls', 'neighbors close', 'townhouse', 'condo']
+        return any(keyword in text_lower for keyword in noise_keywords)
+
+    def _check_allergies(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否有過敏體質"""
+        text_lower = input_text.lower()
+        allergy_keywords = ['allergies', 'hypoallergenic', 'sensitive to fur', 'asthma', 'allergy']
+        return (any(keyword in text_lower for keyword in allergy_keywords) or
+                ctx.get('has_allergies') == True)
+
+    def _check_active(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否為活躍生活方式"""
+        text_lower = input_text.lower()
+        return (any(keyword in text_lower for keyword in self.lifestyle_keywords['active']) or
+                ctx.get('activity_level') == 'high')
+
+    def _check_small_space(self, input_text: str, ctx: Dict[str, Any]) -> bool:
+        """檢查是否為小型空間"""
+        text_lower = input_text.lower()
+        small_space_keywords = ['small space', 'limited space', 'tiny', 'compact', 'studio']
+        return any(keyword in text_lower for keyword in small_space_keywords)
+
+    def infer_implicit_priorities(self,
+                                  explicit_input: str,
+                                  user_context: Optional[Dict[str, Any]] = None) -> InferenceResult:
+        """
+        從明確輸入和使用者上下文推斷隱含優先級
+
+        Args:
+            explicit_input: 使用者明確輸入
+            user_context: 使用者上下文資訊
+
+        Returns:
+            InferenceResult: 推理結果
+        """
+        try:
+            if user_context is None:
+                user_context = {}
+
+            implicit_priorities = {}
+            triggered_rules = []
+            reasoning_chains = []
+
+            # 按優先級排序規則
+            sorted_rules = sorted(self.inference_rules, key=lambda r: r.priority)
+
+            # 應用推理規則
+            for rule in sorted_rules:
+                try:
+                    if rule.condition(explicit_input, user_context):
+                        # 規則觸發
+                        implied = rule.imply(explicit_input, user_context)
+                        triggered_rules.append(rule.name)
+                        reasoning_chains.append(rule.reasoning)
+
+                        # 合併隱含優先級（取最大值）
+                        for dim, score in implied.items():
+                            implicit_priorities[dim] = max(
+                                implicit_priorities.get(dim, 1.0),
+                                score
+                            )
+                except Exception as e:
+                    print(f"Error applying rule {rule.name}: {str(e)}")
+                    continue
+
+            # 計算信心度
+            confidence = self._calculate_inference_confidence(
+                triggered_rules, explicit_input
+            )
+
+            return InferenceResult(
+                implicit_priorities=implicit_priorities,
+                triggered_rules=triggered_rules,
+                reasoning_chains=reasoning_chains,
+                confidence=confidence
+            )
+
+        except Exception as e:
+            print(f"Error inferring implicit priorities: {str(e)}")
+            print(traceback.format_exc())
+            return InferenceResult()
+
+    def _calculate_inference_confidence(self,
+                                       triggered_rules: List[str],
+                                       input_text: str) -> float:
+        """
+        計算推理信心度
+
+        Args:
+            triggered_rules: 觸發的規則列表
+            input_text: 輸入文字
+
+        Returns:
+            float: 信心度 (0-1)
+        """
+        base_confidence = 0.6
+
+        # 觸發的規則越多，信心度越高
+        rule_bonus = min(0.3, len(triggered_rules) * 0.1)
+
+        # 輸入文字越詳細，信心度越高
+        word_count = len(input_text.split())
+        detail_bonus = min(0.1, word_count / 100)
+
+        return min(1.0, base_confidence + rule_bonus + detail_bonus)
+
+    def get_inference_summary(self, result: InferenceResult) -> Dict[str, Any]:
+        """
+        獲取推理摘要
+
+        Args:
+            result: 推理結果
+
+        Returns:
+            Dict[str, Any]: 推理摘要
+        """
+        return {
+            'total_implicit_priorities': len(result.implicit_priorities),
+            'implicit_priorities': result.implicit_priorities,
+            'triggered_rules': result.triggered_rules,
+            'reasoning_chains': result.reasoning_chains,
+            'inference_confidence': result.confidence,
+            'high_confidence_inferences': [
+                dim for dim, score in result.implicit_priorities.items() if score >= 1.4
+            ]
+        }
+
+
+def infer_user_priorities(user_input: str,
+                         user_context: Optional[Dict[str, Any]] = None) -> InferenceResult:
+    """
+    便利函數: 推斷使用者隱含優先級
+
+    Args:
+        user_input: 使用者輸入
+        user_context: 使用者上下文
+
+    Returns:
+        InferenceResult: 推理結果
+    """
+    engine = BreedRecommendationInferenceEngine()
+    return engine.infer_implicit_priorities(user_input, user_context)
+
+
+def get_inference_summary(user_input: str,
+                         user_context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """
+    便利函數: 獲取推理摘要
+
+    Args:
+        user_input: 使用者輸入
+        user_context: 使用者上下文
+
+    Returns:
+        Dict[str, Any]: 推理摘要
+    """
+    engine = BreedRecommendationInferenceEngine()
+    result = engine.infer_implicit_priorities(user_input, user_context)
+    return engine.get_inference_summary(result)

matching_score_calculator.py

@@ -1,3 +1,4 @@
+# %%writefile matching_score_calculator.py
 import random
 import hashlib
 import numpy as np
@@ -483,7 +484,13 @@ class MatchingScoreCalculator:
             # 家庭相容性 (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)  # 經驗需求基於語意相似度
+
+            # 經驗相容性 - 使用真實品種特性計算
+            experience_requirements = self._analyze_experience_requirements(user_desc)
+            experience_score = self._calculate_experience_compatibility(
+                experience_requirements, breed_info, breed_temperament
+            )
+            dimension_scores['experience'] = experience_score
 
             # 應用硬約束過濾
             constraint_penalty = self._apply_hard_constraints_enhanced(user_desc, breed_info)
@@ -786,6 +793,134 @@ class MatchingScoreCalculator:
 
         return 0.7
 
+    def _analyze_experience_requirements(self, user_desc: str) -> dict:
+        """分析用戶經驗水平需求"""
+        requirements = {'level': 'intermediate', 'importance': 0.5}
+
+        # 新手識別 - 關鍵詞匹配
+        beginner_terms = ['first dog', 'first time', 'beginner', 'new to dogs', 'inexperienced',
+                         'never owned', 'never had a dog', 'first-time owner', 'my first']
+        if any(term in user_desc for term in beginner_terms):
+            requirements['level'] = 'beginner'
+            requirements['importance'] = 0.95  # 對新手非常重要
+
+        # 高級用戶識別
+        advanced_terms = ['experienced', 'advanced', 'expert', 'breeder', 'trainer', 'many dogs']
+        if any(term in user_desc for term in advanced_terms):
+            requirements['level'] = 'advanced'
+            requirements['importance'] = 0.6
+
+        # 易於訓練需求
+        if any(term in user_desc for term in ['easy to train', 'trainable', 'obedient', 'well-behaved']):
+            requirements['needs_easy_training'] = True
+            requirements['importance'] = max(requirements['importance'], 0.85)
+
+        # 低維護需求通常暗示需要更易處理的品種
+        if any(term in user_desc for term in ['low maintenance', 'low-maintenance', 'easy care']):
+            requirements['needs_easy_care'] = True
+            if requirements['level'] == 'intermediate':
+                requirements['level'] = 'beginner'  # 低維護需求暗示初學者
+                requirements['importance'] = 0.85
+
+        return requirements
+
+    def _calculate_experience_compatibility(self, experience_req: dict, breed_info: dict, temperament: str) -> float:
+        """
+        計算經驗相容性分數 - 基於品種特性和用戶經驗水平
+
+        這是修復的關鍵函數！確保敏感/難以處理的品種對新手有低分數
+        """
+        care_level = breed_info.get('Care Level', 'Moderate').lower()
+        temperament_lower = temperament.lower()
+        user_level = experience_req.get('level', 'intermediate')
+
+        # 基礎分數矩陣
+        base_scores = {
+            'high': {
+                'beginner': 0.45,      # 高照護品種對新手困難
+                'intermediate': 0.75,
+                'advanced': 0.90
+            },
+            'moderate': {
+                'beginner': 0.65,
+                'intermediate': 0.85,
+                'advanced': 0.90
+            },
+            'low': {
+                'beginner': 0.85,      # 低照護品種對新手友善
+                'intermediate': 0.90,
+                'advanced': 0.90
+            }
+        }
+
+        # 獲取基礎分數
+        score = base_scores.get(care_level, base_scores['moderate']).get(user_level, 0.70)
+
+        # 性格特徵調整 - 對新手特別重要
+        if user_level == 'beginner':
+            # 困難性格懲罰
+            difficult_traits = {
+                'sensitive': -0.20,      # 敏感品種對新手非常困難（需要細心處理）
+                'stubborn': -0.15,
+                'independent': -0.12,
+                'dominant': -0.15,
+                'aggressive': -0.25,
+                'nervous': -0.15,
+                'alert': -0.08,          # 過度警覺可能導致吠叫問題
+                'shy': -0.12,
+                'timid': -0.12,
+                'strong-willed': -0.12,
+                'protective': -0.10
+            }
+
+            for trait, penalty in difficult_traits.items():
+                if trait in temperament_lower:
+                    score += penalty
+
+            # 友善性格獎勵
+            easy_traits = {
+                'gentle': 0.10,
+                'friendly': 0.12,
+                'eager to please': 0.15,
+                'patient': 0.10,
+                'calm': 0.10,
+                'outgoing': 0.08,
+                'affectionate': 0.08,
+                'playful': 0.05,       # 輕微加分（可能太活潑）
+                'loyal': 0.05
+            }
+
+            for trait, bonus in easy_traits.items():
+                if trait in temperament_lower:
+                    score += bonus
+
+            # 易於訓練需求額外懲罰/獎勵
+            if experience_req.get('needs_easy_training'):
+                if any(term in temperament_lower for term in ['stubborn', 'independent', 'strong-willed']):
+                    score -= 0.12
+                elif any(term in temperament_lower for term in ['eager to please', 'intelligent', 'trainable']):
+                    score += 0.10
+
+            # Good with Children = No 對新手也是警示
+            good_with_children = breed_info.get('Good with Children', 'Yes')
+            if good_with_children == 'No':
+                score -= 0.08  # 額外扣分：不適合兒童的狗通常對新手也更具挑戰
+
+        elif user_level == 'intermediate':
+            # 中級用戶的適度調整
+            if 'stubborn' in temperament_lower:
+                score -= 0.05
+            if 'independent' in temperament_lower:
+                score -= 0.03
+
+        elif user_level == 'advanced':
+            # 高級用戶可以處理具挑戰性的品種
+            if any(term in temperament_lower for term in ['intelligent', 'working', 'athletic']):
+                score += 0.05
+
+        # 確保分數在合理範圍內
+        return max(0.15, min(0.95, score))
+
     def _apply_hard_constraints_enhanced(self, user_desc: str, breed_info: dict) -> float:
         """應用品種特性感知的動態懲罰機制"""
         penalty = 0.0
@@ -869,12 +1004,15 @@ class MatchingScoreCalculator:
 
         # 添加特殊品種適應性補償機制
         # 對於邊界適配品種，給予適度補償
+        # 注意：僅補償真正對新手友善的品種
         boundary_adaptable_breeds = {
-            'Italian_Greyhound': 0.08,  # 安靜、低維護的小型犬
+            # 'Italian_Greyhound' 已移除：Sensitive 性格對新手不友好
             'Boston_Bull': 0.06,        # 適應性強的小型犬
             'Havanese': 0.05,           # 友好適應的小型犬
             'Silky_terrier': 0.04,      # 安靜的玩具犬
-            'Basset': 0.07              # 低能量但友好的中型犬
+            'Basset': 0.07,             # 低能量但友好的中型犬
+            'Cavalier_King_Charles_Spaniel': 0.08,  # 溫和友善，適合新手
+            'Bichon_Frise': 0.06        # 友善易訓練
         }
 
         if breed_name in boundary_adaptable_breeds:

multi_head_scorer.py

@@ -1,3 +1,4 @@
+# %%writefile multi_head_scorer.py 
 import numpy as np
 import json
 from typing import Dict, List, Tuple, Optional, Any, Set
@@ -11,6 +12,9 @@ from breed_health_info import breed_health_info
 from breed_noise_info import breed_noise_info
 from query_understanding import QueryDimensions
 from constraint_manager import FilterResult
+from dynamic_weight_calculator import DynamicWeightCalculator, WeightAllocationResult
+from adaptive_score_distribution import AdaptiveScoreDistribution, DistributionResult
+from dimension_score_calculator import DimensionScoreCalculator
 
 @dataclass
 class DimensionalScores:
@@ -142,165 +146,190 @@ class SemanticScoringHead(ScoringHead):
         return f"{breed_name} is a dog breed with various characteristics"
 
 class AttributeScoringHead(ScoringHead):
-    """屬性評分頭"""
+    """
+    屬性評分頭 - 使用DimensionScoreCalculator進行精確評分
+    這個類別整合了dimension_score_calculator.py中的精確評分邏輯
+    """
 
     def __init__(self):
-        self.scoring_matrices = self._initialize_scoring_matrices()
-
-    def _initialize_scoring_matrices(self) -> Dict[str, Dict[str, float]]:
-        """初始化評分矩陣"""
-        return {
-            'spatial_scoring': {
-                # (user_preference, breed_attribute) -> score
-                ('apartment', 'small'): 1.0,
-                ('apartment', 'medium'): 0.6,
-                ('apartment', 'large'): 0.2,
-                ('apartment', 'giant'): 0.0,
-                ('house', 'small'): 0.7,
-                ('house', 'medium'): 0.9,
-                ('house', 'large'): 1.0,
-                ('house', 'giant'): 1.0,
-            },
-            'activity_scoring': {
-                ('low', 'low'): 1.0,
-                ('low', 'moderate'): 0.7,
-                ('low', 'high'): 0.2,
-                ('low', 'very high'): 0.0,
-                ('moderate', 'low'): 0.8,
-                ('moderate', 'moderate'): 1.0,
-                ('moderate', 'high'): 0.8,
-                ('high', 'moderate'): 0.7,
-                ('high', 'high'): 1.0,
-                ('high', 'very high'): 1.0,
-            },
-            'noise_scoring': {
-                ('low', 'low'): 1.0,
-                ('low', 'moderate'): 0.6,
-                ('low', 'high'): 0.1,
-                ('moderate', 'low'): 0.8,
-                ('moderate', 'moderate'): 1.0,
-                ('moderate', 'high'): 0.7,
-                ('high', 'low'): 0.7,
-                ('high', 'moderate'): 0.9,
-                ('high', 'high'): 1.0,
-            },
-            'size_scoring': {
-                ('small', 'small'): 1.0,
-                ('small', 'medium'): 0.5,
-                ('small', 'large'): 0.2,
-                ('medium', 'small'): 0.6,
-                ('medium', 'medium'): 1.0,
-                ('medium', 'large'): 0.6,
-                ('large', 'medium'): 0.7,
-                ('large', 'large'): 1.0,
-                ('large', 'giant'): 0.9,
-            },
-            'maintenance_scoring': {
-                ('low', 'low'): 1.0,
-                ('low', 'moderate'): 0.6,
-                ('low', 'high'): 0.2,
-                ('moderate', 'low'): 0.8,
-                ('moderate', 'moderate'): 1.0,
-                ('moderate', 'high'): 0.7,
-                ('high', 'low'): 0.6,
-                ('high', 'moderate'): 0.8,
-                ('high', 'high'): 1.0,
-            }
-        }
+        self.dimension_calculator = DimensionScoreCalculator()
 
     def score_dimension(self, breed_info: Dict[str, Any],
                        dimensions: QueryDimensions,
                        dimension_type: str) -> float:
-        """屬性維度評分"""
+        """屬性維度評分 - 使用精確的DimensionScoreCalculator"""
         try:
-            if dimension_type.startswith('spatial_'):
+            if 'spatial' in dimension_type:
                 return self._score_spatial_compatibility(breed_info, dimensions)
-            elif dimension_type.startswith('activity_'):
+            elif 'activity' in dimension_type:
                 return self._score_activity_compatibility(breed_info, dimensions)
-            elif dimension_type.startswith('noise_'):
+            elif 'noise' in dimension_type:
                 return self._score_noise_compatibility(breed_info, dimensions)
-            elif dimension_type.startswith('size_'):
+            elif 'size' in dimension_type:
                 return self._score_size_compatibility(breed_info, dimensions)
-            elif dimension_type.startswith('family_'):
+            elif 'family' in dimension_type:
                 return self._score_family_compatibility(breed_info, dimensions)
-            elif dimension_type.startswith('maintenance_'):
+            elif 'maintenance' in dimension_type:
                 return self._score_maintenance_compatibility(breed_info, dimensions)
+            elif 'experience' in dimension_type:
+                return self._score_experience_compatibility(breed_info, dimensions)
+            elif 'health' in dimension_type:
+                return self._score_health_compatibility(breed_info, dimensions)
             else:
-                return 0.5  # 預設中性分數
+                return 0.5
 
         except Exception as e:
             print(f"Error in attribute scoring for {dimension_type}: {str(e)}")
             return 0.5
 
+    def _get_user_living_space(self, dimensions: QueryDimensions) -> str:
+        """從dimensions提取居住空間類型"""
+        if dimensions.spatial_constraints:
+            for constraint in dimensions.spatial_constraints:
+                if 'apartment' in constraint.lower():
+                    return 'apartment'
+                elif 'house' in constraint.lower():
+                    if 'small' in constraint.lower():
+                        return 'house_small'
+                    return 'house_large'
+        return 'house_small'
+
+    def _get_user_has_yard(self, dimensions: QueryDimensions) -> bool:
+        """從dimensions提取是否有院子"""
+        if dimensions.spatial_constraints:
+            for constraint in dimensions.spatial_constraints:
+                if 'yard' in constraint.lower():
+                    return True
+        return False
+
+    def _get_user_exercise_time(self, dimensions: QueryDimensions) -> int:
+        """從dimensions提取運動時間"""
+        if dimensions.activity_level:
+            for level in dimensions.activity_level:
+                if 'low' in level.lower():
+                    return 30
+                elif 'high' in level.lower():
+                    return 120
+        return 60
+
+    def _get_user_exercise_type(self, dimensions: QueryDimensions) -> str:
+        """從dimensions提取運動類型"""
+        if dimensions.activity_level:
+            for level in dimensions.activity_level:
+                if 'high' in level.lower() or 'active' in level.lower():
+                    return 'active_training'
+                elif 'low' in level.lower():
+                    return 'light_walks'
+        return 'moderate_activity'
+
+    def _get_user_grooming_commitment(self, dimensions: QueryDimensions) -> str:
+        """從dimensions提取美容承諾度"""
+        if dimensions.maintenance_level:
+            for level in dimensions.maintenance_level:
+                if 'low' in level.lower():
+                    return 'low'
+                elif 'high' in level.lower():
+                    return 'high'
+        return 'medium'
+
+    def _get_user_experience_level(self, dimensions: QueryDimensions) -> str:
+        """從dimensions提取經驗等級"""
+        if dimensions.experience_level:
+            for level in dimensions.experience_level:
+                if 'beginner' in level.lower() or 'first' in level.lower():
+                    return 'beginner'
+                elif 'advanced' in level.lower() or 'expert' in level.lower():
+                    return 'advanced'
+        return 'intermediate'
+
     def _score_spatial_compatibility(self, breed_info: Dict[str, Any],
                                    dimensions: QueryDimensions) -> float:
-        """空間相容性評分"""
-        if not dimensions.spatial_constraints:
-            return 0.5
-
-        breed_size = breed_info.get('size', 'medium').lower()
-        total_score = 0.0
+        """空間相容性評分 - 使用DimensionScoreCalculator"""
+        breed_size = breed_info.get('size', 'medium').capitalize()
+        if breed_size.lower() in ['small', 'medium', 'large', 'giant']:
+            breed_size = breed_size.capitalize()
+        else:
+            breed_size = 'Medium'
 
-        for spatial_constraint in dimensions.spatial_constraints:
-            key = (spatial_constraint, breed_size)
-            score = self.scoring_matrices['spatial_scoring'].get(key, 0.5)
-            total_score += score
+        living_space = self._get_user_living_space(dimensions)
+        has_yard = self._get_user_has_yard(dimensions)
+        exercise_needs = breed_info.get('exercise_needs', 'Moderate').capitalize()
 
-        return total_score / len(dimensions.spatial_constraints)
+        return self.dimension_calculator.calculate_space_score(
+            size=breed_size,
+            living_space=living_space,
+            has_yard=has_yard,
+            exercise_needs=exercise_needs
+        )
 
     def _score_activity_compatibility(self, breed_info: Dict[str, Any],
                                     dimensions: QueryDimensions) -> float:
-        """活動相容性評分"""
-        if not dimensions.activity_level:
-            return 0.5
-
-        breed_exercise = breed_info.get('exercise_needs', 'moderate').lower()
-        # 清理品種運動需求字串
-        if 'very high' in breed_exercise:
-            breed_exercise = 'very high'
-        elif 'high' in breed_exercise:
-            breed_exercise = 'high'
-        elif 'low' in breed_exercise:
-            breed_exercise = 'low'
-        else:
-            breed_exercise = 'moderate'
-
-        total_score = 0.0
-        for activity_level in dimensions.activity_level:
-            key = (activity_level, breed_exercise)
-            score = self.scoring_matrices['activity_scoring'].get(key, 0.5)
-            total_score += score
-
-        return total_score / len(dimensions.activity_level)
+        """活動相容性評分 - 使用DimensionScoreCalculator"""
+        breed_exercise = breed_info.get('exercise_needs', 'Moderate').capitalize()
+        exercise_time = self._get_user_exercise_time(dimensions)
+        exercise_type = self._get_user_exercise_type(dimensions)
+        breed_size = breed_info.get('size', 'Medium').capitalize()
+        living_space = self._get_user_living_space(dimensions)
+
+        return self.dimension_calculator.calculate_exercise_score(
+            breed_needs=breed_exercise,
+            exercise_time=exercise_time,
+            exercise_type=exercise_type,
+            breed_size=breed_size,
+            living_space=living_space
+        )
 
     def _score_noise_compatibility(self, breed_info: Dict[str, Any],
                                  dimensions: QueryDimensions) -> float:
-        """噪音相容性評分"""
-        if not dimensions.noise_preferences:
-            return 0.5
-
-        breed_noise = breed_info.get('noise_level', 'moderate').lower()
-        total_score = 0.0
-
-        for noise_pref in dimensions.noise_preferences:
-            key = (noise_pref, breed_noise)
-            score = self.scoring_matrices['noise_scoring'].get(key, 0.5)
-            total_score += score
-
-        return total_score / len(dimensions.noise_preferences)
+        """噪音相容性評分 - 使用DimensionScoreCalculator"""
+        breed_name = breed_info.get('breed_name', '')
+        noise_tolerance = 'medium'
+        if dimensions.noise_preferences:
+            for pref in dimensions.noise_preferences:
+                if 'low' in pref.lower() or 'quiet' in pref.lower():
+                    noise_tolerance = 'low'
+                elif 'high' in pref.lower():
+                    noise_tolerance = 'high'
+
+        living_space = self._get_user_living_space(dimensions)
+        has_children = 'children' in str(dimensions.family_context).lower()
+        children_age = 'school_age'
+
+        return self.dimension_calculator.calculate_noise_score(
+            breed_name=breed_name,
+            noise_tolerance=noise_tolerance,
+            living_space=living_space,
+            has_children=has_children,
+            children_age=children_age
+        )
 
     def _score_size_compatibility(self, breed_info: Dict[str, Any],
                                 dimensions: QueryDimensions) -> float:
         """尺寸相容性評分"""
         if not dimensions.size_preferences:
-            return 0.5
+            return 0.7
 
         breed_size = breed_info.get('size', 'medium').lower()
         total_score = 0.0
 
+        size_compatibility = {
+            ('small', 'small'): 1.0,
+            ('small', 'medium'): 0.5,
+            ('small', 'large'): 0.2,
+            ('small', 'giant'): 0.1,
+            ('medium', 'small'): 0.6,
+            ('medium', 'medium'): 1.0,
+            ('medium', 'large'): 0.7,
+            ('medium', 'giant'): 0.4,
+            ('large', 'small'): 0.3,
+            ('large', 'medium'): 0.7,
+            ('large', 'large'): 1.0,
+            ('large', 'giant'): 0.9,
+        }
+
         for size_pref in dimensions.size_preferences:
-            key = (size_pref, breed_size)
-            score = self.scoring_matrices['size_scoring'].get(key, 0.5)
+            key = (size_pref.lower(), breed_size)
+            score = size_compatibility.get(key, 0.5)
             total_score += score
 
         return total_score / len(dimensions.size_preferences)
@@ -309,7 +338,7 @@ class AttributeScoringHead(ScoringHead):
                                   dimensions: QueryDimensions) -> float:
         """家庭相容性評分"""
         if not dimensions.family_context:
-            return 0.5
+            return 0.7
 
         good_with_children = breed_info.get('good_with_children', 'Yes')
         temperament = breed_info.get('temperament', '').lower()
@@ -319,15 +348,18 @@ class AttributeScoringHead(ScoringHead):
 
         for family_context in dimensions.family_context:
             if family_context == 'children':
-                if good_with_children == 'Yes':
-                    total_score += 1.0
-                elif good_with_children == 'No':
-                    total_score += 0.1
+                if good_with_children == 'Yes' or good_with_children == True:
+                    # 進一步檢查temperament
+                    if any(trait in temperament for trait in ['gentle', 'friendly', 'patient']):
+                        total_score += 1.0
+                    else:
+                        total_score += 0.85
+                elif good_with_children == 'No' or good_with_children == False:
+                    total_score += 0.15
                 else:
-                    total_score += 0.6
+                    total_score += 0.5
                 score_count += 1
             elif family_context == 'elderly':
-                # 溫和、冷靜的品種適合老年人
                 if any(trait in temperament for trait in ['gentle', 'calm', 'docile']):
                     total_score += 1.0
                 elif any(trait in temperament for trait in ['energetic', 'hyperactive']):
@@ -336,7 +368,6 @@ class AttributeScoringHead(ScoringHead):
                     total_score += 0.7
                 score_count += 1
             elif family_context == 'single':
-                # 大多數品種都適合單身人士
                 total_score += 0.8
                 score_count += 1
 
@@ -344,19 +375,44 @@ class AttributeScoringHead(ScoringHead):
 
     def _score_maintenance_compatibility(self, breed_info: Dict[str, Any],
                                        dimensions: QueryDimensions) -> float:
-        """維護相容性評分"""
-        if not dimensions.maintenance_level:
-            return 0.5
-
-        breed_grooming = breed_info.get('grooming_needs', 'moderate').lower()
-        total_score = 0.0
-
-        for maintenance_level in dimensions.maintenance_level:
-            key = (maintenance_level, breed_grooming)
-            score = self.scoring_matrices['maintenance_scoring'].get(key, 0.5)
-            total_score += score
+        """維護相容性評分 - 使用DimensionScoreCalculator"""
+        breed_grooming = breed_info.get('grooming_needs', 'Moderate').capitalize()
+        user_commitment = self._get_user_grooming_commitment(dimensions)
+        breed_size = breed_info.get('size', 'Medium').capitalize()
+        breed_name = breed_info.get('breed_name', '')
+        temperament = breed_info.get('temperament', '')
+
+        return self.dimension_calculator.calculate_grooming_score(
+            breed_needs=breed_grooming,
+            user_commitment=user_commitment,
+            breed_size=breed_size,
+            breed_name=breed_name,
+            temperament=temperament
+        )
+
+    def _score_experience_compatibility(self, breed_info: Dict[str, Any],
+                                       dimensions: QueryDimensions) -> float:
+        """經驗相容性評分 - 使用DimensionScoreCalculator"""
+        care_level = breed_info.get('care_level', 'Moderate').capitalize()
+        user_experience = self._get_user_experience_level(dimensions)
+        temperament = breed_info.get('temperament', '')
+
+        return self.dimension_calculator.calculate_experience_score(
+            care_level=care_level,
+            user_experience=user_experience,
+            temperament=temperament
+        )
+
+    def _score_health_compatibility(self, breed_info: Dict[str, Any],
+                                   dimensions: QueryDimensions) -> float:
+        """健康相容性評分 - 使用DimensionScoreCalculator"""
+        breed_name = breed_info.get('breed_name', '')
+        health_sensitivity = 'medium'
 
-        return total_score / len(dimensions.maintenance_level)
+        return self.dimension_calculator.calculate_health_score(
+            breed_name=breed_name,
+            health_sensitivity=health_sensitivity
+        )
 
 class MultiHeadScorer:
     """
@@ -370,26 +426,31 @@ class MultiHeadScorer:
         self.attribute_head = AttributeScoringHead()
         self.dimension_weights = self._initialize_dimension_weights()
         self.head_fusion_weights = self._initialize_head_fusion_weights()
+        self.weight_calculator = DynamicWeightCalculator()
+        self.score_distributor = AdaptiveScoreDistribution()
 
     def _initialize_dimension_weights(self) -> Dict[str, float]:
         """初始化維度權重"""
         return {
-            'activity_compatibility': 0.35,    # 最高優先級：生活方式匹配
-            'noise_compatibility': 0.25,       # 關鍵：居住和諧
-            'spatial_compatibility': 0.15,     # 基本：物理約束
-            'family_compatibility': 0.10,      # 重要：社交相容性
-            'maintenance_compatibility': 0.10,  # 實際：持續護理評估
-            'size_compatibility': 0.05         # 基本：偏好匹配
+            'activity_compatibility': 0.20,     # 生活方式匹配
+            'noise_compatibility': 0.15,        # 居住和諧
+            'spatial_compatibility': 0.12,      # 物理約束
+            'family_compatibility': 0.12,       # 社交相容性
+            'maintenance_compatibility': 0.15,  # 持續護理評估
+            'experience_compatibility': 0.18,   # 經驗匹配（對新手非常重要）
+            'health_compatibility': 0.08        # 健康考量
         }
 
     def _initialize_head_fusion_weights(self) -> Dict[str, Dict[str, float]]:
         """初始化頭融合權重"""
         return {
-            'activity_compatibility': {'semantic': 0.4, 'attribute': 0.6},
-            'noise_compatibility': {'semantic': 0.3, 'attribute': 0.7},
-            'spatial_compatibility': {'semantic': 0.3, 'attribute': 0.7},
-            'family_compatibility': {'semantic': 0.5, 'attribute': 0.5},
-            'maintenance_compatibility': {'semantic': 0.4, 'attribute': 0.6},
+            'activity_compatibility': {'semantic': 0.3, 'attribute': 0.7},
+            'noise_compatibility': {'semantic': 0.2, 'attribute': 0.8},
+            'spatial_compatibility': {'semantic': 0.2, 'attribute': 0.8},
+            'family_compatibility': {'semantic': 0.4, 'attribute': 0.6},
+            'maintenance_compatibility': {'semantic': 0.2, 'attribute': 0.8},
+            'experience_compatibility': {'semantic': 0.2, 'attribute': 0.8},  # 經驗主要看attribute
+            'health_compatibility': {'semantic': 0.3, 'attribute': 0.7},
             'size_compatibility': {'semantic': 0.2, 'attribute': 0.8}
         }
 
@@ -417,6 +478,19 @@ class MultiHeadScorer:
             # 按最終分數排序
             breed_scores.sort(key=lambda x: x.final_score, reverse=True)
 
+            # 應用自適應分數分佈
+            raw_scores = [(bs.breed_name, bs.final_score) for bs in breed_scores]
+            distribution_result = self.score_distributor.distribute_scores(raw_scores)
+
+            # 更新品種分數
+            score_mapping = {breed: score for breed, score in distribution_result.final_scores}
+            for breed_score in breed_scores:
+                if breed_score.breed_name in score_mapping:
+                    breed_score.final_score = score_mapping[breed_score.breed_name]
+
+            # 重新排序
+            breed_scores.sort(key=lambda x: x.final_score, reverse=True)
+
             return breed_scores
 
         except Exception as e:
@@ -468,9 +542,20 @@ class MultiHeadScorer:
             semantic_total = 0.0
             attribute_total = 0.0
 
-            # 動態權重分配（基於用戶表達的維度）
-            active_dimensions = self._get_active_dimensions(dimensions)
-            adjusted_weights = self._adjust_dimension_weights(active_dimensions)
+            # 動態權重分配（優先使用dimension_priorities）
+            if dimensions.dimension_priorities:
+                # 使用動態權重計算器
+                user_mentions = self._extract_user_mentions(dimensions)
+                weight_result = self.weight_calculator.calculate_dynamic_weights(
+                    dimensions.dimension_priorities,
+                    user_mentions,
+                    use_contextual=True
+                )
+                adjusted_weights = weight_result.dynamic_weights
+            else:
+                # 降級到原有邏輯
+                active_dimensions = self._get_active_dimensions(dimensions)
+                adjusted_weights = self._adjust_dimension_weights(active_dimensions)
 
             # 為每個活躍維度評分
             for dimension, weight in adjusted_weights.items():
@@ -508,8 +593,14 @@ class MultiHeadScorer:
             base_score = sum(score * adjusted_weights[dim]
                            for dim, score in dimensional_scores.items())
 
+            # 關鍵維度低分懲罰機制
+            # 當用戶明確提到某維度且該維度分數很低時，施加額外懲罰
+            critical_penalty = self._calculate_critical_dimension_penalty(
+                dimensional_scores, dimensions, adjusted_weights
+            )
+
             # Apply corrections
-            final_score = max(0.0, min(1.0, base_score + bidirectional_bonus + bias_correction))
+            final_score = max(0.0, min(1.0, base_score + bidirectional_bonus + bias_correction + critical_penalty))
 
             # 信心度評估
             confidence_score = self._calculate_confidence(dimensions)
@@ -549,9 +640,40 @@ class MultiHeadScorer:
             active.add('family_compatibility')
         if dimensions.maintenance_level:
             active.add('maintenance_compatibility')
+        if hasattr(dimensions, 'experience_level') and dimensions.experience_level:
+            active.add('experience_compatibility')
 
         return active
 
+    def _extract_user_mentions(self, dimensions: QueryDimensions) -> Set[str]:
+        """
+        提取使用者明確提到的維度
+
+        Args:
+            dimensions: 查詢維度
+
+        Returns:
+            Set[str]: 使用者提到的維度集合
+        """
+        mentioned = set()
+
+        if dimensions.spatial_constraints:
+            mentioned.add('spatial_compatibility')
+        if dimensions.activity_level:
+            mentioned.add('activity_compatibility')
+        if dimensions.noise_preferences:
+            mentioned.add('noise_compatibility')
+        if dimensions.size_preferences:
+            mentioned.add('size_compatibility')
+        if dimensions.family_context:
+            mentioned.add('family_compatibility')
+        if dimensions.maintenance_level:
+            mentioned.add('maintenance_compatibility')
+        if hasattr(dimensions, 'experience_level') and dimensions.experience_level:
+            mentioned.add('experience_compatibility')
+
+        return mentioned
+
     def _adjust_dimension_weights(self, active_dimensions: Set[str]) -> Dict[str, float]:
         """調整維度權重"""
         if not active_dimensions:
@@ -569,6 +691,90 @@ class MultiHeadScorer:
 
         return active_weights
 
+    def _calculate_critical_dimension_penalty(self,
+                                             dimensional_scores: Dict[str, float],
+                                             dimensions: QueryDimensions,
+                                             weights: Dict[str, float]) -> float:
+        """
+        計算關鍵維度低分懲罰
+
+        當用戶明確提到某維度（通過 dimension_priorities 或活躍維度）
+        且該維度的分數低於閾值時，施加額外懲罰。
+
+        這確保了「不合適」的品種不會因為其他維度的高分而排名過高。
+
+        Args:
+            dimensional_scores: 各維度的分數
+            dimensions: 查詢維度
+            weights: 當前使用的維度權重
+
+        Returns:
+            float: 懲罰值（負數）
+        """
+        total_penalty = 0.0
+
+        # 定義低分閾值和懲罰係數
+        LOW_SCORE_THRESHOLD = 0.55  # 低於此分數視為不匹配
+        VERY_LOW_THRESHOLD = 0.40   # 極低分數
+        PENALTY_MULTIPLIER = 0.25   # 基礎懲罰乘數（提高以增強效果）
+
+        # 檢測用戶關心的維度
+        user_priorities = {}
+
+        # 從 dimension_priorities 獲取優先級
+        if dimensions.dimension_priorities:
+            for dim, priority in dimensions.dimension_priorities.items():
+                # 映射維度名稱
+                mapped_dim = self._map_priority_dimension(dim)
+                if mapped_dim:
+                    user_priorities[mapped_dim] = priority
+
+        # 從活躍維度補充（確保提到的維度都被考慮）
+        active_dims = self._get_active_dimensions(dimensions)
+        for dim in active_dims:
+            if dim not in user_priorities:
+                user_priorities[dim] = 1.2  # 給予基本優先級
+
+        # 對用戶關心的維度檢查低分情況
+        for dim, priority in user_priorities.items():
+            if dim in dimensional_scores:
+                score = dimensional_scores[dim]
+
+                # 只對低分維度施加懲罰
+                if score < LOW_SCORE_THRESHOLD:
+                    # 懲罰程度與以下因素成正比：
+                    # 1. 分數有多低（距離閾值的差距）
+                    # 2. 用戶對該維度的優先級
+                    score_gap = LOW_SCORE_THRESHOLD - score
+                    priority_factor = min(2.0, priority)  # 限制優先級影響
+
+                    penalty = -score_gap * priority_factor * PENALTY_MULTIPLIER
+
+                    # 極低分數額外懲罰
+                    if score < VERY_LOW_THRESHOLD:
+                        penalty *= 1.5
+
+                    total_penalty += penalty
+
+        return total_penalty
+
+    def _map_priority_dimension(self, dim: str) -> str:
+        """將 priority_detector 的維度名稱映射到 multi_head_scorer 使用的名稱"""
+        mapping = {
+            'noise': 'noise_compatibility',
+            'size': 'spatial_compatibility',
+            'exercise': 'activity_compatibility',
+            'activity': 'activity_compatibility',
+            'grooming': 'maintenance_compatibility',
+            'maintenance': 'maintenance_compatibility',
+            'family': 'family_compatibility',
+            'experience': 'experience_compatibility',
+            'health': 'health_compatibility',
+            'spatial': 'spatial_compatibility',
+            'space': 'spatial_compatibility'
+        }
+        return mapping.get(dim, dim if dim.endswith('_compatibility') else None)
+
     def _calculate_bidirectional_bonus(self, breed_info: Dict[str, Any],
                                      dimensions: QueryDimensions) -> float:
         """計算雙向相容性獎勵"""

priority_detector.py

@@ -0,0 +1,462 @@
+# %%writefile priority_detector.py
+import re
+import numpy as np
+from typing import Dict, List, Tuple, Set, Optional, Any
+from dataclasses import dataclass, field
+import traceback
+
+
+@dataclass
+class PriorityDetectionResult:
+    """優先級檢測結果"""
+    dimension_priorities: Dict[str, float] = field(default_factory=dict)
+    detected_emphases: Dict[str, List[float]] = field(default_factory=dict)
+    detected_rankings: Dict[str, int] = field(default_factory=dict)
+    detected_negatives: List[str] = field(default_factory=list)
+    detection_confidence: float = 1.0
+
+
+class PriorityDetector:
+    """
+    優先級檢測器
+    檢測使用者輸入中的優先級表達，包括強調關鍵字、排序詞、負面約束
+    """
+
+    def __init__(self):
+        """初始化優先級檢測器"""
+        self.emphasis_keywords = self._initialize_emphasis_keywords()
+        self.ranking_keywords = self._initialize_ranking_keywords()
+        self.negative_keywords = self._initialize_negative_keywords()
+        self.dimension_keywords = self._initialize_dimension_keywords()
+        self.absolute_max_priority = 2.5
+
+    def _initialize_emphasis_keywords(self) -> Dict[str, Dict[str, List[str]]]:
+        """初始化強調關鍵字"""
+        return {
+            'strong_emphasis': {
+                'en': [
+                    'most important', 'most importantly', 'must have', 'absolutely need',
+                    'critical', 'essential', 'top priority', 'crucial',
+                    'absolutely', 'definitely', 'certainly', 'paramount',
+                    'vital', 'indispensable', 'mandatory', 'imperative'
+                ]
+            },
+            'medium_emphasis': {
+                'en': [
+                    'really want', 'prefer', 'hope for', 'would like',
+                    'strongly prefer', 'important', 'significant',
+                    'really need', 'very important', 'highly prefer'
+                ]
+            },
+            'mild_emphasis': {
+                'en': [
+                    'nice to have', 'ideally', 'if possible', 'bonus if',
+                    'preferably', 'would be nice', 'hopefully',
+                    'optimally', 'wish for'
+                ]
+            }
+        }
+
+    def _initialize_ranking_keywords(self) -> Dict[str, List[str]]:
+        """初始化排序關鍵字"""
+        return {
+            'en': [
+                'first', 'second', 'third', 'fourth', 'fifth',
+                '1st', '2nd', '3rd', '4th', '5th',
+                'firstly', 'secondly', 'thirdly',
+                'primary', 'secondary', 'tertiary'
+            ]
+        }
+
+    def _initialize_negative_keywords(self) -> Dict[str, List[str]]:
+        """初始化負面約束關鍵字"""
+        return {
+            'en': [
+                'must not', 'cannot', "don't want", "don't need",
+                'absolutely no', 'cannot tolerate', 'no way',
+                'avoid', 'never', 'not', 'refuse',
+                'unacceptable', 'won\'t accept'
+            ]
+        }
+
+    def _initialize_dimension_keywords(self) -> Dict[str, List[str]]:
+        """初始化維度關鍵字映射"""
+        return {
+            'noise': [
+                'quiet', 'silent', 'not noisy', "doesn't bark", 'peaceful',
+                'noise', 'barking', 'vocal', 'loud', 'sound'
+            ],
+            'size': [
+                'small', 'medium', 'large', 'tiny', 'big', 'compact',
+                'size', 'giant', 'toy', 'miniature'
+            ],
+            'grooming': [
+                'low maintenance', 'easy care', 'minimal grooming', 'low-maintenance',
+                'grooming', 'care', 'maintenance', 'brush', 'shed', 'shedding'
+            ],
+            'family': [
+                'good with kids', 'child friendly', 'family dog',
+                'children', 'kids', 'family', 'toddler', 'baby'
+            ],
+            'exercise': [
+                'active', 'exercise', 'energy', 'activity',
+                'lazy', 'calm', 'energetic', 'athletic', 'work full time'
+            ],
+            'experience': [
+                'first time', 'first dog', 'beginner', 'new to dogs', 'inexperienced',
+                'easy to train', 'trainable', 'obedient', 'never owned', 'never had'
+            ],
+            'health': [
+                'healthy', 'health', 'lifespan', 'longevity',
+                'medical', 'genetic issues'
+            ]
+        }
+
+    def detect_priorities(self, user_input: str) -> PriorityDetectionResult:
+        """
+        檢測使用者輸入中的優先級
+
+        Args:
+            user_input: 使用者輸入文字
+
+        Returns:
+            PriorityDetectionResult: 優先級檢測結果
+        """
+        try:
+            if not user_input or not user_input.strip():
+                return PriorityDetectionResult()
+
+            normalized_input = user_input.lower().strip()
+
+            # Step 1: 檢測強調關鍵字
+            detected_emphases = self._detect_emphasis_keywords(normalized_input)
+
+            # Step 2: 檢測排序詞
+            detected_rankings = self._detect_explicit_ranking(normalized_input)
+
+            # Step 3: 檢測負面約束
+            detected_negatives = self._detect_negative_constraints(normalized_input)
+
+            # Step 4: 檢測所有提及的維度（即使沒有強調詞）
+            mentioned_dimensions = self._detect_mentioned_dimensions(normalized_input)
+
+            # Step 5: 計算疊加優先級（包括提及的維度）
+            dimension_priorities = self._calculate_final_priorities(
+                detected_emphases, detected_rankings, mentioned_dimensions
+            )
+
+            # Step 6: 計算信心度
+            detection_confidence = self._calculate_detection_confidence(
+                detected_emphases, detected_rankings, normalized_input
+            )
+
+            return PriorityDetectionResult(
+                dimension_priorities=dimension_priorities,
+                detected_emphases=detected_emphases,
+                detected_rankings=detected_rankings,
+                detected_negatives=detected_negatives,
+                detection_confidence=detection_confidence
+            )
+
+        except Exception as e:
+            print(f"Error detecting priorities: {str(e)}")
+            print(traceback.format_exc())
+            return PriorityDetectionResult()
+
+    def _detect_mentioned_dimensions(self, text: str) -> Set[str]:
+        """
+        檢測文字中提及的所有維度（不需要強調詞）
+
+        Args:
+            text: 正規化後的輸入文字
+
+        Returns:
+            Set[str]: 提及的維度集合
+        """
+        mentioned = set()
+
+        for dimension, keywords in self.dimension_keywords.items():
+            for keyword in keywords:
+                if keyword in text:
+                    mentioned.add(dimension)
+                    break  # 一個維度只需匹配一次
+
+        return mentioned
+
+    def _detect_emphasis_keywords(self, text: str) -> Dict[str, List[float]]:
+        """檢測強調關鍵字"""
+        detected = {}
+
+        # 定義權重倍數
+        emphasis_weights = {
+            'strong_emphasis': 2.0,
+            'medium_emphasis': 1.5,
+            'mild_emphasis': 1.2
+        }
+
+        # 為每個強調級別檢測
+        for emphasis_level, keywords_dict in self.emphasis_keywords.items():
+            weight = emphasis_weights[emphasis_level]
+
+            for lang, keywords in keywords_dict.items():
+                for keyword in keywords:
+                    if keyword in text:
+                        # 找到關鍵字附近的維度詞
+                        dimensions = self._extract_nearby_dimensions(text, keyword)
+                        for dimension in dimensions:
+                            if dimension not in detected:
+                                detected[dimension] = []
+                            detected[dimension].append(weight)
+
+        return detected
+
+    def _detect_explicit_ranking(self, text: str) -> Dict[str, int]:
+        """檢測明確排序詞"""
+        detected = {}
+
+        # 排序詞到排名的映射
+        ranking_map = {
+            'first': 1, '1st': 1, 'firstly': 1, 'primary': 1,
+            'second': 2, '2nd': 2, 'secondly': 2, 'secondary': 2,
+            'third': 3, '3rd': 3, 'thirdly': 3, 'tertiary': 3,
+            'fourth': 4, '4th': 4,
+            'fifth': 5, '5th': 5
+        }
+
+        for keyword in self.ranking_keywords['en']:
+            if keyword in text:
+                rank = ranking_map.get(keyword, 0)
+                if rank > 0:
+                    # 找到排序詞附近的維度詞
+                    dimensions = self._extract_nearby_dimensions(text, keyword)
+                    for dimension in dimensions:
+                        # 如果已經有排名，取較高優先級（較小的數字）
+                        if dimension in detected:
+                            detected[dimension] = min(detected[dimension], rank)
+                        else:
+                            detected[dimension] = rank
+
+        return detected
+
+    def _detect_negative_constraints(self, text: str) -> List[str]:
+        """檢測負面約束"""
+        detected = []
+
+        for lang, keywords in self.negative_keywords.items():
+            for keyword in keywords:
+                if keyword in text:
+                    # 找到負面關鍵字附近的維度詞
+                    dimensions = self._extract_nearby_dimensions(text, keyword)
+                    detected.extend(dimensions)
+
+        return list(set(detected))
+
+    def _extract_nearby_dimensions(self, text: str, keyword: str, window: int = 50) -> List[str]:
+        """
+        提取關鍵字附近的維度詞
+
+        Args:
+            text: 文字
+            keyword: 關鍵字
+            window: 搜尋窗口大小（字元數）
+
+        Returns:
+            List[str]: 檢測到的維度列表
+        """
+        detected_dimensions = []
+
+        # 找到關鍵字位置
+        keyword_positions = [m.start() for m in re.finditer(re.escape(keyword), text)]
+
+        for pos in keyword_positions:
+            # 定義搜尋窗口
+            start = max(0, pos - window)
+            end = min(len(text), pos + len(keyword) + window)
+            window_text = text[start:end]
+
+            # 在窗口中搜尋維度關鍵字
+            for dimension, dimension_keywords in self.dimension_keywords.items():
+                for dim_keyword in dimension_keywords:
+                    if dim_keyword in window_text:
+                        detected_dimensions.append(dimension)
+                        break  # 找到一個就夠了，不重複添加
+
+        return list(set(detected_dimensions))
+
+    def _calculate_final_priorities(self,
+                                   detected_emphases: Dict[str, List[float]],
+                                   detected_rankings: Dict[str, int],
+                                   mentioned_dimensions: Set[str] = None) -> Dict[str, float]:
+        """
+        計算最終優先級（疊加邏輯）
+
+        Args:
+            detected_emphases: 檢測到的強調 {dimension: [weights]}
+            detected_rankings: 檢測到的排序 {dimension: rank}
+            mentioned_dimensions: 被提及但沒有強調詞的維度
+
+        Returns:
+            Dict[str, float]: 最終優先級分數
+        """
+        final_priorities = {}
+
+        if mentioned_dimensions is None:
+            mentioned_dimensions = set()
+
+        # 合併所有提及的維度（包括強調、排序、和一般提及）
+        all_dimensions = set(detected_emphases.keys()) | set(detected_rankings.keys()) | mentioned_dimensions
+
+        for dimension in all_dimensions:
+            emphasis_scores = detected_emphases.get(dimension, [])
+            ranking = detected_rankings.get(dimension, 0)
+            is_mentioned = dimension in mentioned_dimensions
+
+            # 計算疊加分數
+            if emphasis_scores or ranking > 0:
+                # 有強調詞或排序詞
+                final_score = self._calculate_stacked_priority(emphasis_scores, ranking)
+            elif is_mentioned:
+                # 僅被提及（沒有強調詞），給予基本優先級提升
+                final_score = 1.3  # 基本提升，讓系統知道這個維度是使用者關心的
+            else:
+                final_score = 1.0
+
+            final_priorities[dimension] = final_score
+
+        return final_priorities
+
+    def _calculate_stacked_priority(self,
+                                   emphases: List[float],
+                                   ranking: int = 0) -> float:
+        """
+        計算疊加後的優先級分數
+
+        邏輯:
+        1. 取最高強調作為基礎
+        2. 其他強調提供遞減加成
+        3. 排序詞轉換為權重並疊加
+        4. 確保不超過絕對上限 2.5
+
+        Args:
+            emphases: 強調權重列表
+            ranking: 排序位置 (1=first, 2=second, etc.)
+
+        Returns:
+            float: 最終優先級分數
+        """
+        if not emphases and ranking == 0:
+            return 1.0
+
+        # 轉換排序為權重
+        ranking_weights = {
+            1: 2.0,   # first
+            2: 1.7,   # second
+            3: 1.4,   # third
+            4: 1.2,   # fourth
+            5: 1.1    # fifth
+        }
+        ranking_weight = ranking_weights.get(ranking, 0.0)
+
+        # 合併所有權重
+        all_weights = emphases.copy()
+        if ranking_weight > 0:
+            all_weights.append(ranking_weight)
+
+        if not all_weights:
+            return 1.0
+
+        # 排序取最高作為基礎
+        sorted_weights = sorted(all_weights, reverse=True)
+        base_score = sorted_weights[0]
+
+        # 額外權重提供遞減加成 (reduced stacking bonus)
+        bonus = 0.0
+        for i, weight in enumerate(sorted_weights[1:], start=1):
+            # 遞減加成: 第2個給30%, 第3個給15%, 第4個給7.5% (reduced from 50/25/12.5)
+            bonus += (weight - 1.0) * (0.3 / i)
+
+        final_score = min(base_score + bonus, self.absolute_max_priority)
+        return final_score
+
+    def _calculate_detection_confidence(self,
+                                       detected_emphases: Dict[str, List[float]],
+                                       detected_rankings: Dict[str, int],
+                                       text: str) -> float:
+        """
+        計算檢測信心度
+
+        Args:
+            detected_emphases: 檢測到的強調
+            detected_rankings: 檢測到的排序
+            text: 原始文字
+
+        Returns:
+            float: 信心度 (0-1)
+        """
+        confidence = 0.5  # 基礎信心度
+
+        # 有明確強調 +0.3
+        if detected_emphases:
+            confidence += 0.3
+
+        # 有明確排序 +0.2
+        if detected_rankings:
+            confidence += 0.2
+
+        # 文字長度適中 +0.1
+        word_count = len(text.split())
+        if 10 <= word_count <= 100:
+            confidence += 0.1
+
+        return min(1.0, confidence)
+
+    def get_detection_summary(self, result: PriorityDetectionResult) -> Dict[str, Any]:
+        """
+        獲取檢測摘要
+
+        Args:
+            result: 優先級檢測結果
+
+        Returns:
+            Dict[str, Any]: 檢測摘要
+        """
+        return {
+            'total_dimensions_detected': len(result.dimension_priorities),
+            'high_priority_dimensions': [
+                dim for dim, score in result.dimension_priorities.items() if score >= 1.5
+            ],
+            'dimension_priorities': result.dimension_priorities,
+            'emphases_detected': len(result.detected_emphases),
+            'rankings_detected': len(result.detected_rankings),
+            'negative_constraints': result.detected_negatives,
+            'detection_confidence': result.detection_confidence
+        }
+
+
+def detect_user_priorities(user_input: str) -> PriorityDetectionResult:
+    """
+    便利函數: 檢測使用者優先級
+
+    Args:
+        user_input: 使用者輸入
+
+    Returns:
+        PriorityDetectionResult: 檢測結果
+    """
+    detector = PriorityDetector()
+    return detector.detect_priorities(user_input)
+
+
+def get_priority_summary(user_input: str) -> Dict[str, Any]:
+    """
+    便利函數: 獲取優先級摘要
+
+    Args:
+        user_input: 使用者輸入
+
+    Returns:
+        Dict[str, Any]: 優先級摘要
+    """
+    detector = PriorityDetector()
+    result = detector.detect_priorities(user_input)
+    return detector.get_detection_summary(result)

query_understanding.py

@@ -1,3 +1,4 @@
+# %%writefile query_understanding.py
 import re
 import json
 import numpy as np
@@ -9,6 +10,7 @@ from sentence_transformers import SentenceTransformer
 from dog_database import get_dog_description
 from breed_health_info import breed_health_info
 from breed_noise_info import breed_noise_info
+from priority_detector import PriorityDetector
 
 @dataclass
 class QueryDimensions:
@@ -19,9 +21,11 @@ class QueryDimensions:
     size_preferences: List[str] = field(default_factory=list)
     family_context: List[str] = field(default_factory=list)
     maintenance_level: List[str] = field(default_factory=list)
+    experience_level: List[str] = field(default_factory=list)  # 用戶經驗等級
     special_requirements: List[str] = field(default_factory=list)
     breed_mentions: List[str] = field(default_factory=list)
     confidence_scores: Dict[str, float] = field(default_factory=dict)
+    dimension_priorities: Dict[str, float] = field(default_factory=dict)
 
 @dataclass
 class DimensionalSynonyms:
@@ -47,6 +51,7 @@ class QueryUnderstandingEngine:
         self.breed_list = self._load_breed_list()
         self.synonyms = self._initialize_synonyms()
         self.semantic_templates = {}
+        self.priority_detector = PriorityDetector()  # 初始化優先級檢測器
         # 延遲SBERT載入直到需要時才在GPU環境中進行
         print("QueryUnderstandingEngine initialized (SBERT loading deferred)")
 
@@ -129,9 +134,12 @@ class QueryUnderstandingEngine:
             },
             family={
                 'children': ['children', 'kids', 'family', 'child-friendly', 'toddler',
-                           'baby', 'school age'],
-                'elderly': ['elderly', 'senior', 'old people', 'retirement', 'aged'],
-                'single': ['single', 'alone', 'individual', 'solo', 'myself']
+                           'baby', 'school age', 'young kids', 'young children',
+                           'aged 1', 'aged 2', 'aged 3', 'aged 4', 'aged 5',
+                           '1 year', '2 year', '3 year', '4 year', '5 year',
+                           'infant', 'preschool'],
+                'elderly': ['elderly', 'senior', 'old people', 'retirement', 'aged', 'retired'],
+                'single': ['single', 'alone', 'individual', 'solo', 'myself', 'living alone']
             },
             maintenance={
                 'low': ['low maintenance', 'easy care', 'simple', 'minimal grooming',
@@ -148,7 +156,9 @@ class QueryUnderstandingEngine:
                 'hypoallergenic': ['hypoallergenic', 'allergies', 'non-shedding',
                                  'allergy-friendly', 'no shed'],
                 'first_time': ['first time', 'beginner', 'new to dogs', 'inexperienced',
-                              'never owned']
+                              'never owned'],
+                'senior': ['senior', 'elderly', 'retired', 'older person', 'old age',
+                          'aging', 'older adult', 'golden years', 'retirement']
             }
         )
 
@@ -209,7 +219,7 @@ class QueryUnderstandingEngine:
             # 如果 SBERT 可用，進行語義分析增強
             if self.sbert_model is None:
                 self._initialize_sbert_model()
-                
+
             if self.sbert_model:
                 semantic_dimensions = self._extract_semantic_dimensions(user_input)
                 dimensions = self._merge_dimensions(dimensions, semantic_dimensions)
@@ -220,6 +230,18 @@ class QueryUnderstandingEngine:
             # 計算信心分數
             dimensions.confidence_scores = self._calculate_confidence_scores(dimensions, user_input)
 
+            # **關鍵修復：使用 PriorityDetector 檢測維度優先級**
+            priority_result = self.priority_detector.detect_priorities(user_input)
+            dimensions.dimension_priorities = priority_result.dimension_priorities
+
+            # Debug 輸出
+            print(f"=== Query Analysis Debug ===")
+            print(f"  experience_level: {dimensions.experience_level}")
+            print(f"  maintenance_level: {dimensions.maintenance_level}")
+            print(f"  spatial_constraints: {dimensions.spatial_constraints}")
+            print(f"  dimension_priorities: {dimensions.dimension_priorities}")
+            print(f"============================")
+
             return dimensions
 
         except Exception as e:
@@ -266,6 +288,22 @@ class QueryUnderstandingEngine:
         for requirement, keywords in self.synonyms.special.items():
             if any(keyword in text for keyword in keywords):
                 dimensions.special_requirements.append(requirement)
+                # 如果檢測到first_time，同時設置experience_level
+                if requirement == 'first_time':
+                    dimensions.experience_level.append('beginner')
+
+        # 額外的經驗等級檢測
+        experience_keywords = {
+            'beginner': ['first dog', 'first time', 'beginner', 'new to dogs', 'inexperienced',
+                        'never owned', 'never had a dog', 'first-time owner', 'first-time dog owner',
+                        'first time owner', 'first time dog owner', 'new dog owner', 'new owner'],
+            'intermediate': ['some experience', 'had dogs before', 'owned dogs'],
+            'advanced': ['experienced', 'expert', 'professional', 'breeder', 'dog trainer']
+        }
+        for level, keywords in experience_keywords.items():
+            if any(keyword in text for keyword in keywords):
+                if level not in dimensions.experience_level:
+                    dimensions.experience_level.append(level)
 
         return dimensions
 
@@ -375,6 +413,9 @@ class QueryUnderstandingEngine:
         merged.maintenance_level = list(set(
             keyword_dims.maintenance_level + semantic_dims.maintenance_level
         ))
+        merged.experience_level = list(set(
+            keyword_dims.experience_level + semantic_dims.experience_level
+        ))
         merged.special_requirements = list(set(
             keyword_dims.special_requirements + semantic_dims.special_requirements
         ))
@@ -453,6 +494,7 @@ class QueryUnderstandingEngine:
             ])
         }
 
+# 便利函數
 def analyze_user_query(user_input: str) -> QueryDimensions:
     """
     便利函數：分析使用者查詢
@@ -478,4 +520,4 @@ def get_query_summary(user_input: str) -> Dict[str, Any]:
     """
     engine = QueryUnderstandingEngine()
     dimensions = engine.analyze_query(user_input)
-    return engine.get_dimension_summary(dimensions)
+    return engine.get_dimension_summary(dimensions)

recommendation_css.py

@@ -0,0 +1,687 @@
+# recommendation_css.py
+"""
+CSS 樣式模組 - 專門處理推薦結果的 CSS 樣式
+將所有 CSS 定義集中管理，提高可維護性
+"""
+
+# Description Search (Find by Description) 模式的 CSS 樣式
+DESCRIPTION_SEARCH_CSS = """
+<style>
+.recommendations-container {
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+    padding: 20px;
+}
+
+.breed-card {
+    border: 2px solid #e5e7eb;
+    border-radius: 12px;
+    padding: 20px;
+    background: white;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    transition: all 0.3s ease;
+    position: relative;
+}
+
+.breed-card:hover {
+    box-shadow: 0 8px 12px rgba(0, 0, 0, 0.15);
+    transform: translateY(-2px);
+}
+
+.rank-badge {
+    position: absolute;
+    top: 15px;
+    left: 15px;
+    padding: 8px 14px;
+    border-radius: 8px;
+    font-weight: 800;
+    font-size: 20px;
+    min-width: 45px;
+    text-align: center;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+}
+
+.rank-1 {
+    background: linear-gradient(135deg, #FEF3C7 0%, #FDE68A 50%, #F59E0B 100%);
+    color: #92400E;
+    font-size: 32px;
+    font-weight: 900;
+    animation: pulse 2s infinite;
+    border: 3px solid rgba(251, 191, 36, 0.4);
+    box-shadow: 0 6px 20px rgba(245, 158, 11, 0.3);
+    text-shadow: 0 1px 2px rgba(255, 255, 255, 0.8);
+}
+
+.rank-2 {
+    background: linear-gradient(135deg, #F1F5F9 0%, #E2E8F0 50%, #94A3B8 100%);
+    color: #475569;
+    font-size: 30px;
+    font-weight: 800;
+    border: 3px solid rgba(148, 163, 184, 0.4);
+    box-shadow: 0 5px 15px rgba(148, 163, 184, 0.3);
+    text-shadow: 0 1px 2px rgba(255, 255, 255, 0.8);
+}
+
+.rank-3 {
+    background: linear-gradient(135deg, #FEF2F2 0%, #FED7AA 50%, #FB923C 100%);
+    color: #9A3412;
+    font-size: 28px;
+    font-weight: 800;
+    border: 3px solid rgba(251, 146, 60, 0.4);
+    box-shadow: 0 4px 12px rgba(251, 146, 60, 0.3);
+    text-shadow: 0 1px 2px rgba(255, 255, 255, 0.8);
+}
+
+.rank-other {
+    background: linear-gradient(135deg, #F8FAFC 0%, #E2E8F0 50%, #CBD5E1 100%);
+    color: #475569;
+    font-size: 26px;
+    font-weight: 700;
+    border: 2px solid rgba(203, 213, 225, 0.6);
+    box-shadow: 0 3px 8px rgba(203, 213, 225, 0.4);
+    text-shadow: 0 1px 2px rgba(255, 255, 255, 0.8);
+}
+
+@keyframes pulse {
+    0% {
+        box-shadow: 0 6px 20px rgba(245, 158, 11, 0.3);
+        transform: scale(1);
+    }
+    50% {
+        box-shadow: 0 8px 25px rgba(245, 158, 11, 0.5), 0 0 0 4px rgba(245, 158, 11, 0.15);
+        transform: scale(1.05);
+    }
+    100% {
+        box-shadow: 0 6px 20px rgba(245, 158, 11, 0.3);
+        transform: scale(1);
+    }
+}
+
+.breed-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 15px;
+    padding-left: 70px;
+}
+
+.breed-name {
+    font-size: 26px;
+    font-weight: 800;
+    color: #1F2937;
+    margin: 0;
+    letter-spacing: -0.025em;
+    line-height: 1.2;
+}
+
+.match-score {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+    padding: 12px 16px;
+    background: linear-gradient(135deg, #F0F9FF 0%, #E0F2FE 100%);
+    border-radius: 12px;
+    border: 2px solid rgba(6, 182, 212, 0.2);
+    box-shadow: 0 4px 12px rgba(6, 182, 212, 0.1);
+}
+
+.match-percentage {
+    font-size: 48px;
+    font-weight: 900;
+    margin-bottom: 8px;
+    text-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    line-height: 1;
+    letter-spacing: -0.02em;
+}
+
+.match-label {
+    font-size: 12px;
+    text-transform: uppercase;
+    letter-spacing: 2px;
+    opacity: 0.9;
+    font-weight: 800;
+    margin-bottom: 6px;
+    color: #0369A1;
+}
+
+.score-excellent { color: #22C55E; }
+.score-good { color: #F59E0B; }
+.score-moderate { color: #6B7280; }
+
+.score-bar {
+    width: 220px;
+    height: 14px;
+    background: rgba(226, 232, 240, 0.8);
+    border-radius: 8px;
+    overflow: hidden;
+    margin-top: 8px;
+    box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.1);
+    border: 1px solid rgba(6, 182, 212, 0.2);
+}
+
+.score-fill {
+    height: 100%;
+    border-radius: 4px;
+    transition: width 1s ease;
+}
+
+.fill-excellent { background: linear-gradient(90deg, #22C55E, #16A34A); }
+.fill-good { background: linear-gradient(90deg, #F59E0B, #DC2626); }
+.fill-moderate { background: linear-gradient(90deg, #6B7280, #4B5563); }
+
+/* Tooltip styles for Find by Description */
+.tooltip {
+    position: relative;
+    display: inline-block;
+    cursor: help;
+}
+
+.tooltip-icon {
+    display: inline-block;
+    width: 18px;
+    height: 18px;
+    background: linear-gradient(135deg, #06b6d4, #0891b2);
+    color: white;
+    border-radius: 50%;
+    text-align: center;
+    line-height: 18px;
+    font-size: 12px;
+    font-weight: bold;
+    margin-left: 8px;
+    cursor: help;
+    box-shadow: 0 2px 4px rgba(6, 182, 212, 0.3);
+    transition: all 0.2s ease;
+}
+
+.tooltip-icon:hover {
+    background: linear-gradient(135deg, #0891b2, #0e7490);
+    transform: scale(1.1);
+    box-shadow: 0 3px 6px rgba(6, 182, 212, 0.4);
+}
+
+.tooltip-text {
+    visibility: hidden;
+    width: 320px;
+    background: linear-gradient(145deg, #1e293b, #334155);
+    color: #f1f5f9;
+    text-align: left;
+    border-radius: 12px;
+    padding: 16px;
+    position: absolute;
+    z-index: 1000;
+    bottom: 125%;
+    left: 50%;
+    margin-left: -160px;
+    opacity: 0;
+    transition: opacity 0.3s ease, transform 0.3s ease;
+    transform: translateY(10px);
+    font-size: 14px;
+    line-height: 1.5;
+    box-shadow: 0 8px 25px rgba(0, 0, 0, 0.3);
+    border: 1px solid rgba(148, 163, 184, 0.2);
+}
+
+.tooltip-text::after {
+    content: "";
+    position: absolute;
+    top: 100%;
+    left: 50%;
+    margin-left: -8px;
+    border-width: 8px;
+    border-style: solid;
+    border-color: #334155 transparent transparent transparent;
+}
+
+.tooltip:hover .tooltip-text {
+    visibility: visible;
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.tooltip-text strong {
+    color: #06b6d4;
+    font-weight: 700;
+    display: block;
+    margin-bottom: 8px;
+    font-size: 15px;
+}
+</style>
+"""
+
+# Criteria Search (Find by Criteria) 模式的 CSS 樣式
+CRITERIA_SEARCH_CSS = """
+<style>
+.recommendations-container {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+    padding: 15px;
+}
+
+.breed-card {
+    border: 1px solid #d1d5db;
+    border-radius: 8px;
+    padding: 16px;
+    background: #ffffff;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+    transition: all 0.2s ease;
+}
+
+.breed-card:hover {
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    transform: translateY(-1px);
+}
+
+.breed-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 12px;
+    padding-bottom: 8px;
+    border-bottom: 1px solid #f3f4f6;
+}
+
+.breed-title {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    justify-content: flex-start;
+}
+
+.trophy-rank {
+    font-size: 24px;
+    font-weight: 800;
+    color: #1f2937;
+}
+
+.breed-name {
+    font-size: 42px;
+    font-weight: 900;
+    color: #1f2937;
+    margin: 0;
+    padding: 8px 16px;
+    background: linear-gradient(135deg, #D1FAE5 0%, #A7F3D0 100%);
+    border: 2px solid #22C55E;
+    border-radius: 12px;
+    display: inline-block;
+    box-shadow: 0 2px 8px rgba(34, 197, 94, 0.2);
+}
+
+.overall-score {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+}
+
+.score-percentage {
+    font-size: 32px;
+    font-weight: 900;
+    margin-bottom: 4px;
+    line-height: 1;
+}
+
+.score-label {
+    font-size: 10px;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    opacity: 0.7;
+    font-weight: 600;
+}
+
+.score-bar-wide {
+    width: 200px;
+    height: 8px;
+    background: #f3f4f6;
+    border-radius: 4px;
+    overflow: hidden;
+    margin-top: 6px;
+}
+
+.score-fill-wide {
+    height: 100%;
+    border-radius: 4px;
+    transition: width 0.8s ease;
+}
+
+.score-excellent { color: #22C55E; }
+.score-good { color: #65a30d; }
+.score-moderate { color: #d4a332; }
+.score-fair { color: #e67e22; }
+.score-poor { color: #e74c3c; }
+
+.fill-excellent { background: #22C55E; }
+.fill-good { background: #65a30d; }
+.fill-moderate { background: #d4a332; }
+.fill-fair { background: #e67e22; }
+.fill-poor { background: #e74c3c; }
+
+.breed-details {
+    margin-top: 12px;
+    padding-top: 12px;
+    border-top: 1px solid #e5e7eb;
+}
+
+/* 通用樣式（兩個模式都需要） */
+.progress {
+    transition: all 0.3s ease-in-out;
+    border-radius: 4px;
+    height: 12px;
+}
+
+.progress-bar {
+    background-color: #f5f5f5;
+    border-radius: 4px;
+    overflow: hidden;
+    position: relative;
+}
+
+.score-item {
+    margin: 10px 0;
+}
+
+.percentage {
+    margin-left: 8px;
+    font-weight: 500;
+}
+
+/* White Tooltip Styles */
+.tooltip {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    cursor: help;
+}
+
+.tooltip .tooltip-icon {
+    font-size: 14px;
+    color: #666;
+}
+
+.tooltip .tooltip-text {
+    visibility: hidden;
+    width: 250px;
+    background-color: rgba(44, 62, 80, 0.95);
+    color: white;
+    text-align: left;
+    border-radius: 8px;
+    padding: 8px 10px;
+    position: absolute;
+    z-index: 100;
+    bottom: 150%;
+    left: 50%;
+    transform: translateX(-50%);
+    opacity: 0;
+    transition: all 0.3s ease;
+    font-size: 14px;
+    line-height: 1.3;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.2);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    margin-bottom: 10px;
+}
+
+.tooltip:hover .tooltip-text {
+    visibility: visible;
+    opacity: 1;
+}
+
+.tooltip .tooltip-text::after {
+    content: "";
+    position: absolute;
+    top: 100%;
+    left: 50%;
+    transform: translateX(-50%);
+    border-width: 8px;
+    border-style: solid;
+    border-color: rgba(44, 62, 80, 0.95) transparent transparent transparent;
+}
+</style>
+"""
+
+# Unified Recommendations (統一推薦結果) 的 CSS 樣式
+UNIFIED_CSS = """
+<style>
+.unified-recommendations {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+.unified-breed-card {
+    background: linear-gradient(145deg, #ffffff 0%, #f8fafc 100%);
+    border-radius: 16px;
+    padding: 24px;
+    margin-bottom: 20px;
+    box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
+    border: 1px solid #e2e8f0;
+    transition: all 0.3s ease;
+}
+
+.unified-breed-card:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 12px 35px rgba(0, 0, 0, 0.15);
+}
+
+.unified-breed-header {
+    margin-bottom: 20px;
+}
+
+.unified-rank-section {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+}
+
+.unified-rank-badge {
+    background: linear-gradient(135deg, #E0F2FE 0%, #BAE6FD 100%);
+    color: #0C4A6E;
+    padding: 8px 16px;
+    border-radius: 8px;
+    font-weight: 900;
+    font-size: 24px;
+    box-shadow: 0 2px 8px rgba(14, 165, 233, 0.2);
+    border: 2px solid #0EA5E9;
+    display: inline-block;
+    min-width: 80px;
+    text-align: center;
+}
+
+.unified-breed-info {
+    flex-grow: 1;
+}
+
+.unified-breed-title {
+    font-size: 24px;
+    font-weight: 800;
+    color: #0C4A6E;
+    margin: 0;
+    letter-spacing: -0.02em;
+    background: linear-gradient(135deg, #F0F9FF, #E0F2FE);
+    padding: 12px 20px;
+    border-radius: 10px;
+    border: 2px solid #0EA5E9;
+    display: inline-block;
+    box-shadow: 0 2px 8px rgba(14, 165, 233, 0.1);
+}
+
+.unified-match-score {
+    font-size: 24px;
+    font-weight: 900;
+    color: #0F5132;
+    background: linear-gradient(135deg, #D1FAE5, #A7F3D0);
+    padding: 12px 20px;
+    border-radius: 10px;
+    display: inline-block;
+    text-align: center;
+    border: 2px solid #22C55E;
+    box-shadow: 0 2px 8px rgba(34, 197, 94, 0.2);
+    margin: 0;
+    text-shadow: 0 1px 2px rgba(255, 255, 255, 0.5);
+    letter-spacing: -0.02em;
+}
+
+.unified-overall-section {
+    background: linear-gradient(135deg, #f0f9ff, #ecfeff);
+    border-radius: 12px;
+    padding: 20px;
+    margin-bottom: 24px;
+    border: 2px solid #06b6d4;
+    box-shadow: 0 4px 12px rgba(6, 182, 212, 0.1);
+}
+
+.unified-dimension-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 16px;
+    margin-bottom: 24px;
+}
+
+.unified-dimension-item {
+    background: white;
+    padding: 16px;
+    border-radius: 10px;
+    border: 1px solid #e2e8f0;
+    transition: all 0.2s ease;
+}
+
+.unified-dimension-item:hover {
+    background: #f8fafc;
+    border-color: #cbd5e1;
+}
+
+.unified-breed-info {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 12px;
+    margin: 20px 0;
+}
+
+.unified-info-item {
+    background: #f8fafc;
+    padding: 12px;
+    border-radius: 8px;
+    border-left: 4px solid #6366f1;
+}
+
+.unified-info-label {
+    font-weight: 600;
+    color: #4b5563;
+    font-size: 0.85em;
+    margin-bottom: 4px;
+}
+
+.unified-info-value {
+    color: #1f2937;
+    font-weight: 500;
+}
+
+/* Tooltip styles for unified recommendations */
+.tooltip {
+    position: relative;
+    display: inline-block;
+    cursor: help;
+}
+
+.tooltip-icon {
+    display: inline-block;
+    width: 18px;
+    height: 18px;
+    background: linear-gradient(135deg, #06b6d4, #0891b2);
+    color: white;
+    border-radius: 50%;
+    text-align: center;
+    line-height: 18px;
+    font-size: 12px;
+    font-weight: bold;
+    margin-left: 8px;
+    cursor: help;
+    box-shadow: 0 2px 4px rgba(6, 182, 212, 0.3);
+    transition: all 0.2s ease;
+}
+
+.tooltip-icon:hover {
+    background: linear-gradient(135deg, #0891b2, #0e7490);
+    transform: scale(1.1);
+    box-shadow: 0 3px 6px rgba(6, 182, 212, 0.4);
+}
+
+.tooltip-text {
+    visibility: hidden;
+    width: 320px;
+    background: linear-gradient(145deg, #1e293b, #334155);
+    color: #f1f5f9;
+    text-align: left;
+    border-radius: 12px;
+    padding: 16px;
+    position: absolute;
+    z-index: 1000;
+    bottom: 125%;
+    left: 50%;
+    margin-left: -160px;
+    opacity: 0;
+    transition: opacity 0.3s ease, transform 0.3s ease;
+    transform: translateY(10px);
+    font-size: 14px;
+    line-height: 1.5;
+    box-shadow: 0 8px 25px rgba(0, 0, 0, 0.3);
+    border: 1px solid rgba(148, 163, 184, 0.2);
+}
+
+.tooltip-text::after {
+    content: "";
+    position: absolute;
+    top: 100%;
+    left: 50%;
+    margin-left: -8px;
+    border-width: 8px;
+    border-style: solid;
+    border-color: #334155 transparent transparent transparent;
+}
+
+.tooltip:hover .tooltip-text {
+    visibility: visible;
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.tooltip-text strong {
+    color: #06b6d4;
+    font-weight: 700;
+    display: block;
+    margin-bottom: 8px;
+    font-size: 15px;
+}
+
+.akc-button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 16px rgba(59, 130, 246, 0.5) !important;
+}
+</style>
+"""
+
+
+def get_recommendation_css_styles(is_description_search: bool) -> str:
+    """
+    根據搜尋類型返回對應的推薦結果 CSS 樣式
+
+    Args:
+        is_description_search: 是否為 Description Search 模式
+
+    Returns:
+        str: 對應的 CSS 樣式字串
+    """
+    if is_description_search:
+        return DESCRIPTION_SEARCH_CSS
+    else:
+        return CRITERIA_SEARCH_CSS
+
+
+def get_unified_css() -> str:
+    """
+    獲取統一推薦結果的 CSS 樣式
+
+    Returns:
+        str: 統一推薦 CSS 樣式字串
+    """
+    return UNIFIED_CSS

recommendation_formatter.py

@@ -1,3 +1,4 @@
+# %%writefile recommendation_formatter.py
 import sqlite3
 import traceback
 import random
@@ -293,33 +294,143 @@ def parse_health_information(health_info: dict) -> tuple:
     return health_considerations, health_screenings
 
 
-def generate_dimension_scores_for_display(base_score: float, rank: int, breed: str, 
+def generate_dimension_scores_for_display(base_score: float, rank: int, breed: str,
                                         semantic_score: float = 0.7,
                                         comparative_bonus: float = 0.0,
                                         lifestyle_bonus: float = 0.0,
-                                        is_description_search: bool = False) -> dict:
-    """為顯示生成維度分數"""
-    random.seed(hash(breed) + rank)  # 一致的隨機性
+                                        is_description_search: bool = False,
+                                        user_input: str = "") -> dict:
+    """
+    為顯示生成維度分數 - 基於真實品種特性
+
+    這個函數現在會考慮品種的實際特性來計算分數，
+    而不是僅僅基於總分生成假分數。
+    """
+    from dog_database import get_dog_description
+
+    # 獲取品種資訊
+    breed_name = breed.replace(' ', '_')
+    breed_info = get_dog_description(breed_name) or {}
+
+    temperament = breed_info.get('Temperament', '').lower()
+    size = breed_info.get('Size', 'Medium').lower()
+    exercise_needs = breed_info.get('Exercise Needs', 'Moderate').lower()
+    grooming_needs = breed_info.get('Grooming Needs', 'Moderate').lower()
+    good_with_children = breed_info.get('Good with Children', 'Yes')
+    care_level = breed_info.get('Care Level', 'Moderate').lower()
+
+    user_text = user_input.lower() if user_input else ""
 
     if is_description_search:
-        # Description search: 創建更自然的分數分佈在50%-95%範圍內
-        score_variance = 0.08 if base_score > 0.7 else 0.06
-        
+        # === 真實維度評分 ===
+
+        # 1. Space Compatibility
+        space_score = 0.75
+        if 'small' in size:
+            space_score = 0.85
+        elif 'medium' in size:
+            space_score = 0.75
+        elif 'large' in size:
+            space_score = 0.65
+        elif 'giant' in size:
+            space_score = 0.55
+
+        # 2. Exercise Compatibility
+        exercise_score = 0.75
+        if 'low' in exercise_needs:
+            exercise_score = 0.85
+        elif 'moderate' in exercise_needs:
+            exercise_score = 0.75
+        elif 'high' in exercise_needs:
+            exercise_score = 0.60
+        elif 'very high' in exercise_needs:
+            exercise_score = 0.50
+
+        # 3. Grooming/Maintenance
+        grooming_score = 0.75
+        if 'low' in grooming_needs:
+            grooming_score = 0.85
+        elif 'moderate' in grooming_needs:
+            grooming_score = 0.70
+        elif 'high' in grooming_needs:
+            grooming_score = 0.55
+
+        # 敏感品種需要額外照顧
+        if 'sensitive' in temperament:
+            grooming_score -= 0.10
+
+        # 4. Experience Compatibility - 關鍵！
+        # DEBUG: 如果這個函數被呼叫，experience 會基於真實品種特性計算
+        experience_score = 0.70
+
+        # 基於 care level 的基礎分數
+        if 'low' in care_level:
+            experience_score = 0.85
+        elif 'moderate' in care_level:
+            experience_score = 0.70
+        elif 'high' in care_level:
+            experience_score = 0.55
+
+        # DEBUG 標記：打印正在計算的品種
+        print(f"[REAL_SCORE] Calculating experience for {breed}: care_level={care_level}, temperament={temperament}")
+
+        # 性格對經驗的影響
+        difficult_traits = {
+            'sensitive': -0.15,
+            'stubborn': -0.12,
+            'independent': -0.10,
+            'dominant': -0.12,
+            'aggressive': -0.20,
+            'nervous': -0.12,
+            'alert': -0.05,
+            'shy': -0.08,
+            'timid': -0.08
+        }
+        for trait, penalty in difficult_traits.items():
+            if trait in temperament:
+                experience_score += penalty
+
+        easy_traits = {
+            'friendly': 0.08,
+            'gentle': 0.08,
+            'eager to please': 0.10,
+            'patient': 0.08,
+            'calm': 0.08,
+            'outgoing': 0.05,
+            'playful': 0.03
+        }
+        for trait, bonus in easy_traits.items():
+            if trait in temperament:
+                experience_score += bonus
+
+        # 5. Noise Compatibility
+        noise_score = 0.75
+        if any(term in temperament for term in ['quiet', 'calm', 'gentle']):
+            noise_score = 0.85
+        elif any(term in temperament for term in ['alert', 'vocal']):
+            noise_score = 0.60
+
+        # 6. Family Compatibility
+        family_score = 0.70
+        if good_with_children == 'Yes' or good_with_children == True:
+            family_score = 0.80
+            if any(term in temperament for term in ['gentle', 'patient', 'friendly']):
+                family_score = 0.90
+        elif good_with_children == 'No' or good_with_children == False:
+            family_score = 0.45
+
+        # 確保分數在合理範圍內
         scores = {
-            'space': max(0.50, min(0.95,
-                base_score * 0.92 + (lifestyle_bonus * 0.5) + random.uniform(-score_variance, score_variance))),
-            'exercise': max(0.50, min(0.95,
-                base_score * 0.88 + (lifestyle_bonus * 0.4) + random.uniform(-score_variance, score_variance))),
-            'grooming': max(0.50, min(0.95,
-                base_score * 0.85 + (comparative_bonus * 0.4) + random.uniform(-score_variance, score_variance))),
-            'experience': max(0.50, min(0.95,
-                base_score * 0.87 + (lifestyle_bonus * 0.3) + random.uniform(-score_variance, score_variance))),
-            'noise': max(0.50, min(0.95,
-                base_score * 0.83 + (lifestyle_bonus * 0.6) + random.uniform(-score_variance, score_variance))),
+            'space': max(0.30, min(0.95, space_score)),
+            'exercise': max(0.30, min(0.95, exercise_score)),
+            'grooming': max(0.30, min(0.95, grooming_score)),
+            'experience': max(0.30, min(0.95, experience_score)),
+            'noise': max(0.30, min(0.95, noise_score)),
+            'family': max(0.30, min(0.95, family_score)),
             'overall': base_score
         }
     else:
         # 傳統搜尋結果的分數結構會在呼叫處理中傳入
         scores = {'overall': base_score}
-    
+
     return scores

recommendation_html_format.py

@@ -1,3 +1,4 @@
+# %%writefile recommendation_html_format.py
 import random
 from typing import List, Dict
 from breed_health_info import breed_health_info, default_health_note
@@ -259,7 +260,7 @@ def format_recommendation_html(recommendations: List[Dict], is_description_searc
 
 def format_unified_recommendation_html(recommendations: List[Dict], is_description_search: bool = False) -> str:
     """統一推薦HTML格式化主函數，確保視覺呈現與數值計算完全一致"""
-    
+
     # 創建HTML格式器實例
     formatter = RecommendationHTMLFormatter()
 
@@ -272,21 +273,33 @@ def format_unified_recommendation_html(recommendations: List[Dict], is_descripti
         </div>
         '''
 
+    # 確保按分數降序排序，並更新排名
+    sorted_recommendations = sorted(
+        recommendations,
+        key=lambda x: x.get('final_score', x.get('overall_score', 0)),
+        reverse=True
+    )
+    for i, rec in enumerate(sorted_recommendations):
+        rec['rank'] = i + 1
+
     # 使用格式器的統一CSS樣式
     html_content = formatter.unified_css + "<div class='unified-recommendations'>"
 
-    for rec in recommendations:
+    for rec in sorted_recommendations:
         breed = rec['breed']
         rank = rec.get('rank', 0)
 
-        # 統一分數處理
-        overall_score = rec.get('overall_score', rec.get('final_score', 0.7))
+        # 統一分數處理 - 優先使用 final_score（經過風險調整後的分數）
+        overall_score = rec.get('final_score', rec.get('overall_score', 0.7))
         scores = rec.get('scores', {})
 
         # 如果沒有維度分數，基於總分生成一致的維度分數
         if not scores:
             scores = generate_dimension_scores_for_display(
-                overall_score, rank, breed, is_description_search=is_description_search
+                base_score=overall_score,
+                rank=rank,
+                breed=breed,
+                is_description_search=is_description_search
             )
 
         # 獲取品種資訊

recommendation_html_formatter.py

@@ -1,3 +1,8 @@
+# %%writefile recommendation_html_formatter.py
+"""
+HTML 格式化器 - 處理推薦結果的 HTML 生成
+CSS 樣式已分離至 recommendation_css.py
+"""
 import random
 from typing import List, Dict
 from breed_health_info import breed_health_info, default_health_note
@@ -10,588 +15,23 @@ from recommendation_formatter import (
     calculate_breed_bonus_factors,
     generate_dimension_scores_for_display
 )
+from recommendation_css import (
+    DESCRIPTION_SEARCH_CSS,
+    CRITERIA_SEARCH_CSS,
+    UNIFIED_CSS,
+    get_recommendation_css_styles,
+    get_unified_css
+)
 
-class RecommendationHTMLFormatter:
-    """處理推薦結果的HTML和CSS格式化"""
-    
-    def __init__(self):
-        self.description_search_css = """
-        <style>
-        .recommendations-container {
-            display: flex;
-            flex-direction: column;
-            gap: 20px;
-            padding: 20px;
-        }
-
-        .breed-card {
-            border: 2px solid #e5e7eb;
-            border-radius: 12px;
-            padding: 20px;
-            background: white;
-            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-            transition: all 0.3s ease;
-            position: relative;
-        }
-
-        .breed-card:hover {
-            box-shadow: 0 8px 12px rgba(0, 0, 0, 0.15);
-            transform: translateY(-2px);
-        }
-
-        .rank-badge {
-            position: absolute;
-            top: 15px;
-            left: 15px;
-            padding: 8px 14px;
-            border-radius: 8px;
-            font-weight: 800;
-            font-size: 20px;
-            min-width: 45px;
-            text-align: center;
-            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
-        }
-
-        .rank-1 {
-            background: linear-gradient(135deg, #FEF3C7 0%, #FDE68A 50%, #F59E0B 100%);
-            color: #92400E;
-            font-size: 32px;
-            font-weight: 900;
-            animation: pulse 2s infinite;
-            border: 3px solid rgba(251, 191, 36, 0.4);
-            box-shadow: 0 6px 20px rgba(245, 158, 11, 0.3);
-            text-shadow: 0 1px 2px rgba(255, 255, 255, 0.8);
-        }
-
-        .rank-2 {
-            background: linear-gradient(135deg, #F1F5F9 0%, #E2E8F0 50%, #94A3B8 100%);
-            color: #475569;
-            font-size: 30px;
-            font-weight: 800;
-            border: 3px solid rgba(148, 163, 184, 0.4);
-            box-shadow: 0 5px 15px rgba(148, 163, 184, 0.3);
-            text-shadow: 0 1px 2px rgba(255, 255, 255, 0.8);
-        }
-
-        .rank-3 {
-            background: linear-gradient(135deg, #FEF2F2 0%, #FED7AA 50%, #FB923C 100%);
-            color: #9A3412;
-            font-size: 28px;
-            font-weight: 800;
-            border: 3px solid rgba(251, 146, 60, 0.4);
-            box-shadow: 0 4px 12px rgba(251, 146, 60, 0.3);
-            text-shadow: 0 1px 2px rgba(255, 255, 255, 0.8);
-        }
-
-        .rank-other {
-            background: linear-gradient(135deg, #F8FAFC 0%, #E2E8F0 50%, #CBD5E1 100%);
-            color: #475569;
-            font-size: 26px;
-            font-weight: 700;
-            border: 2px solid rgba(203, 213, 225, 0.6);
-            box-shadow: 0 3px 8px rgba(203, 213, 225, 0.4);
-            text-shadow: 0 1px 2px rgba(255, 255, 255, 0.8);
-        }
-
-        @keyframes pulse {
-            0% {
-                box-shadow: 0 6px 20px rgba(245, 158, 11, 0.3);
-                transform: scale(1);
-            }
-            50% {
-                box-shadow: 0 8px 25px rgba(245, 158, 11, 0.5), 0 0 0 4px rgba(245, 158, 11, 0.15);
-                transform: scale(1.05);
-            }
-            100% {
-                box-shadow: 0 6px 20px rgba(245, 158, 11, 0.3);
-                transform: scale(1);
-            }
-        }
-
-        .breed-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 15px;
-            padding-left: 70px;
-        }
-
-        .breed-name {
-            font-size: 26px;
-            font-weight: 800;
-            color: #1F2937;
-            margin: 0;
-            letter-spacing: -0.025em;
-            line-height: 1.2;
-        }
-
-        .match-score {
-            display: flex;
-            flex-direction: column;
-            align-items: flex-end;
-            padding: 12px 16px;
-            background: linear-gradient(135deg, #F0F9FF 0%, #E0F2FE 100%);
-            border-radius: 12px;
-            border: 2px solid rgba(6, 182, 212, 0.2);
-            box-shadow: 0 4px 12px rgba(6, 182, 212, 0.1);
-        }
-
-        .match-percentage {
-            font-size: 48px;
-            font-weight: 900;
-            margin-bottom: 8px;
-            text-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-            line-height: 1;
-            letter-spacing: -0.02em;
-        }
-
-        .match-label {
-            font-size: 12px;
-            text-transform: uppercase;
-            letter-spacing: 2px;
-            opacity: 0.9;
-            font-weight: 800;
-            margin-bottom: 6px;
-            color: #0369A1;
-        }
-
-        .score-excellent { color: #22C55E; }
-        .score-good { color: #F59E0B; }
-        .score-moderate { color: #6B7280; }
-
-        .score-bar {
-            width: 220px;
-            height: 14px;
-            background: rgba(226, 232, 240, 0.8);
-            border-radius: 8px;
-            overflow: hidden;
-            margin-top: 8px;
-            box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.1);
-            border: 1px solid rgba(6, 182, 212, 0.2);
-        }
-
-        .score-fill {
-            height: 100%;
-            border-radius: 4px;
-            transition: width 1s ease;
-        }
-
-        .fill-excellent { background: linear-gradient(90deg, #22C55E, #16A34A); }
-        .fill-good { background: linear-gradient(90deg, #F59E0B, #DC2626); }
-        .fill-moderate { background: linear-gradient(90deg, #6B7280, #4B5563); }
-        
-        /* Tooltip styles for Find by Description */
-        .tooltip {
-            position: relative;
-            display: inline-block;
-            cursor: help;
-        }
-        
-        .tooltip-icon {
-            display: inline-block;
-            width: 18px;
-            height: 18px;
-            background: linear-gradient(135deg, #06b6d4, #0891b2);
-            color: white;
-            border-radius: 50%;
-            text-align: center;
-            line-height: 18px;
-            font-size: 12px;
-            font-weight: bold;
-            margin-left: 8px;
-            cursor: help;
-            box-shadow: 0 2px 4px rgba(6, 182, 212, 0.3);
-            transition: all 0.2s ease;
-        }
-        
-        .tooltip-icon:hover {
-            background: linear-gradient(135deg, #0891b2, #0e7490);
-            transform: scale(1.1);
-            box-shadow: 0 3px 6px rgba(6, 182, 212, 0.4);
-        }
-        
-        .tooltip-text {
-            visibility: hidden;
-            width: 320px;
-            background: linear-gradient(145deg, #1e293b, #334155);
-            color: #f1f5f9;
-            text-align: left;
-            border-radius: 12px;
-            padding: 16px;
-            position: absolute;
-            z-index: 1000;
-            bottom: 125%;
-            left: 50%;
-            margin-left: -160px;
-            opacity: 0;
-            transition: opacity 0.3s ease, transform 0.3s ease;
-            transform: translateY(10px);
-            font-size: 14px;
-            line-height: 1.5;
-            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.3);
-            border: 1px solid rgba(148, 163, 184, 0.2);
-        }
-        
-        .tooltip-text::after {
-            content: "";
-            position: absolute;
-            top: 100%;
-            left: 50%;
-            margin-left: -8px;
-            border-width: 8px;
-            border-style: solid;
-            border-color: #334155 transparent transparent transparent;
-        }
-        
-        .tooltip:hover .tooltip-text {
-            visibility: visible;
-            opacity: 1;
-            transform: translateY(0);
-        }
-        
-        .tooltip-text strong {
-            color: #06b6d4;
-            font-weight: 700;
-            display: block;
-            margin-bottom: 8px;
-            font-size: 15px;
-        }
-        </style>
-        """
-        
-        self.criteria_search_css = """
-        <style>
-        .recommendations-container {
-            display: flex;
-            flex-direction: column;
-            gap: 15px;
-            padding: 15px;
-        }
-
-        .breed-card {
-            border: 1px solid #d1d5db;
-            border-radius: 8px;
-            padding: 16px;
-            background: #ffffff;
-            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
-            transition: all 0.2s ease;
-        }
-
-        .breed-card:hover {
-            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
-            transform: translateY(-1px);
-        }
-
-        .breed-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 12px;
-            padding-bottom: 8px;
-            border-bottom: 1px solid #f3f4f6;
-        }
-
-        .breed-title {
-            display: flex;
-            align-items: center;
-            gap: 16px;
-            justify-content: flex-start;
-        }
-
-        .trophy-rank {
-            font-size: 24px;
-            font-weight: 800;
-            color: #1f2937;
-        }
-
-        .breed-name {
-            font-size: 42px;
-            font-weight: 900;
-            color: #1f2937;
-            margin: 0;
-            padding: 8px 16px;
-            background: linear-gradient(135deg, #D1FAE5 0%, #A7F3D0 100%);
-            border: 2px solid #22C55E;
-            border-radius: 12px;
-            display: inline-block;
-            box-shadow: 0 2px 8px rgba(34, 197, 94, 0.2);
-        }
-
-        .overall-score {
-            display: flex;
-            flex-direction: column;
-            align-items: flex-end;
-        }
-
-        .score-percentage {
-            font-size: 32px;
-            font-weight: 900;
-            margin-bottom: 4px;
-            line-height: 1;
-        }
-
-        .score-label {
-            font-size: 10px;
-            text-transform: uppercase;
-            letter-spacing: 1px;
-            opacity: 0.7;
-            font-weight: 600;
-        }
-
-        .score-bar-wide {
-            width: 200px;
-            height: 8px;
-            background: #f3f4f6;
-            border-radius: 4px;
-            overflow: hidden;
-            margin-top: 6px;
-        }
-
-        .score-fill-wide {
-            height: 100%;
-            border-radius: 4px;
-            transition: width 0.8s ease;
-        }
-
-        .score-excellent { color: #22C55E; }
-        .score-good { color: #65a30d; }
-        .score-moderate { color: #d4a332; }
-        .score-fair { color: #e67e22; }
-        .score-poor { color: #e74c3c; }
-
-        .fill-excellent { background: #22C55E; }
-        .fill-good { background: #65a30d; }
-        .fill-moderate { background: #d4a332; }
-        .fill-fair { background: #e67e22; }
-        .fill-poor { background: #e74c3c; }
 
-        .breed-details {
-            margin-top: 12px;
-            padding-top: 12px;
-            border-top: 1px solid #e5e7eb;
-        }
-        
-        /* 通用樣式（兩個模式都需要） */
-        .progress {
-            transition: all 0.3s ease-in-out;
-            border-radius: 4px;
-            height: 12px;
-        }
-        
-        .progress-bar {
-            background-color: #f5f5f5;
-            border-radius: 4px;
-            overflow: hidden;
-            position: relative;
-        }
-        
-        .score-item {
-            margin: 10px 0;
-        }
-        
-        .percentage {
-            margin-left: 8px;
-            font-weight: 500;
-        }
+class RecommendationHTMLFormatter:
+    """處理推薦結果的HTML格式化，CSS樣式從recommendation_css.py導入"""
 
-        /* White Tooltip Styles from styles.py */
-        .tooltip {
-            position: relative;
-            display: inline-flex;
-            align-items: center;
-            gap: 4px;
-            cursor: help;
-        }
-        .tooltip .tooltip-icon {
-            font-size: 14px;
-            color: #666;
-        }
-        .tooltip .tooltip-text {
-            visibility: hidden;
-            width: 250px;
-            background-color: rgba(44, 62, 80, 0.95);
-            color: white;
-            text-align: left;
-            border-radius: 8px;
-            padding: 8px 10px;
-            position: absolute;
-            z-index: 100;
-            bottom: 150%;
-            left: 50%;
-            transform: translateX(-50%);
-            opacity: 0;
-            transition: all 0.3s ease;
-            font-size: 14px;
-            line-height: 1.3;
-            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.2);
-            border: 1px solid rgba(255, 255, 255, 0.1);
-            margin-bottom: 10px;
-        }
-        .tooltip:hover .tooltip-text {
-            visibility: visible;
-            opacity: 1;
-        }
-        .tooltip .tooltip-text::after {
-            content: "";
-            position: absolute;
-            top: 100%;
-            left: 50%;
-            transform: translateX(-50%);
-            border-width: 8px;
-            border-style: solid;
-            border-color: rgba(44, 62, 80, 0.95) transparent transparent transparent;
-        }
-        
-        </style>
-        """
-        
-        self.unified_css = """
-        <style>
-        .unified-recommendations { max-width: 1200px; margin: 0 auto; padding: 20px; }
-        .unified-breed-card {
-            background: linear-gradient(145deg, #ffffff 0%, #f8fafc 100%);
-            border-radius: 16px; padding: 24px; margin-bottom: 20px;
-            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1); border: 1px solid #e2e8f0;
-            transition: all 0.3s ease;
-        }
-        .unified-breed-card:hover { transform: translateY(-2px); box-shadow: 0 12px 35px rgba(0, 0, 0, 0.15); }
-        .unified-breed-header { margin-bottom: 20px; }
-        .unified-rank-section { display: flex; align-items: center; gap: 15px; }
-        .unified-rank-badge {
-            background: linear-gradient(135deg, #E0F2FE 0%, #BAE6FD 100%);
-            color: #0C4A6E; padding: 8px 16px; border-radius: 8px;
-            font-weight: 900; font-size: 24px;
-            box-shadow: 0 2px 8px rgba(14, 165, 233, 0.2);
-            border: 2px solid #0EA5E9;
-            display: inline-block;
-            min-width: 80px; text-align: center;
-        }
-        .unified-breed-info { flex-grow: 1; }
-        .unified-breed-title { 
-            font-size: 24px; font-weight: 800; color: #0C4A6E; 
-            margin: 0; letter-spacing: -0.02em;
-            background: linear-gradient(135deg, #F0F9FF, #E0F2FE);
-            padding: 12px 20px; border-radius: 10px;
-            border: 2px solid #0EA5E9;
-            display: inline-block; box-shadow: 0 2px 8px rgba(14, 165, 233, 0.1);
-        }
-        .unified-match-score {
-            font-size: 24px; font-weight: 900;
-            color: #0F5132; background: linear-gradient(135deg, #D1FAE5, #A7F3D0);
-            padding: 12px 20px; border-radius: 10px; display: inline-block;
-            text-align: center; border: 2px solid #22C55E;
-            box-shadow: 0 2px 8px rgba(34, 197, 94, 0.2);
-            margin: 0; text-shadow: 0 1px 2px rgba(255, 255, 255, 0.5);
-            letter-spacing: -0.02em;
-        }
-        .unified-overall-section {
-            background: linear-gradient(135deg, #f0f9ff, #ecfeff); border-radius: 12px;
-            padding: 20px; margin-bottom: 24px; border: 2px solid #06b6d4;
-            box-shadow: 0 4px 12px rgba(6, 182, 212, 0.1);
-        }
-        .unified-dimension-grid {
-            display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-            gap: 16px; margin-bottom: 24px;
-        }
-        .unified-dimension-item {
-            background: white; padding: 16px; border-radius: 10px;
-            border: 1px solid #e2e8f0; transition: all 0.2s ease;
-        }
-        .unified-dimension-item:hover { background: #f8fafc; border-color: #cbd5e1; }
-        .unified-breed-info {
-            display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-            gap: 12px; margin: 20px 0;
-        }
-        .unified-info-item {
-            background: #f8fafc; padding: 12px; border-radius: 8px;
-            border-left: 4px solid #6366f1;
-        }
-        .unified-info-label { font-weight: 600; color: #4b5563; font-size: 0.85em; margin-bottom: 4px; }
-        .unified-info-value { color: #1f2937; font-weight: 500; }
-        
-        /* Tooltip styles for unified recommendations */
-        .tooltip {
-            position: relative;
-            display: inline-block;
-            cursor: help;
-        }
-        
-        .tooltip-icon {
-            display: inline-block;
-            width: 18px;
-            height: 18px;
-            background: linear-gradient(135deg, #06b6d4, #0891b2);
-            color: white;
-            border-radius: 50%;
-            text-align: center;
-            line-height: 18px;
-            font-size: 12px;
-            font-weight: bold;
-            margin-left: 8px;
-            cursor: help;
-            box-shadow: 0 2px 4px rgba(6, 182, 212, 0.3);
-            transition: all 0.2s ease;
-        }
-        
-        .tooltip-icon:hover {
-            background: linear-gradient(135deg, #0891b2, #0e7490);
-            transform: scale(1.1);
-            box-shadow: 0 3px 6px rgba(6, 182, 212, 0.4);
-        }
-        
-        .tooltip-text {
-            visibility: hidden;
-            width: 320px;
-            background: linear-gradient(145deg, #1e293b, #334155);
-            color: #f1f5f9;
-            text-align: left;
-            border-radius: 12px;
-            padding: 16px;
-            position: absolute;
-            z-index: 1000;
-            bottom: 125%;
-            left: 50%;
-            margin-left: -160px;
-            opacity: 0;
-            transition: opacity 0.3s ease, transform 0.3s ease;
-            transform: translateY(10px);
-            font-size: 14px;
-            line-height: 1.5;
-            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.3);
-            border: 1px solid rgba(148, 163, 184, 0.2);
-        }
-        
-        .tooltip-text::after {
-            content: "";
-            position: absolute;
-            top: 100%;
-            left: 50%;
-            margin-left: -8px;
-            border-width: 8px;
-            border-style: solid;
-            border-color: #334155 transparent transparent transparent;
-        }
-        
-        .tooltip:hover .tooltip-text {
-            visibility: visible;
-            opacity: 1;
-            transform: translateY(0);
-        }
-        
-        .tooltip-text strong {
-            color: #06b6d4;
-            font-weight: 700;
-            display: block;
-            margin-bottom: 8px;
-            font-size: 15px;
-        }
-        
-        .akc-button:hover {
-            transform: translateY(-2px) !important;
-            box-shadow: 0 6px 16px rgba(59, 130, 246, 0.5) !important;
-        }
-        </style>
-        """
+    def __init__(self):
+        # 從 recommendation_css.py 導入 CSS 樣式
+        self.description_search_css = DESCRIPTION_SEARCH_CSS
+        self.criteria_search_css = CRITERIA_SEARCH_CSS
+        self.unified_css = UNIFIED_CSS
 
     def format_unified_percentage(self, score: float) -> str:
         """統一格式化百分比顯示，確保數值邏輯一致"""

scoring_calculation_system.py

@@ -1,3 +1,4 @@
+# %%writefile scoring_calculation_system.py
 from dataclasses import dataclass
 from typing import Dict, List, Any, Optional
 import math
@@ -111,7 +112,9 @@ def calculate_compatibility_score(breed_info: dict, user_prefs: UserPreferences)
             'grooming': _dimension_calculator.calculate_grooming_score(
                 breed_info.get('Grooming Needs', 'Moderate'),
                 user_prefs.grooming_commitment.lower(),
-                breed_info['Size']
+                breed_info['Size'],
+                breed_info.get('Breed', ''),
+                breed_info.get('Temperament', '')
             ),
             'experience': _dimension_calculator.calculate_experience_score(
                 breed_info.get('Care Level', 'Moderate'),
@@ -494,4 +497,4 @@ def calculate_unified_breed_scores(breed_list: List[str], user_prefs: UserPrefer
     # 按總分排序
     scores.sort(key=lambda x: x.overall_score, reverse=True)
 
-    return scores
+    return scores

semantic_breed_recommender.py

@@ -1,3 +1,4 @@
+# %%writefile semantic_breed_recommender.py
 import random
 import hashlib
 import numpy as np
@@ -21,6 +22,7 @@ from config_manager import get_config_manager, get_standardized_breed_data
 from semantic_vector_manager import SemanticVectorManager, BreedDescriptionVector
 from user_query_analyzer import UserQueryAnalyzer
 from matching_score_calculator import MatchingScoreCalculator
+from smart_breed_filter import apply_smart_filtering
 
 class SemanticBreedRecommender:
     """
@@ -49,17 +51,23 @@ class SemanticBreedRecommender:
         # 初始化增強系統組件（如果可用）
         try:
             self.query_engine = QueryUnderstandingEngine()
+            print("QueryUnderstandingEngine initialized")
             self.constraint_manager = ConstraintManager()
+            print("ConstraintManager initialized")
             self.multi_head_scorer = None
             self.score_calibrator = ScoreCalibrator()
+            print("ScoreCalibrator initialized")
             self.config_manager = get_config_manager()
 
             # 如果 SBERT 模型可用，初始化多頭評分器
             if self.sbert_model:
                 self.multi_head_scorer = MultiHeadScorer(self.sbert_model)
                 print("Multi-head scorer initialized with SBERT model")
-        except ImportError:
-            print("Enhanced system components not available, using basic functionality")
+            else:
+                print("WARNING: SBERT model not available, multi_head_scorer will be None")
+        except Exception as e:
+            print(f"Error initializing enhanced system components: {str(e)}")
+            print(traceback.format_exc())
             self.query_engine = None
             self.constraint_manager = None
             self.multi_head_scorer = None
@@ -107,6 +115,444 @@ class SemanticBreedRecommender:
         """當增強系統失敗時獲取備用推薦"""
         return self.score_calculator.get_fallback_recommendations(top_k)
 
+    def _get_fallback_scoring_with_constraints(self, user_input: str,
+                                               passed_breeds: set,
+                                               dimensions: 'QueryDimensions',
+                                               top_k: int = 15) -> List[Dict[str, Any]]:
+        """
+        當 multi_head_scorer 不可用時的回退評分方法
+        關鍵：仍然尊重 constraint_manager 的過濾結果，並產生自然分佈的分數
+        """
+        print(f"Fallback scoring for {len(passed_breeds)} filtered breeds")
+
+        recommendations = []
+        user_text = user_input.lower()
+
+        # 提取用戶需求關鍵詞
+        lifestyle_keywords = self._extract_lifestyle_keywords(user_input)
+
+        for breed in passed_breeds:
+            breed_info = get_dog_description(breed.replace(' ', '_')) or {}
+            if not breed_info:
+                continue
+
+            # 計算多維度匹配分數
+            dimension_scores = self._calculate_comprehensive_dimension_scores(
+                breed, breed_info, user_text, dimensions, lifestyle_keywords
+            )
+
+            # 基於維度分數計算加權總分
+            weights = self._get_dimension_weights_from_query(user_text, dimensions)
+            weighted_sum = sum(dimension_scores.get(dim, 0.7) * weights.get(dim, 1.0)
+                             for dim in dimension_scores)
+            total_weight = sum(weights.get(dim, 1.0) for dim in dimension_scores)
+            final_score = weighted_sum / total_weight if total_weight > 0 else 0.7
+
+            # 確保分數在合理範圍內（允許高分，非常契合的品種可超過 90%）
+            final_score = max(0.45, min(0.98, final_score))
+            dimension_scores['overall'] = final_score
+
+            recommendation = {
+                'breed': breed.replace('_', ' '),
+                'rank': 0,
+                'overall_score': final_score,
+                'final_score': final_score,
+                'scores': dimension_scores,
+                '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_with_constraints',
+            }
+
+            recommendations.append(recommendation)
+
+        # 按分數排序
+        recommendations.sort(key=lambda x: -x['final_score'])
+
+        # 更新排名
+        for i, rec in enumerate(recommendations[:top_k]):
+            rec['rank'] = i + 1
+
+        print(f"Generated {len(recommendations[:top_k])} fallback recommendations")
+        return recommendations[:top_k]
+
+    def _calculate_comprehensive_dimension_scores(self, breed: str, breed_info: Dict,
+                                                   user_text: str, dimensions,
+                                                   lifestyle_keywords: Dict) -> Dict[str, float]:
+        """
+        計算全面的維度分數，產生自然分佈的評分
+        """
+        scores = {}
+        temperament = breed_info.get('Temperament', '').lower()
+        size = breed_info.get('Size', 'Medium').lower()
+        exercise_needs = breed_info.get('Exercise Needs', 'Moderate').lower()
+        grooming_needs = breed_info.get('Grooming Needs', 'Moderate').lower()
+        good_with_children = breed_info.get('Good with Children', 'Yes')
+        care_level = breed_info.get('Care Level', 'Moderate').lower()
+        description = breed_info.get('Description', '').lower()
+
+        # 1. 空間相容性
+        space_score = 0.7
+        if 'apartment' in user_text or 'small space' in user_text:
+            if 'small' in size or 'toy' in size:
+                space_score = 0.96
+            elif 'medium' in size:
+                space_score = 0.78
+            elif 'large' in size:
+                space_score = 0.52
+            else:
+                space_score = 0.45
+        elif 'house' in user_text or 'yard' in user_text:
+            if 'large' in size:
+                space_score = 0.92
+            elif 'medium' in size:
+                space_score = 0.88
+            else:
+                space_score = 0.82
+        scores['space'] = space_score
+
+        # 2. 運動相容性
+        exercise_score = 0.7
+        user_wants_high = any(w in user_text for w in ['energetic', 'active', 'running', 'hiking', 'athletic'])
+        user_wants_low = any(w in user_text for w in ['low maintenance', 'relaxed', 'calm', 'couch'])
+
+        if user_wants_high:
+            if 'very high' in exercise_needs:
+                exercise_score = 0.98
+            elif 'high' in exercise_needs:
+                exercise_score = 0.92
+            elif 'moderate' in exercise_needs:
+                exercise_score = 0.68
+            else:
+                exercise_score = 0.48
+        elif user_wants_low:
+            if 'low' in exercise_needs:
+                exercise_score = 0.96
+            elif 'moderate' in exercise_needs:
+                exercise_score = 0.78
+            elif 'high' in exercise_needs:
+                exercise_score = 0.52
+            else:
+                exercise_score = 0.42
+        else:
+            # 中等運動需求
+            if 'moderate' in exercise_needs:
+                exercise_score = 0.88
+            elif 'low' in exercise_needs or 'high' in exercise_needs:
+                exercise_score = 0.72
+            else:
+                exercise_score = 0.65
+        scores['exercise'] = exercise_score
+
+        # 3. 美容需求相容性
+        grooming_score = 0.7
+        user_wants_low_maintenance = any(w in user_text for w in ['low maintenance', 'easy care', 'minimal grooming'])
+
+        if user_wants_low_maintenance:
+            if 'low' in grooming_needs or 'minimal' in grooming_needs:
+                grooming_score = 0.96
+            elif 'moderate' in grooming_needs:
+                grooming_score = 0.75
+            else:
+                grooming_score = 0.50
+        else:
+            if 'low' in grooming_needs:
+                grooming_score = 0.85
+            elif 'moderate' in grooming_needs:
+                grooming_score = 0.78
+            else:
+                grooming_score = 0.70
+        scores['grooming'] = grooming_score
+
+        # 4. 噪音相容性
+        noise_score = 0.7
+        user_wants_quiet = any(w in user_text for w in ['quiet', 'silent', 'noise', 'bark', 'neighbors'])
+
+        if user_wants_quiet:
+            # 從 breed_noise_info 獲取噪音資訊
+            noise_info = breed_noise_info.get(breed.replace(' ', '_'), {})
+            noise_level = noise_info.get('noise_level', 'Moderate').lower()
+
+            if 'low' in noise_level or 'quiet' in noise_level:
+                noise_score = 0.97
+            elif 'moderate' in noise_level:
+                noise_score = 0.72
+            elif 'high' in noise_level:
+                noise_score = 0.45
+            else:
+                # 根據性格推斷
+                if any(w in temperament for w in ['calm', 'quiet', 'gentle', 'reserved']):
+                    noise_score = 0.88
+                elif any(w in temperament for w in ['alert', 'vocal', 'energetic']):
+                    noise_score = 0.55
+                else:
+                    noise_score = 0.70
+        scores['noise'] = noise_score
+
+        # 5. 家庭相容性
+        family_score = 0.7
+        has_family_context = any(w in user_text for w in ['kids', 'children', 'family', 'child'])
+
+        if has_family_context:
+            if good_with_children == 'Yes':
+                family_score = 0.94
+                # 額外加分：溫和性格
+                if any(w in temperament for w in ['gentle', 'friendly', 'patient', 'loving']):
+                    family_score = min(0.98, family_score + 0.04)
+            elif good_with_children == 'No':
+                family_score = 0.32
+            else:
+                family_score = 0.62
+        else:
+            family_score = 0.76 if good_with_children == 'Yes' else 0.70
+        scores['family'] = family_score
+
+        # 6. 經驗相容性
+        experience_score = 0.7
+        is_beginner = any(w in user_text for w in ['first dog', 'first time', 'beginner', 'new owner', 'never had'])
+
+        if is_beginner:
+            # 評估品種對新手的友好程度
+            if 'low' in care_level or 'easy' in care_level:
+                experience_score = 0.94
+            elif 'moderate' in care_level:
+                experience_score = 0.78
+            else:
+                experience_score = 0.52
+
+            # 性格調整
+            if any(w in temperament for w in ['eager to please', 'trainable', 'intelligent', 'friendly']):
+                experience_score = min(0.98, experience_score + 0.08)
+            if any(w in temperament for w in ['stubborn', 'independent', 'strong-willed']):
+                experience_score = max(0.38, experience_score - 0.18)
+        else:
+            experience_score = 0.80
+        scores['experience'] = experience_score
+
+        # 7. 健康分數（基於壽命和品種特性）
+        health_score = 0.75
+        lifespan = breed_info.get('Lifespan', '10-12 years')
+        try:
+            # 解析壽命
+            years = [int(y) for y in lifespan.replace(' years', '').split('-') if y.strip().isdigit()]
+            if years:
+                avg_lifespan = sum(years) / len(years)
+                if avg_lifespan >= 14:
+                    health_score = 0.94
+                elif avg_lifespan >= 12:
+                    health_score = 0.85
+                elif avg_lifespan >= 10:
+                    health_score = 0.75
+                else:
+                    health_score = 0.62
+        except:
+            pass
+        scores['health'] = health_score
+
+        return scores
+
+    def _get_dimension_weights_from_query(self, user_text: str, dimensions) -> Dict[str, float]:
+        """
+        根據用戶查詢動態計算維度權重
+        """
+        weights = {
+            'space': 1.0,
+            'exercise': 1.0,
+            'grooming': 1.0,
+            'noise': 1.0,
+            'family': 1.0,
+            'experience': 1.0,
+            'health': 0.8
+        }
+
+        # 根據 dimensions 的 priority 調整權重
+        if hasattr(dimensions, 'dimension_priorities'):
+            priority_map = getattr(dimensions, 'dimension_priorities', {})
+            for dim, priority in priority_map.items():
+                if dim in weights:
+                    weights[dim] = priority
+                # 映射不同名稱
+                if dim == 'size':
+                    weights['space'] = max(weights['space'], priority)
+                if dim == 'family':
+                    weights['family'] = max(weights['family'], priority)
+
+        # 根據關鍵詞強化權重
+        if any(w in user_text for w in ['quiet', 'noise', 'bark', 'neighbors', 'thin walls']):
+            weights['noise'] = max(weights['noise'], 2.2)
+        if any(w in user_text for w in ['kids', 'children', 'family', 'child']):
+            weights['family'] = max(weights['family'], 2.0)
+        if any(w in user_text for w in ['first', 'beginner', 'new owner']):
+            weights['experience'] = max(weights['experience'], 2.0)
+        if any(w in user_text for w in ['apartment', 'small space', 'studio']):
+            weights['space'] = max(weights['space'], 1.8)
+        if any(w in user_text for w in ['energetic', 'active', 'running', 'hiking']):
+            weights['exercise'] = max(weights['exercise'], 2.0)
+        if any(w in user_text for w in ['low maintenance', 'easy care']):
+            weights['grooming'] = max(weights['grooming'], 1.8)
+
+        return weights
+
+    def _calculate_real_dimension_scores(self, breed: str, breed_info: Dict,
+                                        user_input: str, overall_score: float) -> Dict[str, float]:
+        """
+        計算真實的維度分數（基於品種特性和用戶需求）
+        這個方法取代了假分數生成器，提供真實的評分
+
+        Args:
+            breed: 品種名稱
+            breed_info: 品種資訊字典
+            user_input: 用戶輸入文字
+            overall_score: 總體分數
+
+        Returns:
+            Dict[str, float]: 維度分數字典
+        """
+        if not breed_info:
+            breed_info = {}
+
+        user_text = user_input.lower()
+        temperament = breed_info.get('Temperament', '').lower()
+        size = breed_info.get('Size', 'Medium').lower()
+        exercise_needs = breed_info.get('Exercise Needs', 'Moderate').lower()
+        grooming_needs = breed_info.get('Grooming Needs', 'Moderate').lower()
+        good_with_children = breed_info.get('Good with Children', 'Yes')
+        care_level = breed_info.get('Care Level', 'Moderate').lower()
+
+        scores = {}
+
+        # 1. Space Compatibility (空間相容性)
+        space_score = 0.7
+        if 'apartment' in user_text or 'small' in user_text:
+            if 'small' in size:
+                space_score = 0.9
+            elif 'medium' in size:
+                space_score = 0.7
+            elif 'large' in size:
+                space_score = 0.5
+            elif 'giant' in size:
+                space_score = 0.3
+        elif 'house' in user_text or 'yard' in user_text:
+            if 'large' in size or 'giant' in size:
+                space_score = 0.85
+            else:
+                space_score = 0.8
+        scores['space'] = space_score
+
+        # 2. Exercise Compatibility (運動相容性)
+        exercise_score = 0.7
+        if 'low' in exercise_needs or 'minimal' in exercise_needs:
+            if any(term in user_text for term in ['work full time', 'busy', 'low exercise', 'not much exercise']):
+                exercise_score = 0.9
+            else:
+                exercise_score = 0.75
+        elif 'high' in exercise_needs or 'very high' in exercise_needs:
+            if any(term in user_text for term in ['active', 'running', 'hiking', 'exercise']):
+                exercise_score = 0.9
+            elif any(term in user_text for term in ['work full time', 'busy']):
+                exercise_score = 0.5
+            else:
+                exercise_score = 0.65
+        else:  # moderate
+            exercise_score = 0.75
+        scores['exercise'] = exercise_score
+
+        # 3. Grooming/Maintenance Compatibility (美容/維護相容性)
+        grooming_score = 0.7
+        if 'low' in grooming_needs:
+            if any(term in user_text for term in ['low maintenance', 'low-maintenance', 'easy care', 'minimal grooming']):
+                grooming_score = 0.9
+            else:
+                grooming_score = 0.8
+        elif 'high' in grooming_needs:
+            if any(term in user_text for term in ['low maintenance', 'low-maintenance', 'easy care']):
+                grooming_score = 0.4
+            else:
+                grooming_score = 0.6
+
+        # 敏感品種需要額外照顧
+        if 'sensitive' in temperament:
+            grooming_score -= 0.1
+        # 特殊品種需要額外護理
+        breed_lower = breed.lower()
+        if any(term in breed_lower for term in ['italian', 'greyhound', 'whippet', 'hairless']):
+            if any(term in user_text for term in ['low maintenance', 'low-maintenance', 'easy']):
+                grooming_score -= 0.15
+        scores['grooming'] = max(0.2, grooming_score)
+
+        # 4. Experience Compatibility (經驗相容性) - 關鍵維度！
+        experience_score = 0.7
+        is_beginner = any(term in user_text for term in ['first dog', 'first time', 'beginner', 'new to dogs', 'never owned', 'never had'])
+
+        if is_beginner:
+            # 新手評估
+            if 'low' in care_level:
+                experience_score = 0.85
+            elif 'moderate' in care_level:
+                experience_score = 0.65
+            elif 'high' in care_level:
+                experience_score = 0.45
+
+            # 性格懲罰 - 對新手很重要
+            difficult_traits = ['sensitive', 'stubborn', 'independent', 'dominant', 'aggressive', 'nervous', 'shy', 'timid', 'alert']
+            for trait in difficult_traits:
+                if trait in temperament:
+                    if trait == 'sensitive':
+                        experience_score -= 0.15  # 敏感性格對新手很具挑戰
+                    elif trait == 'aggressive':
+                        experience_score -= 0.25
+                    elif trait in ['stubborn', 'independent', 'dominant']:
+                        experience_score -= 0.12
+                    else:
+                        experience_score -= 0.08
+
+            # 友善性格獎勵
+            easy_traits = ['friendly', 'gentle', 'eager to please', 'patient', 'calm', 'outgoing']
+            for trait in easy_traits:
+                if trait in temperament:
+                    experience_score += 0.08
+
+            # 易於訓練的加分
+            if any(term in user_text for term in ['easy to train', 'trainable']):
+                if any(term in temperament for term in ['eager to please', 'intelligent', 'trainable']):
+                    experience_score += 0.1
+                elif any(term in temperament for term in ['stubborn', 'independent']):
+                    experience_score -= 0.1
+        else:
+            # 有經驗的飼主
+            experience_score = 0.8
+
+        scores['experience'] = max(0.2, min(0.95, experience_score))
+
+        # 5. Noise Compatibility (噪音相容性)
+        noise_score = 0.75
+        if any(term in user_text for term in ['quiet', 'apartment', 'neighbors']):
+            if any(term in temperament for term in ['quiet', 'calm', 'gentle']):
+                noise_score = 0.9
+            elif any(term in temperament for term in ['alert', 'vocal', 'barking']):
+                noise_score = 0.5
+        scores['noise'] = noise_score
+
+        # 6. Family Compatibility (家庭相容性)
+        family_score = 0.7
+        if any(term in user_text for term in ['children', 'kids', 'family']):
+            if good_with_children == 'Yes' or good_with_children == True:
+                family_score = 0.9
+                if any(term in temperament for term in ['gentle', 'patient', 'friendly']):
+                    family_score = 0.95
+            else:
+                family_score = 0.35
+        scores['family'] = family_score
+
+        # 7. Overall
+        scores['overall'] = overall_score
+
+        return scores
+
     def get_enhanced_semantic_recommendations(self, user_input: str, top_k: int = 15) -> List[Dict[str, Any]]:
         """
         增強的多維度語義品種推薦
@@ -149,9 +595,16 @@ class SemanticBreedRecommender:
             if self.multi_head_scorer:
                 breed_scores = self.multi_head_scorer.score_breeds(filter_result.passed_breeds, dimensions)
                 print(f"Multi-head scoring completed for {len(breed_scores)} breeds")
+                # Debug: 顯示前5名的分數和維度breakdown
+                for bs in breed_scores[:5]:
+                    print(f"  {bs.breed_name}: final={bs.final_score:.3f}, breakdown={bs.dimensional_breakdown}")
             else:
-                print("Multi-head scorer not available, using fallback scoring")
-                return self.get_semantic_recommendations(user_input, top_k)
+                # 使用回退評分，但仍然尊重 constraint 過濾結果
+                print("Multi-head scorer not available, using fallback scoring with constraint filtering")
+                fallback_results = self._get_fallback_scoring_with_constraints(
+                    user_input, filter_result.passed_breeds, dimensions, top_k
+                )
+                return fallback_results
 
             # 階段 4: 分數校準
             if self.score_calibrator:
@@ -184,6 +637,19 @@ class SemanticBreedRecommender:
                 else:
                     breed_info = get_dog_description(breed_name.replace(' ', '_')) or {}
 
+                # 將 dimensional_breakdown 轉換為 UI 需要的 scores 格式
+                breakdown = breed_score.dimensional_breakdown or {}
+                ui_scores = {
+                    'space': breakdown.get('spatial_compatibility', 0.7),
+                    'exercise': breakdown.get('activity_compatibility', 0.7),
+                    'grooming': breakdown.get('maintenance_compatibility', 0.7),
+                    'experience': breakdown.get('experience_compatibility', 0.7),
+                    'noise': breakdown.get('noise_compatibility', 0.7),
+                    'family': breakdown.get('family_compatibility', 0.7),
+                    'health': breakdown.get('health_compatibility', 0.7),
+                    'overall': calibrated_score
+                }
+
                 recommendation = {
                     'breed': breed_name,
                     'rank': i + 1,
@@ -194,6 +660,7 @@ class SemanticBreedRecommender:
                     'bidirectional_bonus': breed_score.bidirectional_bonus,
                     'confidence_score': breed_score.confidence_score,
                     'dimensional_breakdown': breed_score.dimensional_breakdown,
+                    'scores': ui_scores,  # UI 需要的格式
                     'explanation': breed_score.explanation,
                     'size': breed_info.get('Size', 'Unknown'),
                     'temperament': breed_info.get('Temperament', ''),
@@ -417,15 +884,45 @@ class SemanticBreedRecommender:
                     'lifestyle_bonus': breed_data['lifestyle_bonus']
                 })
 
-            # 按顯示分數排序以確保排名一致性
-            breed_display_scores.sort(key=lambda x: x['display_score'], reverse=True)
+            # 計算真實維度分數並整合到排序中
+            for breed_data in breed_display_scores:
+                breed = breed_data['breed']
+                breed_info = get_dog_description(breed)
+                real_scores = self._calculate_real_dimension_scores(
+                    breed, breed_info, user_input, breed_data['display_score']
+                )
+                breed_data['real_scores'] = real_scores
+
+                # 計算加權的最終分數（考慮維度分數）
+                # 原始顯示分數權重 50%，維度分數平均權重 50%
+                dim_scores = [real_scores.get('space', 0.7), real_scores.get('exercise', 0.7),
+                             real_scores.get('grooming', 0.7), real_scores.get('experience', 0.7),
+                             real_scores.get('noise', 0.7)]
+                avg_dim_score = sum(dim_scores) / len(dim_scores)
+
+                # 對低維度分數施加懲罰
+                min_dim_score = min(dim_scores)
+                penalty = 0
+                if min_dim_score < 0.5:
+                    penalty = (0.5 - min_dim_score) * 0.3  # 最低分數懲罰
+
+                # 最終排序分數
+                breed_data['adjusted_score'] = (
+                    breed_data['display_score'] * 0.5 +
+                    avg_dim_score * 0.5 -
+                    penalty
+                )
+
+            # 按調整後的分數排序
+            breed_display_scores.sort(key=lambda x: x['adjusted_score'], reverse=True)
             top_breeds = breed_display_scores[:top_k]
 
             # 轉換為標準推薦格式
             recommendations = []
             for i, breed_data in enumerate(top_breeds):
                 breed = breed_data['breed']
-                display_score = breed_data['display_score']
+                adjusted_score = breed_data['adjusted_score']
+                real_scores = breed_data['real_scores']
 
                 # 獲取詳細信息
                 breed_info = get_dog_description(breed)
@@ -433,8 +930,8 @@ class SemanticBreedRecommender:
                 recommendation = {
                     'breed': breed.replace('_', ' '),
                     'rank': i + 1,
-                    'overall_score': display_score,  # 使用顯示分數以保持一致性
-                    'final_score': display_score,    # 確保 final_score 與 overall_score 匹配
+                    'overall_score': adjusted_score,  # 使用調整後的分數
+                    'final_score': adjusted_score,    # 確保 final_score 與 overall_score 匹配
                     'semantic_score': breed_data['semantic_score'],
                     'comparative_bonus': breed_data['comparative_bonus'],
                     'lifestyle_bonus': breed_data['lifestyle_bonus'],
@@ -445,7 +942,8 @@ class SemanticBreedRecommender:
                     'good_with_children': breed_info.get('Good with Children', 'Yes') if breed_info else 'Yes',
                     'lifespan': breed_info.get('Lifespan', '10-12 years') if breed_info else '10-12 years',
                     'description': breed_info.get('Description', '') if breed_info else '',
-                    'search_type': 'description'
+                    'search_type': 'description',
+                    'scores': real_scores  # 添加真實的維度分數
                 }
 
                 recommendations.append(recommendation)
@@ -459,12 +957,20 @@ class SemanticBreedRecommender:
             return []
 
     def get_enhanced_recommendations_with_unified_scoring(self, user_input: str, top_k: int = 15) -> List[Dict[str, Any]]:
-        """簡化的增強推薦方法"""
+        """
+        增強推薦方法 - 使用完整的多頭評分系統
+
+        這個方法使用:
+        - QueryUnderstandingEngine: 解析用戶意圖
+        - PriorityDetector: 檢測維度優先級
+        - MultiHeadScorer: 多維度評分
+        - DynamicWeightCalculator: 動態權重分配
+        """
         try:
-            print(f"Processing enhanced recommendation: {user_input[:50]}...")
+            print(f"Processing enhanced recommendation with multi-head scoring: {user_input[:50]}...")
 
-            # 使用基本語意匹配
-            return self.get_semantic_recommendations(user_input, top_k)
+            # 使用完整的增強語義推薦系統（包含 multi_head_scorer）
+            return self.get_enhanced_semantic_recommendations(user_input, top_k)
 
         except Exception as e:
             error_msg = f"Enhanced recommendation error: {str(e)}. Please check your description."
@@ -630,65 +1136,61 @@ def get_breed_recommendations_by_description(user_description: str,
 
 
 def get_enhanced_recommendations_with_unified_scoring(user_description: str, top_k: int = 15) -> List[Dict[str, Any]]:
-    """簡化版本：基本語意推薦功能"""
+    """
+    模組層級便利函數 - 使用完整的多頭評分系統
+
+    這個函數呼叫 SemanticBreedRecommender 的增強推薦方法，使用:
+    - QueryUnderstandingEngine: 解析用戶意圖
+    - PriorityDetector: 檢測維度優先級
+    - MultiHeadScorer: 多維度評分
+    - DynamicWeightCalculator: 動態權重分配
+    - SmartBreedFilter: 智慧風險過濾（只對真正危害用戶的情況干預）
+
+    如果增強系統失敗，會自動回退到基本語義推薦
+    """
     try:
-        print(f"Processing description-based recommendation: {user_description[:50]}...")
+        print(f"Processing description-based recommendation with multi-head scoring: {user_description[:50]}...")
 
-        # 創建基本推薦器實例
+        # 創建推薦器實例
         recommender = SemanticBreedRecommender()
 
+        # 檢查 SBERT 模型是否可用
         if not recommender.vector_manager.is_model_available():
             print("SBERT model not available, using basic text matching...")
-            # 使用基本文字匹配邏輯
-            return _get_basic_text_matching_recommendations(user_description, top_k, recommender)
-
-        # 使用語意相似度推薦
-        recommendations = []
-        user_embedding = recommender.vector_manager.encode_text(user_description)
-
-        # 計算所有品種的增強分數
-        all_breed_scores = []
-        for breed_name, breed_vector in recommender.breed_vectors.items():
-            breed_embedding = breed_vector.embedding
-            similarity = cosine_similarity([user_embedding], [breed_embedding])[0][0]
-
-            # 獲取品種資料
-            breed_info = get_dog_description(breed_name) or {}
-
-            # 計算增強的匹配分數
-            enhanced_score = recommender.score_calculator.calculate_enhanced_matching_score(
-                breed_name, breed_info, user_description, similarity
-            )
-
-            all_breed_scores.append((breed_name, enhanced_score, breed_info, similarity))
+            results = _get_basic_text_matching_recommendations(user_description, top_k, recommender)
+            # 應用智慧過濾
+            results = apply_smart_filtering(results, user_description)
+            return results
 
-        # 按 final_score 排序（而不是語意相似度）
-        all_breed_scores.sort(key=lambda x: x[1]['final_score'], reverse=True)
-        top_breeds = all_breed_scores[:top_k]
+        # 嘗試使用完整的增強語義推薦系統
+        try:
+            results = recommender.get_enhanced_semantic_recommendations(user_description, top_k)
+            if results:
+                # 應用智慧過濾
+                results = apply_smart_filtering(results, user_description)
+                return results
+            else:
+                print("Enhanced recommendations returned empty, falling back to basic semantic...")
+        except Exception as enhanced_error:
+            print(f"Enhanced recommendation failed: {str(enhanced_error)}, falling back to basic semantic...")
+            print(traceback.format_exc())
 
-        for i, (breed, enhanced_score, breed_info, similarity) in enumerate(top_breeds):
-            recommendation = {
-                'breed': breed.replace('_', ' '),
-                'rank': i + 1,  # 正確的排名
-                'overall_score': enhanced_score['final_score'],
-                'final_score': enhanced_score['final_score'],
-                'semantic_score': similarity,
-                'comparative_bonus': enhanced_score['lifestyle_bonus'],
-                'lifestyle_bonus': enhanced_score['lifestyle_bonus'],
-                'size': breed_info.get('Size', 'Unknown'),
-                'temperament': breed_info.get('Temperament', 'Unknown'),
-                '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', 'No description available'),
-                'search_type': 'description',
-                'scores': enhanced_score['dimension_scores']
-            }
-            recommendations.append(recommendation)
+        # 回退到基本語義推薦
+        try:
+            results = recommender.get_semantic_recommendations(user_description, top_k)
+            if results:
+                # 應用智慧過濾
+                results = apply_smart_filtering(results, user_description)
+                return results
+        except Exception as semantic_error:
+            print(f"Basic semantic recommendation also failed: {str(semantic_error)}")
 
-        print(f"Generated {len(recommendations)} semantic recommendations")
-        return recommendations
+        # 最後回退到基本文字匹配
+        print("All semantic methods failed, using basic text matching as last resort...")
+        results = _get_basic_text_matching_recommendations(user_description, top_k, recommender)
+        # 應用智慧過濾
+        results = apply_smart_filtering(results, user_description)
+        return results
 
     except Exception as e:
         error_msg = f"Error in semantic recommendation system: {str(e)}. Please check your input and try again."
@@ -730,6 +1232,29 @@ def _get_basic_text_matching_recommendations(user_description: str, top_k: int =
                 'Japanese_Spaniel', 'Toy_Terrier', 'Affenpinscher', 'Pekingese', 'Lhasa'
             ]
 
+        # 應用約束過濾 - 關鍵修復！
+        try:
+            from constraint_manager import ConstraintManager
+            from query_understanding import QueryUnderstandingEngine
+
+            query_engine = QueryUnderstandingEngine()
+            dimensions = query_engine.analyze_query(user_description)
+            constraint_manager = ConstraintManager()
+            filter_result = constraint_manager.apply_constraints(dimensions)
+
+            # 只保留通過約束的品種
+            allowed_breeds = filter_result.passed_breeds
+            filtered_count = len(basic_breeds)
+            basic_breeds = [b for b in basic_breeds if b in allowed_breeds]
+            print(f"Constraint filtering: {filtered_count} -> {len(basic_breeds)} breeds")
+
+            # 記錄被過濾的原因（用於調試）
+            for breed, reason in filter_result.filtered_breeds.items():
+                if breed in ['Italian_Greyhound', 'Rottweiler', 'Malinois']:
+                    print(f"  Filtered {breed}: {reason}")
+        except Exception as e:
+            print(f"Warning: Could not apply constraints: {str(e)}")
+
         for breed in basic_breeds:
             breed_info = get_dog_description(breed) or {}
             breed_text = f"{breed} {breed_info.get('Temperament', '')} {breed_info.get('Size', '')} {breed_info.get('Description', '')}".lower()

smart_breed_filter.py

@@ -0,0 +1,454 @@
+# %%writefile smart_breed_filter.py
+"""
+Smart Breed Filter - 智慧品種過濾系統
+
+設計原則：
+1. 只對「真正危害用戶」的情況進行干預
+2. 無傷大雅的偏好差異維持原有評分邏輯
+3. 所有規則基於通用性設計，不針對特定品種硬編碼
+
+危害類型：
+- 安全風險：幼童 + 高風險行為特徵
+- 生活品質嚴重影響：噪音零容忍 + 焦慮/警戒吠叫品種
+"""
+
+from typing import Dict, List, Tuple, Optional, Set
+from dataclasses import dataclass
+from breed_noise_info import breed_noise_info
+
+
+@dataclass
+class UserPriorityContext:
+    """用戶優先級上下文"""
+    noise_intolerance: bool = False      # 噪音零容忍
+    has_young_children: bool = False     # 有幼童
+    is_beginner: bool = False            # 新手
+    is_senior: bool = False              # 老年人
+    priority_dimensions: Dict[str, str] = None  # 各維度優先級
+
+    def __post_init__(self):
+        if self.priority_dimensions is None:
+            self.priority_dimensions = {}
+
+
+class PriorityParser:
+    """
+    優先級語意解析器
+
+    識別用戶是否對某些維度有「絕對需求」vs「一般偏好」
+    只在用戶明確強調時才觸發嚴格約束
+    """
+
+    # 絕對需求信號詞
+    ABSOLUTE_SIGNALS = [
+        'most importantly', 'absolutely need', 'must have', 'essential',
+        'critical', 'cannot', "can't", 'no way', 'zero tolerance',
+        'very noise sensitive', 'neighbors complain', 'thin walls'
+    ]
+
+    # 主要需求信號詞
+    PRIMARY_SIGNALS = [
+        'first', 'primarily', 'main priority', 'most important',
+        'first priority', 'number one'
+    ]
+
+    # 維度關鍵詞
+    DIMENSION_KEYWORDS = {
+        'noise': ['quiet', 'noise', 'bark', 'silent', 'neighbors',
+                  'thin walls', 'apartment noise', 'loud', 'vocal'],
+        'children': ['kids', 'children', 'child', 'toddler', 'baby',
+                    'infant', 'young kids', 'aged 1', 'aged 2', 'aged 3',
+                    'aged 4', 'aged 5', 'preschool'],
+        'exercise': ['active', 'exercise', 'running', 'hiking', 'energetic',
+                    'athletic', 'jogging', 'outdoor activities'],
+        'grooming': ['maintenance', 'grooming', 'shedding', 'brush', 'coat',
+                    'low maintenance', 'easy care'],
+    }
+
+    def parse(self, user_input: str) -> UserPriorityContext:
+        """解析用戶輸入，提取優先級上下文"""
+        text = user_input.lower()
+        context = UserPriorityContext()
+
+        # 檢測噪音零容忍
+        context.noise_intolerance = self._detect_noise_intolerance(text)
+
+        # 檢測是否有幼童
+        context.has_young_children = self._detect_young_children(text)
+
+        # 檢測各維度優先級
+        context.priority_dimensions = self._detect_dimension_priorities(text)
+
+        return context
+
+    def _detect_noise_intolerance(self, text: str) -> bool:
+        """
+        檢測噪音零容忍
+
+        只有當用戶明確表達噪音是嚴重問題時才觸發
+        例如：thin walls, neighbors complain, noise sensitive neighbors
+        """
+        # 強烈噪音敏感信號
+        strong_signals = [
+            'thin walls', 'noise sensitive', 'neighbors complain',
+            'zero tolerance', 'cannot bark', "can't bark",
+            'absolutely quiet', 'must be quiet', 'noise restriction'
+        ]
+
+        # 需要同時出現「噪音相關詞」+「強調詞」
+        noise_words = ['quiet', 'noise', 'bark', 'silent', 'loud']
+        emphasis_words = ['most importantly', 'absolutely', 'must', 'essential',
+                         'critical', 'very', 'extremely', 'cannot', "can't"]
+
+        # 檢查強烈信號
+        if any(signal in text for signal in strong_signals):
+            return True
+
+        # 檢查組合：噪音詞 + 強調詞
+        has_noise_word = any(w in text for w in noise_words)
+        has_emphasis = any(w in text for w in emphasis_words)
+
+        return has_noise_word and has_emphasis
+
+    def _detect_young_children(self, text: str) -> bool:
+        """
+        檢測是否有幼童或一般兒童
+
+        對於兒童安全，我們採取保守策略：
+        - 明確提到 kids/children 就視為有兒童風險需要考慮
+        - 因為牧羊本能的 nipping 對任何年齡兒童都有風險
+        """
+        # 任何提到兒童的情況都需要考慮安全
+        child_signals = [
+            'kids', 'children', 'child', 'toddler', 'baby', 'infant',
+            'young kids', 'young children',
+            'aged 1', 'aged 2', 'aged 3', 'aged 4', 'aged 5',
+            '1 year', '2 year', '3 year', '4 year', '5 year',
+            'preschool', 'newborn', 'family with'
+        ]
+        return any(signal in text for signal in child_signals)
+
+    def _detect_dimension_priorities(self, text: str) -> Dict[str, str]:
+        """檢測各維度的優先級"""
+        priorities = {}
+
+        for dimension, keywords in self.DIMENSION_KEYWORDS.items():
+            if any(kw in text for kw in keywords):
+                # 檢查是否有絕對需求信號
+                if any(signal in text for signal in self.ABSOLUTE_SIGNALS):
+                    # 檢查信號是否與該維度相關（在附近）
+                    for signal in self.ABSOLUTE_SIGNALS:
+                        if signal in text:
+                            signal_pos = text.find(signal)
+                            for kw in keywords:
+                                if kw in text:
+                                    kw_pos = text.find(kw)
+                                    # 如果信號詞和維度關鍵詞距離在50字符內
+                                    if abs(signal_pos - kw_pos) < 80:
+                                        priorities[dimension] = 'ABSOLUTE'
+                                        break
+                            if dimension in priorities:
+                                break
+
+                # 檢查是否有主要需求信號
+                if dimension not in priorities:
+                    if any(signal in text for signal in self.PRIMARY_SIGNALS):
+                        priorities[dimension] = 'PRIMARY'
+                    else:
+                        priorities[dimension] = 'PREFERENCE'
+
+        return priorities
+
+
+class BreedRiskAnalyzer:
+    """
+    品種風險分析器
+
+    只分析「真正的危害風險」，不對一般偏好差異進行干預
+    """
+
+    # 焦慮相關觸發詞（會導致持續吠叫的真正問題）
+    ANXIETY_TRIGGERS = ['anxiety', 'separation anxiety', 'loneliness']
+
+    # 高警戒觸發詞（會導致頻繁吠叫）
+    HIGH_ALERT_TRIGGERS = ['stranger alerts', 'strangers approaching',
+                           'suspicious activity', 'territorial defense',
+                           'protecting territory']
+
+    # 牧羊/追逐本能（對幼童有 nipping 風險）
+    HERDING_INDICATORS = ['herding instincts', 'herding', 'nipping']
+
+    # 獵物驅動（可能追逐小孩）
+    PREY_DRIVE_INDICATORS = ['prey drive', 'prey sighting', 'chase']
+
+    def analyze_noise_risk(self, breed_info: Dict, noise_info: Dict) -> Dict:
+        """
+        分析品種的噪音風險
+
+        只標記「真正會造成問題」的品種：
+        - 有焦慮吠叫傾向（持續性問題）
+        - 高度警戒吠叫（頻繁問題）
+
+        不標記：
+        - 偶爾興奮吠叫（正常狗行為）
+        - 打招呼吠叫（短暫且可控）
+        """
+        noise_notes = noise_info.get('noise_notes', '').lower()
+        noise_level = noise_info.get('noise_level', 'Moderate').lower()
+        temperament = breed_info.get('Temperament', '').lower()
+
+        risk_factors = []
+
+        # 1. 焦慮觸發 - 這是真正的問題（持續性吠叫）
+        has_anxiety = any(t in noise_notes for t in self.ANXIETY_TRIGGERS)
+        if has_anxiety:
+            risk_factors.append('anxiety_barking')
+
+        # 2. 高度警戒 - 頻繁吠叫風險
+        has_high_alert = any(t in noise_notes for t in self.HIGH_ALERT_TRIGGERS)
+        if has_high_alert:
+            risk_factors.append('high_alert_barking')
+
+        # 3. 敏感性格 + 焦慮觸發的組合（更嚴重）
+        is_sensitive = 'sensitive' in temperament
+        if is_sensitive and has_anxiety:
+            risk_factors.append('sensitive_anxiety_combo')
+
+        # 4. 基礎噪音等級高
+        if noise_level in ['high', 'moderate-high', 'moderate to high']:
+            risk_factors.append('high_base_noise')
+
+        # 計算風險等級
+        # 只有真正問題的組合才是 HIGH
+        if 'sensitive_anxiety_combo' in risk_factors:
+            risk_level = 'HIGH'
+        elif 'anxiety_barking' in risk_factors and 'high_alert_barking' in risk_factors:
+            risk_level = 'HIGH'
+        elif 'anxiety_barking' in risk_factors or len(risk_factors) >= 2:
+            risk_level = 'MODERATE'
+        elif len(risk_factors) >= 1:
+            risk_level = 'LOW'
+        else:
+            risk_level = 'NONE'
+
+        return {
+            'risk_level': risk_level,
+            'risk_factors': risk_factors
+        }
+
+    def analyze_child_safety_risk(self, breed_info: Dict, noise_info: Dict) -> Dict:
+        """
+        分析品種對幼童的安全風險
+
+        只標記「真正的安全風險」：
+        - 牧羊本能（nipping 風險）
+        - 高獵物驅動 + 大體型（追逐風險）
+        - Good with Children = No 且有其他風險因素
+
+        不標記：
+        - 只是體型大但性格溫和
+        - 活力高但無追逐/牧羊本能
+        """
+        temperament = breed_info.get('Temperament', '').lower()
+        description = breed_info.get('Description', '').lower()
+        noise_notes = noise_info.get('noise_notes', '').lower()
+        size = breed_info.get('Size', '').lower()
+        good_with_children = breed_info.get('Good with Children', 'Yes')
+        exercise = breed_info.get('Exercise Needs', '').lower()
+
+        risk_factors = []
+
+        # 1. 牧羊本能 - 真正的 nipping 風險
+        has_herding = any(ind in noise_notes or ind in description
+                         for ind in self.HERDING_INDICATORS)
+        if has_herding:
+            risk_factors.append('herding_instinct')
+
+        # 2. 獵物驅動 - 追逐風險
+        has_prey_drive = any(ind in noise_notes or ind in description
+                            for ind in self.PREY_DRIVE_INDICATORS)
+        if has_prey_drive:
+            risk_factors.append('prey_drive')
+
+        # 3. Good with Children = No 是強烈信號
+        if good_with_children == 'No':
+            risk_factors.append('not_child_friendly')
+
+        # 4. 大體型 + 高驅動 + 牧羊/獵物本能的組合才是風險
+        is_large = size in ['large', 'giant']
+        is_very_high_energy = 'very high' in exercise
+
+        if is_large and (has_herding or has_prey_drive) and is_very_high_energy:
+            risk_factors.append('large_high_drive_instinct')
+
+        # 計算風險等級
+        # 只有真正危險的組合才是 HIGH
+        if 'not_child_friendly' in risk_factors and len(risk_factors) >= 2:
+            risk_level = 'HIGH'
+        elif 'large_high_drive_instinct' in risk_factors:
+            risk_level = 'HIGH'
+        elif 'herding_instinct' in risk_factors and is_very_high_energy:
+            # 牧羊本能 + 高能量 = 對兒童的真正風險（nipping + 控制不住）
+            risk_level = 'HIGH'
+        elif 'herding_instinct' in risk_factors or 'prey_drive' in risk_factors:
+            # 單獨的牧羊或獵物本能仍是中等風險
+            risk_level = 'MODERATE'
+        elif 'not_child_friendly' in risk_factors:
+            risk_level = 'MODERATE'
+        elif len(risk_factors) >= 1:
+            risk_level = 'LOW'
+        else:
+            risk_level = 'NONE'
+
+        return {
+            'risk_level': risk_level,
+            'risk_factors': risk_factors
+        }
+
+
+class SmartBreedFilter:
+    """
+    智慧品種過濾器
+
+    整合優先級解析和風險分析，只對真正危害用戶的情況進行干預
+    """
+
+    def __init__(self):
+        self.priority_parser = PriorityParser()
+        self.risk_analyzer = BreedRiskAnalyzer()
+
+    def analyze_user_context(self, user_input: str) -> UserPriorityContext:
+        """分析用戶輸入，提取優先級上下文"""
+        return self.priority_parser.parse(user_input)
+
+    def should_exclude_breed(self, breed_info: Dict, noise_info: Dict,
+                            user_context: UserPriorityContext) -> Tuple[bool, str]:
+        """
+        判斷是否應該排除該品種
+
+        返回: (是否排除, 排除原因)
+        """
+        # 1. 噪音零容忍 + 高噪音風險
+        if user_context.noise_intolerance:
+            noise_risk = self.risk_analyzer.analyze_noise_risk(breed_info, noise_info)
+            if noise_risk['risk_level'] == 'HIGH':
+                return True, f"High noise risk ({', '.join(noise_risk['risk_factors'])}) conflicts with noise intolerance"
+
+        # 2. 有幼童 + 高兒童安全風險
+        if user_context.has_young_children:
+            child_risk = self.risk_analyzer.analyze_child_safety_risk(breed_info, noise_info)
+            if child_risk['risk_level'] == 'HIGH':
+                return True, f"Child safety risk ({', '.join(child_risk['risk_factors'])}) with young children"
+
+        return False, ""
+
+    def calculate_risk_penalty(self, breed_info: Dict, noise_info: Dict,
+                               user_context: UserPriorityContext) -> float:
+        """
+        計算風險懲罰分數
+
+        只對中等風險進行輕微降權，不排除
+        返回: 懲罰係數 (0.0 - 0.3)
+        """
+        penalty = 0.0
+
+        # 噪音相關懲罰（只在用戶關注噪音時）
+        if 'noise' in user_context.priority_dimensions:
+            noise_risk = self.risk_analyzer.analyze_noise_risk(breed_info, noise_info)
+            if noise_risk['risk_level'] == 'MODERATE':
+                penalty += 0.1
+            elif noise_risk['risk_level'] == 'HIGH' and not user_context.noise_intolerance:
+                penalty += 0.15
+
+        # 兒童安全相關懲罰（只在用戶有孩子時）
+        if 'children' in user_context.priority_dimensions or user_context.has_young_children:
+            child_risk = self.risk_analyzer.analyze_child_safety_risk(breed_info, noise_info)
+            if child_risk['risk_level'] == 'MODERATE':
+                penalty += 0.1
+            elif child_risk['risk_level'] == 'HIGH' and not user_context.has_young_children:
+                penalty += 0.15
+
+        return min(penalty, 0.3)  # 最大懲罰 30%
+
+    def filter_and_adjust_recommendations(self, recommendations: List[Dict],
+                                          user_input: str) -> List[Dict]:
+        """
+        過濾並調整推薦結果
+
+        這是主要入口函數，整合所有過濾和��整邏輯
+        """
+        user_context = self.analyze_user_context(user_input)
+
+        filtered_recommendations = []
+
+        for rec in recommendations:
+            breed = rec.get('breed', '')
+
+            # 智能獲取品種資訊：優先從 info 欄位，否則從 rec 本身，最後從資料庫
+            breed_info = rec.get('info')
+            if not breed_info:
+                # 嘗試從 rec 中構建標準化的 breed_info（處理大小寫差異）
+                breed_info = {
+                    'Temperament': rec.get('Temperament', rec.get('temperament', '')),
+                    'Description': rec.get('Description', rec.get('description', '')),
+                    'Size': rec.get('Size', rec.get('size', '')),
+                    'Exercise Needs': rec.get('Exercise Needs', rec.get('exercise_needs', '')),
+                    'Good with Children': rec.get('Good with Children', rec.get('good_with_children', 'Yes')),
+                    'Care Level': rec.get('Care Level', rec.get('care_level', '')),
+                }
+                # 如果關鍵資訊缺失，從資料庫獲取
+                if not breed_info['Temperament'] and not breed_info['Description']:
+                    from dog_database import get_dog_description
+                    db_info = get_dog_description(breed.replace(' ', '_'))
+                    if db_info:
+                        breed_info = db_info
+
+            # 獲取噪音資訊（嘗試兩種品種名稱格式）
+            noise_info = breed_noise_info.get(breed) or breed_noise_info.get(breed.replace(' ', '_'), {
+                'noise_notes': '',
+                'noise_level': 'Moderate'
+            })
+
+            # 檢查是否應該排除
+            should_exclude, reason = self.should_exclude_breed(
+                breed_info, noise_info, user_context
+            )
+
+            if should_exclude:
+                print(f"  [SmartFilter] Excluded {breed}: {reason}")
+                continue
+
+            # 計算風險懲罰
+            penalty = self.calculate_risk_penalty(breed_info, noise_info, user_context)
+
+            if penalty > 0:
+                original_score = rec.get('final_score', rec.get('overall_score', 0.8))
+                adjusted_score = original_score * (1 - penalty)
+                rec['final_score'] = adjusted_score
+                rec['risk_penalty'] = penalty
+
+            filtered_recommendations.append(rec)
+
+        # 重新排序
+        filtered_recommendations.sort(key=lambda x: -x.get('final_score', 0))
+
+        # 更新排名
+        for i, rec in enumerate(filtered_recommendations):
+            rec['rank'] = i + 1
+
+        return filtered_recommendations
+
+
+# 模組級便捷函數
+_smart_filter = None
+
+def get_smart_filter() -> SmartBreedFilter:
+    """獲取單例過濾器"""
+    global _smart_filter
+    if _smart_filter is None:
+        _smart_filter = SmartBreedFilter()
+    return _smart_filter
+
+def apply_smart_filtering(recommendations: List[Dict], user_input: str) -> List[Dict]:
+    """便捷函數：應用智慧過濾"""
+    return get_smart_filter().filter_and_adjust_recommendations(recommendations, user_input)

user_query_analyzer.py

@@ -4,7 +4,7 @@ import numpy as np
 import sqlite3
 import re
 import traceback
-from typing import List, Dict, Tuple, Optional, Any
+from typing import List, Dict, Tuple, Optional, Any, Set
 from dataclasses import dataclass
 from sentence_transformers import SentenceTransformer
 import torch
@@ -18,6 +18,8 @@ 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
+from priority_detector import PriorityDetector, PriorityDetectionResult
+from inference_engine import BreedRecommendationInferenceEngine, InferenceResult
 
 class UserQueryAnalyzer:
     """
@@ -28,6 +30,8 @@ class UserQueryAnalyzer:
     def __init__(self, breed_list: List[str]):
         """初始化用戶查詢分析器"""
         self.breed_list = breed_list
+        self.priority_detector = PriorityDetector()
+        self.inference_engine = BreedRecommendationInferenceEngine()
         self.comparative_keywords = {
             'most': 1.0, 'love': 1.0, 'prefer': 0.9, 'like': 0.8,
             'then': 0.7, 'second': 0.7, 'followed': 0.6,
@@ -82,6 +86,34 @@ class UserQueryAnalyzer:
 
         return breed_scores
 
+    def _merge_priorities(self,
+                         explicit_priorities: Dict[str, float],
+                         implicit_priorities: Dict[str, float]) -> Dict[str, float]:
+        """
+        合併顯式和隱式優先級
+
+        規則:
+        1. 明確提及的維度，使用明確優先級
+        2. 未明確提及但推斷出的維度，使用隱含優先級
+        3. 隱含優先級不會覆蓋明確優先級
+
+        Args:
+            explicit_priorities: 明確優先級
+            implicit_priorities: 隱含優先級
+
+        Returns:
+            Dict[str, float]: 合併後的優先級
+        """
+        merged = explicit_priorities.copy()
+
+        for dim, implicit_score in implicit_priorities.items():
+            if dim not in merged:
+                # 只添加未明確提及的隱含優先級
+                merged[dim] = implicit_score
+            # 如果已有明確優先級，保持不變
+
+        return merged
+
     def extract_lifestyle_keywords(self, user_input: str) -> Dict[str, List[str]]:
         """增強的生活方式關鍵字提取，具有更好的模式匹配"""
         keywords = {
@@ -432,6 +464,35 @@ class UserQueryAnalyzer:
             'experience_level': 'beginner' if any(word in text for word in ['first time', 'beginner', '新手']) else 'intermediate'
         }
 
+        # 優先級檢測與推理
+        try:
+            # Step 1: 檢測明確優先級
+            priority_result = self.priority_detector.detect_priorities(user_description)
+            explicit_priorities = priority_result.dimension_priorities
+
+            # Step 2: 推斷隱含優先級
+            inference_result = self.inference_engine.infer_implicit_priorities(
+                user_description,
+                analysis['user_context']
+            )
+            implicit_priorities = inference_result.implicit_priorities
+
+            # Step 3: 合併優先級（明確優先級 > 隱含優先級）
+            final_priorities = self._merge_priorities(explicit_priorities, implicit_priorities)
+
+            # 添加到分析結果
+            analysis['dimension_priorities'] = final_priorities
+            analysis['explicit_priorities'] = explicit_priorities
+            analysis['implicit_priorities'] = implicit_priorities
+            analysis['priority_detection_confidence'] = priority_result.detection_confidence
+            analysis['inference_confidence'] = inference_result.confidence
+
+        except Exception as e:
+            print(f"Error in priority detection/inference: {str(e)}")
+            analysis['dimension_priorities'] = {}
+            analysis['explicit_priorities'] = {}
+            analysis['implicit_priorities'] = {}
+
         return analysis
 
     def create_user_preferences_from_analysis_enhanced(self, analysis: Dict[str, Any]) -> 'UserPreferences':