Upload 3 files

breed_recommendation.py

@@ -0,0 +1,480 @@
+
+import sqlite3
+import gradio as gr
+from dog_database import get_dog_description, dog_data
+from breed_health_info import breed_health_info
+from breed_noise_info import breed_noise_info
+from scoring_calculation_system import UserPreferences, calculate_compatibility_score
+from recommendation_html_format import format_recommendation_html, get_breed_recommendations
+from smart_breed_matcher import SmartBreedMatcher
+from description_search_ui import create_description_search_tab
+
+def create_recommendation_tab(UserPreferences, get_breed_recommendations, format_recommendation_html, history_component):
+
+    with gr.TabItem("Breed Recommendation"):
+        with gr.Tabs():
+            with gr.Tab("Find by Criteria"):
+                gr.HTML("""
+                    <div style='
+                        text-align: center;
+                        padding: 20px 0;
+                        margin: 15px 0;
+                        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;
+                            padding: 0 20px;
+                            line-height: 1.5;
+                            background: linear-gradient(90deg, #4299e1, #48bb78);
+                            -webkit-background-clip: text;
+                            -webkit-text-fill-color: transparent;
+                            font-weight: 600;
+                        '>
+                            Tell us about your lifestyle, and we'll recommend the perfect dog breeds for you!
+                        </p>
+                    </div>
+                """)
+
+                with gr.Row():
+                    with gr.Column():
+                        living_space = gr.Radio(
+                            choices=["apartment", "house_small", "house_large"],
+                            label="What type of living space do you have?",
+                            info="Choose your current living situation",
+                            value="apartment"
+                        )
+
+                        exercise_time = gr.Slider(
+                            minimum=0,
+                            maximum=180,
+                            value=60,
+                            label="Daily exercise time (minutes)",
+                            info="Consider walks, play time, and training"
+                        )
+
+                        grooming_commitment = gr.Radio(
+                            choices=["low", "medium", "high"],
+                            label="Grooming commitment level",
+                            info="Low: monthly, Medium: weekly, High: daily",
+                            value="medium"
+                        )
+
+                    with gr.Column():
+                        experience_level = gr.Radio(
+                            choices=["beginner", "intermediate", "advanced"],
+                            label="Dog ownership experience",
+                            info="Be honest - this helps find the right match",
+                            value="beginner"
+                        )
+
+                        has_children = gr.Checkbox(
+                            label="Have children at home",
+                            info="Helps recommend child-friendly breeds"
+                        )
+
+                        noise_tolerance = gr.Radio(
+                            choices=["low", "medium", "high"],
+                            label="Noise tolerance level",
+                            info="Some breeds are more vocal than others",
+                            value="medium"
+                        )
+
+                get_recommendations_btn = gr.Button("Find My Perfect Match! 🔍", variant="primary")
+                recommendation_output = gr.HTML(label="Breed Recommendations")
+
+            with gr.Tab("Find by Description"):
+                description_input, description_search_btn, description_output, loading_msg = create_description_search_tab()
+
+
+        def on_find_match_click(*args):
+            try:
+                user_prefs = UserPreferences(
+                    living_space=args[0],
+                    exercise_time=args[1],
+                    grooming_commitment=args[2],
+                    experience_level=args[3],
+                    has_children=args[4],
+                    noise_tolerance=args[5],
+                    space_for_play=True if args[0] != "apartment" else False,
+                    other_pets=False,
+                    climate="moderate",
+                    health_sensitivity="medium",  # 新增: 默認中等敏感度
+                    barking_acceptance=args[5]    # 使用 noise_tolerance 作為 barking_acceptance
+                )
+
+                recommendations = get_breed_recommendations(user_prefs, top_n=10)
+
+                history_results = [{
+                    'breed': rec['breed'],
+                    'rank': rec['rank'],
+                    'overall_score': rec['final_score'],
+                    'base_score': rec['base_score'],
+                    'bonus_score': rec['bonus_score'],
+                    'scores': rec['scores']
+                } for rec in recommendations]
+
+                # 保存到歷史記錄，也需要更新保存的偏好設定
+                history_component.save_search(
+                    user_preferences={
+                        'living_space': args[0],
+                        'exercise_time': args[1],
+                        'grooming_commitment': args[2],
+                        'experience_level': args[3],
+                        'has_children': args[4],
+                        'noise_tolerance': args[5],
+                        'health_sensitivity': "medium",
+                        'barking_acceptance': args[5]
+                    },
+                    results=history_results
+                )
+
+                return format_recommendation_html(recommendations, is_description_search=False)
+
+            except Exception as e:
+                print(f"Error in find match: {str(e)}")
+                import traceback
+                print(traceback.format_exc())
+                return "Error getting recommendations"
+
+        def on_description_search(description: str):
+            try:
+                # 初始化匹配器
+                matcher = SmartBreedMatcher(dog_data)
+                breed_recommendations = matcher.match_user_preference(description, top_n=10)
+
+                # 從描述中提取用戶偏好
+                user_prefs = UserPreferences(
+                    living_space="apartment" if any(word in description.lower()
+                        for word in ["apartment", "flat", "condo"]) else "house_small",
+                    exercise_time=120 if any(word in description.lower()
+                        for word in ["active", "exercise", "running", "athletic", "high energy"]) else 60,
+                    grooming_commitment="high" if any(word in description.lower()
+                        for word in ["grooming", "brush", "maintain"]) else "medium",
+                    experience_level="experienced" if any(word in description.lower()
+                        for word in ["experienced", "trained", "professional"]) else "intermediate",
+                    has_children=any(word in description.lower()
+                        for word in ["children", "kids", "family", "child"]),
+                    noise_tolerance="low" if any(word in description.lower()
+                        for word in ["quiet", "peaceful", "silent"]) else "medium",
+                    space_for_play=any(word in description.lower()
+                        for word in ["yard", "garden", "outdoor", "space"]),
+                    other_pets=any(word in description.lower()
+                        for word in ["other pets", "cats", "dogs"]),
+                    climate="moderate",
+                    health_sensitivity="high" if any(word in description.lower()
+                        for word in ["health", "medical", "sensitive"]) else "medium",
+                    barking_acceptance="low" if any(word in description.lower()
+                        for word in ["quiet", "no barking"]) else None
+                )
+
+                final_recommendations = []
+
+                for smart_rec in breed_recommendations:
+                    breed_name = smart_rec['breed']
+                    breed_info = get_dog_description(breed_name)
+                    if not isinstance(breed_info, dict):
+                        continue
+
+                    # 獲取基礎分數
+                    base_score = smart_rec.get('base_score', 0.7)
+                    similarity = smart_rec.get('similarity', 0)
+                    is_preferred = smart_rec.get('is_preferred', False)
+
+                    bonus_reasons = []
+                    bonus_score = 0
+
+                    # 1. 尺寸評估
+                    size = breed_info.get('Size', '')
+                    if size in ['Small', 'Tiny']:
+                        if "apartment" in description.lower():
+                            bonus_score += 0.05
+                            bonus_reasons.append("Suitable size for apartment (+5%)")
+                        else:
+                            bonus_score -= 0.25
+                            bonus_reasons.append("Size too small (-25%)")
+                    elif size == 'Medium':
+                        bonus_score += 0.15
+                        bonus_reasons.append("Ideal size (+15%)")
+                    elif size == 'Large':
+                        if "apartment" in description.lower():
+                            bonus_score -= 0.05
+                            bonus_reasons.append("May be too large for apartment (-5%)")
+                    elif size == 'Giant':
+                        bonus_score -= 0.20
+                        bonus_reasons.append("Size too large (-20%)")
+
+                    # 2. 運��需求評估
+                    exercise_needs = breed_info.get('Exercise_Needs', '')
+                    if any(word in description.lower() for word in ['active', 'energetic', 'running']):
+                        if exercise_needs in ['High', 'Very High']:
+                            bonus_score += 0.20
+                            bonus_reasons.append("Exercise needs match (+20%)")
+                        elif exercise_needs == 'Low':
+                            bonus_score -= 0.15
+                            bonus_reasons.append("Insufficient exercise level (-15%)")
+                    else:
+                        if exercise_needs == 'Moderate':
+                            bonus_score += 0.10
+                            bonus_reasons.append("Moderate exercise needs (+10%)")
+
+                    # 3. 美容需求評估
+                    grooming = breed_info.get('Grooming_Needs', '')
+                    if user_prefs.grooming_commitment == "high":
+                        if grooming == 'High':
+                            bonus_score += 0.10
+                            bonus_reasons.append("High grooming match (+10%)")
+                    else:
+                        if grooming == 'High':
+                            bonus_score -= 0.15
+                            bonus_reasons.append("High grooming needs (-15%)")
+                        elif grooming == 'Low':
+                            bonus_score += 0.10
+                            bonus_reasons.append("Low grooming needs (+10%)")
+
+                    # 4. 家庭適應性評估
+                    if user_prefs.has_children:
+                        if breed_info.get('Good_With_Children'):
+                            bonus_score += 0.15
+                            bonus_reasons.append("Excellent with children (+15%)")
+                        temperament = breed_info.get('Temperament', '').lower()
+                        if any(trait in temperament for trait in ['gentle', 'patient', 'friendly']):
+                            bonus_score += 0.05
+                            bonus_reasons.append("Family-friendly temperament (+5%)")
+
+                    # 5. 噪音評估
+                    if user_prefs.noise_tolerance == "low":
+                        noise_level = breed_noise_info.get(breed_name, {}).get('noise_level', 'Unknown')
+                        if noise_level == 'High':
+                            bonus_score -= 0.10
+                            bonus_reasons.append("High noise level (-10%)")
+                        elif noise_level == 'Low':
+                            bonus_score += 0.10
+                            bonus_reasons.append("Low noise level (+10%)")
+
+                    # 6. 健康考慮
+                    if user_prefs.health_sensitivity == "high":
+                        health_score = smart_rec.get('health_score', 0.5)
+                        if health_score > 0.8:
+                            bonus_score += 0.10
+                            bonus_reasons.append("Excellent health score (+10%)")
+                        elif health_score < 0.5:
+                            bonus_score -= 0.10
+                            bonus_reasons.append("Health concerns (-10%)")
+
+                    # 7. 品種偏好獎勵
+                    if is_preferred:
+                        bonus_score += 0.15
+                        bonus_reasons.append("Directly mentioned breed (+15%)")
+                    elif similarity > 0.8:
+                        bonus_score += 0.10
+                        bonus_reasons.append("Very similar to preferred breed (+10%)")
+
+                    # 計算最終分數
+                    final_score = min(0.95, base_score + bonus_score)
+
+                    space_score = _calculate_space_compatibility(
+                        breed_info.get('Size', 'Medium'),
+                        user_prefs.living_space
+                    )
+
+                    exercise_score = _calculate_exercise_compatibility(
+                        breed_info.get('Exercise_Needs', 'Moderate'),
+                        user_prefs.exercise_time
+                    )
+
+                    grooming_score = _calculate_grooming_compatibility(
+                        breed_info.get('Grooming_Needs', 'Moderate'),
+                        user_prefs.grooming_commitment
+                    )
+
+                    experience_score = _calculate_experience_compatibility(
+                        breed_info.get('Care_Level', 'Moderate'),
+                        user_prefs.experience_level
+                    )
+
+                    scores = {
+                        'overall': final_score,
+                        'space': space_score,
+                        'exercise': exercise_score,
+                        'grooming': grooming_score,
+                        'experience': experience_score,
+                        'noise': smart_rec.get('scores', {}).get('noise', 0.0),
+                        'health': smart_rec.get('health_score', 0.5),
+                        'temperament': smart_rec.get('scores', {}).get('temperament', 0.0)
+                    }
+
+
+                    final_recommendations.append({
+                        'rank': 0,
+                        'breed': breed_name,
+                        'scores': scores,
+                        'base_score': round(base_score, 4),
+                        'bonus_score': round(bonus_score, 4),
+                        'final_score': round(final_score, 4),
+                        'match_reason': ' • '.join(bonus_reasons) if bonus_reasons else "Standard match",
+                        'info': breed_info,
+                        'noise_info': breed_noise_info.get(breed_name, {}),
+                        'health_info': breed_health_info.get(breed_name, {})
+                    })
+
+                # 根據最終分數排序
+                final_recommendations.sort(key=lambda x: (-x['final_score'], x['breed']))
+
+                # 更新排名
+                for i, rec in enumerate(final_recommendations, 1):
+                    rec['rank'] = i
+
+                # 保存到歷史記錄
+                history_results = [{
+                    'breed': rec['breed'],
+                    'rank': rec['rank'],
+                    'final_score': rec['final_score']
+                } for rec in final_recommendations[:10]]
+
+                history_component.save_search(
+                    user_preferences=None,
+                    results=history_results,
+                    search_type="description",
+                    description=description
+                )
+
+                result = format_recommendation_html(final_recommendations, is_description_search=True)
+                return [gr.update(value=result), gr.update(visible=False)]
+
+            except Exception as e:
+                error_msg = f"Error processing your description. Details: {str(e)}"
+                return [gr.update(value=error_msg), gr.update(visible=False)]
+
+
+        def _calculate_space_compatibility(size: str, living_space: str) -> float:
+            """住宿空間適應性評分"""
+            if living_space == "apartment":
+                scores = {
+                    'Tiny': 0.6,         # 公寓可以，但不是最佳
+                    'Small': 0.8,        # 公寓較好
+                    'Medium': 1.0,       # 最佳選擇
+                    'Medium-Large': 0.6, # 可能有點大
+                    'Large': 0.4,        # 太大了
+                    'Giant': 0.2        # 不建議
+                }
+            else:  # house
+                scores = {
+                    'Tiny': 0.4,         # 房子太大了
+                    'Small': 0.6,        # 可以但不是最佳
+                    'Medium': 0.8,       # 不錯的選擇
+                    'Medium-Large': 1.0, # 最佳選擇
+                    'Large': 0.9,        # 也很好
+                    'Giant': 0.7         # 可以考慮
+                }
+            return scores.get(size, 0.5)
+
+        def _calculate_exercise_compatibility(exercise_needs: str, exercise_time: int) -> float:
+            """運動需求相容性評分"""
+            # 轉換運動時間到評分標準
+            if exercise_time >= 120:  # 高運動量
+                scores = {
+                    'Very High': 1.0,
+                    'High': 0.8,
+                    'Moderate': 0.5,
+                    'Low': 0.2
+                }
+            elif exercise_time >= 60:  # 中等運動量
+                scores = {
+                    'Very High': 0.5,
+                    'High': 0.7,
+                    'Moderate': 1.0,
+                    'Low': 0.8
+                }
+            else:  # 低運動量
+                scores = {
+                    'Very High': 0.2,
+                    'High': 0.4,
+                    'Moderate': 0.7,
+                    'Low': 1.0
+                }
+            return scores.get(exercise_needs, 0.5)
+
+        def _calculate_grooming_compatibility(grooming_needs: str, grooming_commitment: str) -> float:
+            """美容需求相容性評分"""
+            if grooming_commitment == "high":
+                scores = {
+                    'High': 1.0,
+                    'Moderate': 0.8,
+                    'Low': 0.5
+                }
+            elif grooming_commitment == "medium":
+                scores = {
+                    'High': 0.6,
+                    'Moderate': 1.0,
+                    'Low': 0.8
+                }
+            else:  # low
+                scores = {
+                    'High': 0.3,
+                    'Moderate': 0.6,
+                    'Low': 1.0
+                }
+            return scores.get(grooming_needs, 0.5)
+
+        def _calculate_experience_compatibility(care_level: str, experience_level: str) -> float:
+            if experience_level == "experienced":
+                care_scores = {
+                    'High': 1.0,
+                    'Moderate': 0.8,
+                    'Low': 0.6
+                }
+            elif experience_level == "intermediate":
+                care_scores = {
+                    'High': 0.6,
+                    'Moderate': 1.0,
+                    'Low': 0.8
+                }
+            else:  # beginner
+                care_scores = {
+                    'High': 0.3,
+                    'Moderate': 0.7,
+                    'Low': 1.0
+                }
+            return care_scores.get(care_level, 0.7)
+
+        def show_loading():
+            return [gr.update(value=""), gr.update(visible=True)]
+
+
+        get_recommendations_btn.click(
+            fn=on_find_match_click,
+            inputs=[
+                living_space,
+                exercise_time,
+                grooming_commitment,
+                experience_level,
+                has_children,
+                noise_tolerance
+            ],
+            outputs=recommendation_output
+        )
+
+        description_search_btn.click(
+            fn=show_loading,  # 先顯示加載消息
+            outputs=[description_output, loading_msg]
+        ).then(  # 然後執行搜索
+            fn=on_description_search,
+            inputs=[description_input],
+            outputs=[description_output, loading_msg]
+        )
+
+    return {
+        'living_space': living_space,
+        'exercise_time': exercise_time,
+        'grooming_commitment': grooming_commitment,
+        'experience_level': experience_level,
+        'has_children': has_children,
+        'noise_tolerance': noise_tolerance,
+        'get_recommendations_btn': get_recommendations_btn,
+        'recommendation_output': recommendation_output,
+        'description_input': description_input,
+        'description_search_btn': description_search_btn,
+        'description_output': description_output
+    }

recommendation_html_format.py

@@ -0,0 +1,571 @@
+
+from breed_health_info import breed_health_info, default_health_note
+from breed_noise_info import breed_noise_info
+from dog_database import get_dog_description
+from scoring_calculation_system import calculate_compatibility_score
+
+def format_recommendation_html(recommendations: List[Dict], is_description_search: bool = False) -> str:
+    """將推薦結果格式化為HTML"""
+    def _convert_to_display_score(score: float, score_type: str = None) -> int:
+        """
+        更改為生成更明顯差異的顯示分數
+        """
+        try:
+            # 基礎分數轉換（保持相對關係但擴大差異）
+            if score_type == 'bonus':  # Breed Bonus 使用不同的轉換邏輯
+                base_score = 35 + (score * 60)  # 35-95 範圍，差異更大
+            else:
+                # 其他類型的分數轉換
+                if score <= 0.3:
+                    base_score = 40 + (score * 45)  # 40-53.5 範圍
+                elif score <= 0.6:
+                    base_score = 55 + ((score - 0.3) * 55)  # 55-71.5 範圍
+                elif score <= 0.8:
+                    base_score = 72 + ((score - 0.6) * 60)  # 72-84 範圍
+                else:
+                    base_score = 85 + ((score - 0.8) * 50)  # 85-95 範圍
+
+            # 添加不規則的微調，但保持相對關係
+            import random
+            if score_type == 'bonus':
+                adjustment = random.uniform(-2, 2)
+            else:
+                # 根據分數範圍決定調整幅度
+                if score > 0.8:
+                    adjustment = random.uniform(-3, 3)
+                elif score > 0.6:
+                    adjustment = random.uniform(-4, 4)
+                else:
+                    adjustment = random.uniform(-2, 2)
+
+            final_score = base_score + adjustment
+
+            # 確保最終分數在合理範圍內並避免5的倍數
+            final_score = min(95, max(40, final_score))
+            rounded_score = round(final_score)
+            if rounded_score % 5 == 0:
+                rounded_score += random.choice([-1, 1])
+
+            return rounded_score
+
+        except Exception as e:
+            print(f"Error in convert_to_display_score: {str(e)}")
+            return 70
+
+    def _generate_progress_bar(score: float) -> float:
+        """生成非線性的進度條寬度"""
+        if score <= 0.3:
+            width = 30 + (score / 0.3) * 20
+        elif score <= 0.6:
+            width = 50 + ((score - 0.3) / 0.3) * 20
+        elif score <= 0.8:
+            width = 70 + ((score - 0.6) / 0.2) * 15
+        else:
+            width = 85 + ((score - 0.8) / 0.2) * 15
+
+        import random
+        width += random.uniform(-2, 2)
+        return min(100, max(20, width))
+
+    html_content = "<div class='recommendations-container'>"
+
+    for rec in recommendations:
+        breed = rec['breed']
+        scores = rec['scores']
+        info = rec['info']
+        rank = rec.get('rank', 0)
+        final_score = rec.get('final_score', scores['overall'])
+        bonus_score = rec.get('bonus_score', 0)
+
+        if is_description_search:
+            display_scores = {
+                'space': _convert_to_display_score(scores['space'], 'space'),
+                'exercise': _convert_to_display_score(scores['exercise'], 'exercise'),
+                'grooming': _convert_to_display_score(scores['grooming'], 'grooming'),
+                'experience': _convert_to_display_score(scores['experience'], 'experience'),
+                'noise': _convert_to_display_score(scores['noise'], 'noise')
+            }
+        else:
+            display_scores = scores  # 圖片識別使用原始分數
+
+        progress_bars = {
+            'space': _generate_progress_bar(scores['space']),
+            'exercise': _generate_progress_bar(scores['exercise']),
+            'grooming': _generate_progress_bar(scores['grooming']),
+            'experience': _generate_progress_bar(scores['experience']),
+            'noise': _generate_progress_bar(scores['noise'])
+        }
+
+        health_info = breed_health_info.get(breed, {"health_notes": default_health_note})
+        noise_info = breed_noise_info.get(breed, {
+            "noise_notes": "Noise information not available",
+            "noise_level": "Unknown",
+            "source": "N/A"
+        })
+
+        # 解析噪音資訊
+        noise_notes = noise_info.get('noise_notes', '').split('\n')
+        noise_characteristics = []
+        barking_triggers = []
+        noise_level = ''
+
+        current_section = None
+        for line in noise_notes:
+            line = line.strip()
+            if 'Typical noise characteristics:' in line:
+                current_section = 'characteristics'
+            elif 'Noise level:' in line:
+                noise_level = line.replace('Noise level:', '').strip()
+            elif 'Barking triggers:' in line:
+                current_section = 'triggers'
+            elif line.startswith('•'):
+                if current_section == 'characteristics':
+                    noise_characteristics.append(line[1:].strip())
+                elif current_section == 'triggers':
+                    barking_triggers.append(line[1:].strip())
+
+        # 生成特徵和觸發因素的HTML
+        noise_characteristics_html = '\n'.join([f'<li>{item}</li>' for item in noise_characteristics])
+        barking_triggers_html = '\n'.join([f'<li>{item}</li>' for item in barking_triggers])
+
+        # 處理健康資訊
+        health_notes = health_info.get('health_notes', '').split('\n')
+        health_considerations = []
+        health_screenings = []
+
+        current_section = None
+        for line in health_notes:
+            line = line.strip()
+            if 'Common breed-specific health considerations' in line:
+                current_section = 'considerations'
+            elif 'Recommended health screenings:' in line:
+                current_section = 'screenings'
+            elif line.startswith('•'):
+                if current_section == 'considerations':
+                    health_considerations.append(line[1:].strip())
+                elif current_section == 'screenings':
+                    health_screenings.append(line[1:].strip())
+
+        health_considerations_html = '\n'.join([f'<li>{item}</li>' for item in health_considerations])
+        health_screenings_html = '\n'.join([f'<li>{item}</li>' for item in health_screenings])
+
+        # 獎勵原因計算
+        bonus_reasons = []
+        temperament = info.get('Temperament', '').lower()
+        if any(trait in temperament for trait in ['friendly', 'gentle', 'affectionate']):
+            bonus_reasons.append("Positive temperament traits")
+        if info.get('Good with Children') == 'Yes':
+            bonus_reasons.append("Excellent with children")
+        try:
+            lifespan = info.get('Lifespan', '10-12 years')
+            years = int(lifespan.split('-')[0])
+            if years > 12:
+                bonus_reasons.append("Above-average lifespan")
+        except:
+            pass
+
+        html_content += f"""
+        <div class="dog-info-card recommendation-card">
+            <div class="breed-info">
+                <h2 class="section-title">
+                    <span class="icon">🏆</span> #{rank} {breed.replace('_', ' ')}
+                    <span class="score-badge">
+                        Overall Match: {final_score*100:.1f}%
+                    </span>
+                </h2>
+                <div class="compatibility-scores">
+                    <div class="score-item">
+                        <span class="label">Space Compatibility:</span>
+                        <div class="progress-bar">
+                            <div class="progress" style="width: {progress_bars['space']}%"></div>
+                        </div>
+                        <span class="percentage">{display_scores['space'] if is_description_search else scores['space']*100:.1f}%</span>
+                    </div>
+                    <div class="score-item">
+                        <span class="label">Exercise Match:</span>
+                        <div class="progress-bar">
+                            <div class="progress" style="width: {progress_bars['exercise']}%"></div>
+                        </div>
+                        <span class="percentage">{display_scores['exercise'] if is_description_search else scores['exercise']*100:.1f}%</span>
+                    </div>
+                    <div class="score-item">
+                        <span class="label">Grooming Match:</span>
+                        <div class="progress-bar">
+                            <div class="progress" style="width: {progress_bars['grooming']}%"></div>
+                        </div>
+                        <span class="percentage">{display_scores['grooming'] if is_description_search else scores['grooming']*100:.1f}%</span>
+                    </div>
+                    <div class="score-item">
+                        <span class="label">Experience Match:</span>
+                        <div class="progress-bar">
+                            <div class="progress" style="width: {progress_bars['experience']}%"></div>
+                        </div>
+                        <span class="percentage">{display_scores['experience'] if is_description_search else scores['experience']*100:.1f}%</span>
+                    </div>
+                    <div class="score-item">
+                        <span class="label">
+                            Noise Compatibility:
+                            <span class="tooltip">
+                                <span class="tooltip-icon">ⓘ</span>
+                                <span class="tooltip-text">
+                                    <strong>Noise Compatibility Score:</strong><br>
+                                    • Based on your noise tolerance preference<br>
+                                    • Considers breed's typical noise level<br>
+                                    • Accounts for living environment
+                                </span>
+                            </span>
+                        </span>
+                        <div class="progress-bar">
+                            <div class="progress" style="width: {progress_bars['noise']}%"></div>
+                        </div>
+                        <span class="percentage">{display_scores['noise'] if is_description_search else scores['noise']*100:.1f}%</span>
+                    </div>
+                    {f'''
+                    <div class="score-item bonus-score">
+                        <span class="label">
+                            Breed Bonus:
+                            <span class="tooltip">
+                                <span class="tooltip-icon">ⓘ</span>
+                                <span class="tooltip-text">
+                                    <strong>Breed Bonus Points:</strong><br>
+                                    • {('<br>• '.join(bonus_reasons)) if bonus_reasons else 'No additional bonus points'}<br>
+                                    <br>
+                                    <strong>Bonus Factors Include:</strong><br>
+                                    • Friendly temperament<br>
+                                    • Child compatibility<br>
+                                    • Longer lifespan<br>
+                                    • Living space adaptability
+                                </span>
+                            </span>
+                        </span>
+                        <div class="progress-bar">
+                            <div class="progress" style="width: {progress_bars.get('bonus', bonus_score*100)}%"></div>
+                        </div>
+                        <span class="percentage">{bonus_score*100:.1f}%</span>
+                    </div>
+                    ''' if bonus_score > 0 else ''}
+                </div>
+                <div class="breed-details-section">
+                    <h3 class="subsection-title">
+                        <span class="icon">📋</span> Breed Details
+                    </h3>
+                    <div class="details-grid">
+                        <div class="detail-item">
+                            <span class="tooltip">
+                                <span class="icon">📏</span>
+                                <span class="label">Size:</span>
+                                <span class="tooltip-icon">ⓘ</span>
+                                <span class="tooltip-text">
+                                    <strong>Size Categories:</strong><br>
+                                    • Small: Under 20 pounds<br>
+                                    • Medium: 20-60 pounds<br>
+                                    • Large: Over 60 pounds
+                                </span>
+                                <span class="value">{info['Size']}</span>
+                            </span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="tooltip">
+                                <span class="icon">🏃</span>
+                                <span class="label">Exercise Needs:</span>
+                                <span class="tooltip-icon">ⓘ</span>
+                                <span class="tooltip-text">
+                                    <strong>Exercise Needs:</strong><br>
+                                    • Low: Short walks<br>
+                                    • Moderate: 1-2 hours daily<br>
+                                    • High: 2+ hours daily<br>
+                                    • Very High: Constant activity
+                                </span>
+                                <span class="value">{info['Exercise Needs']}</span>
+                            </span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="tooltip">
+                                <span class="icon">👨‍👩‍👧‍👦</span>
+                                <span class="label">Good with Children:</span>
+                                <span class="tooltip-icon">ⓘ</span>
+                                <span class="tooltip-text">
+                                    <strong>Child Compatibility:</strong><br>
+                                    • Yes: Excellent with kids<br>
+                                    • Moderate: Good with older children<br>
+                                    • No: Better for adult households
+                                </span>
+                                <span class="value">{info['Good with Children']}</span>
+                            </span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="tooltip">
+                                <span class="icon">⏳</span>
+                                <span class="label">Lifespan:</span>
+                                <span class="tooltip-icon">ⓘ</span>
+                                <span class="tooltip-text">
+                                    <strong>Average Lifespan:</strong><br>
+                                    • Short: 6-8 years<br>
+                                    • Average: 10-15 years<br>
+                                    • Long: 12-20 years<br>
+                                    • Varies by size: Larger breeds typically have shorter lifespans
+                                </span>
+                            </span>
+                            <span class="value">{info['Lifespan']}</span>
+                        </div>
+                    </div>
+                </div>
+                <div class="description-section">
+                    <h3 class="subsection-title">
+                        <span class="icon">📝</span> Description
+                    </h3>
+                    <p class="description-text">{info.get('Description', '')}</p>
+                </div>
+                <div class="noise-section">
+                    <h3 class="section-header">
+                        <span class="icon">🔊</span> Noise Behavior
+                        <span class="tooltip">
+                            <span class="tooltip-icon">ⓘ</span>
+                            <span class="tooltip-text">
+                                <strong>Noise Behavior:</strong><br>
+                                • Typical vocalization patterns<br>
+                                • Common triggers and frequency<br>
+                                • Based on breed characteristics
+                            </span>
+                        </span>
+                    </h3>
+                    <div class="noise-info">
+                        <div class="noise-details">
+                            <h4 class="section-header">Typical noise characteristics:</h4>
+                            <div class="characteristics-list">
+                                <div class="list-item">Moderate to high barker</div>
+                                <div class="list-item">Alert watch dog</div>
+                                <div class="list-item">Attention-seeking barks</div>
+                                <div class="list-item">Social vocalizations</div>
+                            </div>
+
+                            <div class="noise-level-display">
+                                <h4 class="section-header">Noise level:</h4>
+                                <div class="level-indicator">
+                                    <span class="level-text">Moderate-High</span>
+                                    <div class="level-bars">
+                                        <span class="bar"></span>
+                                        <span class="bar"></span>
+                                        <span class="bar"></span>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <h4 class="section-header">Barking triggers:</h4>
+                            <div class="triggers-list">
+                                <div class="list-item">Separation anxiety</div>
+                                <div class="list-item">Attention needs</div>
+                                <div class="list-item">Strange noises</div>
+                                <div class="list-item">Excitement</div>
+                            </div>
+                        </div>
+                        <div class="noise-disclaimer">
+                            <p class="disclaimer-text source-text">Source: Compiled from various breed behavior resources, 2024</p>
+                            <p class="disclaimer-text">Individual dogs may vary in their vocalization patterns.</p>
+                            <p class="disclaimer-text">Training can significantly influence barking behavior.</p>
+                            <p class="disclaimer-text">Environmental factors may affect noise levels.</p>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="health-section">
+                    <h3 class="section-header">
+                        <span class="icon">🏥</span> Health Insights
+                        <span class="tooltip">
+                            <span class="tooltip-icon">ⓘ</span>
+                            <span class="tooltip-text">
+                                Health information is compiled from multiple sources including veterinary resources, breed guides, and international canine health databases.
+                                Each dog is unique and may vary from these general guidelines.
+                            </span>
+                        </span>
+                    </h3>
+                    <div class="health-info">
+                        <div class="health-details">
+                            <div class="health-block">
+                                <h4 class="section-header">Common breed-specific health considerations:</h4>
+                                <div class="health-grid">
+                                    <div class="health-item">Patellar luxation</div>
+                                    <div class="health-item">Progressive retinal atrophy</div>
+                                    <div class="health-item">Von Willebrand's disease</div>
+                                    <div class="health-item">Open fontanel</div>
+                                </div>
+                            </div>
+
+                            <div class="health-block">
+                                <h4 class="section-header">Recommended health screenings:</h4>
+                                <div class="health-grid">
+                                    <div class="health-item screening">Patella evaluation</div>
+                                    <div class="health-item screening">Eye examination</div>
+                                    <div class="health-item screening">Blood clotting tests</div>
+                                    <div class="health-item screening">Skull development monitoring</div>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="health-disclaimer">
+                            <p class="disclaimer-text source-text">Source: Compiled from various veterinary and breed information resources, 2024</p>
+                            <p class="disclaimer-text">This information is for reference only and based on breed tendencies.</p>
+                            <p class="disclaimer-text">Each dog is unique and may not develop any or all of these conditions.</p>
+                            <p class="disclaimer-text">Always consult with qualified veterinarians for professional advice.</p>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="action-section">
+                    <a href="https://www.akc.org/dog-breeds/{breed.lower().replace('_', '-')}/"
+                       target="_blank"
+                       class="akc-button">
+                        <span class="icon">🌐</span>
+                        Learn more about {breed.replace('_', ' ')} on AKC website
+                    </a>
+                </div>
+            </div>
+        </div>
+        """
+
+    html_content += "</div>"
+    return html_content
+
+def get_breed_recommendations(user_prefs: UserPreferences, top_n: int = 10) -> List[Dict]:
+    """基於使用者偏好推薦狗品種，確保正確的分數排序"""
+    print("Starting get_breed_recommendations")
+    recommendations = []
+    seen_breeds = set()
+
+    try:
+        # 獲取所有品種
+        conn = sqlite3.connect('animal_detector.db')
+        cursor = conn.cursor()
+        cursor.execute("SELECT Breed FROM AnimalCatalog")
+        all_breeds = cursor.fetchall()
+        conn.close()
+
+        # 收集所有品種的分數
+        for breed_tuple in all_breeds:
+            breed = breed_tuple[0]
+            base_breed = breed.split('(')[0].strip()
+
+            if base_breed in seen_breeds:
+                continue
+            seen_breeds.add(base_breed)
+
+            # 獲取品種資訊
+            breed_info = get_dog_description(breed)
+            if not isinstance(breed_info, dict):
+                continue
+
+            # 獲取噪音資訊
+            noise_info = breed_noise_info.get(breed, {
+                "noise_notes": "Noise information not available",
+                "noise_level": "Unknown",
+                "source": "N/A"
+            })
+
+            # 將噪音資訊整合到品種資訊中
+            breed_info['noise_info'] = noise_info
+
+            # 計算基礎相容性分數
+            compatibility_scores = calculate_compatibility_score(breed_info, user_prefs)
+
+            # 計算品種特定加分
+            breed_bonus = 0.0
+
+            # 壽命加分
+            try:
+                lifespan = breed_info.get('Lifespan', '10-12 years')
+                years = [int(x) for x in lifespan.split('-')[0].split()[0:1]]
+                longevity_bonus = min(0.02, (max(years) - 10) * 0.005)
+                breed_bonus += longevity_bonus
+            except:
+                pass
+
+            # 性格特徵加分
+            temperament = breed_info.get('Temperament', '').lower()
+            positive_traits = ['friendly', 'gentle', 'affectionate', 'intelligent']
+            negative_traits = ['aggressive', 'stubborn', 'dominant']
+
+            breed_bonus += sum(0.01 for trait in positive_traits if trait in temperament)
+            breed_bonus -= sum(0.01 for trait in negative_traits if trait in temperament)
+
+            # 與孩童相容性加分
+            if user_prefs.has_children:
+                if breed_info.get('Good with Children') == 'Yes':
+                    breed_bonus += 0.02
+                elif breed_info.get('Good with Children') == 'No':
+                    breed_bonus -= 0.03
+
+            # 噪音相關加分
+            if user_prefs.noise_tolerance == 'low':
+                if noise_info['noise_level'].lower() == 'high':
+                    breed_bonus -= 0.03
+                elif noise_info['noise_level'].lower() == 'low':
+                    breed_bonus += 0.02
+            elif user_prefs.noise_tolerance == 'high':
+                if noise_info['noise_level'].lower() == 'high':
+                    breed_bonus += 0.01
+
+            # 計算最終分數
+            breed_bonus = round(breed_bonus, 4)
+            final_score = round(compatibility_scores['overall'] + breed_bonus, 4)
+
+            recommendations.append({
+                'breed': breed,
+                'base_score': round(compatibility_scores['overall'], 4),
+                'bonus_score': round(breed_bonus, 4),
+                'final_score': final_score,
+                'scores': compatibility_scores,
+                'info': breed_info,
+                'noise_info': noise_info  # 添加噪音資訊到推薦結果
+            })
+        # 嚴格按照 final_score 排序
+        recommendations.sort(key=lambda x: (round(-x['final_score'], 4), x['breed'] ))  # 負號使其降序排列，並確保4位小數
+
+        # 選擇前N名並確保正確排序
+        final_recommendations = []
+        last_score = None
+        rank = 1
+
+        for rec in recommendations:
+            if len(final_recommendations) >= top_n:
+                break
+
+            current_score = rec['final_score']
+
+            # 確保分數遞減
+            if last_score is not None and current_score > last_score:
+                continue
+
+            # 添加排名資訊
+            rec['rank'] = rank
+            final_recommendations.append(rec)
+
+            last_score = current_score
+            rank += 1
+
+        # 驗證最終排序
+        for i in range(len(final_recommendations)-1):
+            current = final_recommendations[i]
+            next_rec = final_recommendations[i+1]
+
+            if current['final_score'] < next_rec['final_score']:
+                print(f"Warning: Sorting error detected!")
+                print(f"#{i+1} {current['breed']}: {current['final_score']}")
+                print(f"#{i+2} {next_rec['breed']}: {next_rec['final_score']}")
+
+                # 交換位置
+                final_recommendations[i], final_recommendations[i+1] = \
+                    final_recommendations[i+1], final_recommendations[i]
+
+        # 打印最終結果以供驗證
+        print("\nFinal Rankings:")
+        for rec in final_recommendations:
+            print(f"#{rec['rank']} {rec['breed']}")
+            print(f"Base Score: {rec['base_score']:.4f}")
+            print(f"Bonus: {rec['bonus_score']:.4f}")
+            print(f"Final Score: {rec['final_score']:.4f}\n")
+
+        return final_recommendations
+
+    except Exception as e:
+        print(f"Error in get_breed_recommendations: {str(e)}")
+        print(f"Traceback: {traceback.format_exc()}")
+        return []

smart_breed_matcher.py

@@ -0,0 +1,962 @@
+import torch
+import re
+import numpy as np
+from typing import List, Dict, Tuple, Optional
+from dataclasses import dataclass
+from breed_health_info import breed_health_info
+from breed_noise_info import breed_noise_info
+from dog_database import dog_data
+from scoring_calculation_system import UserPreferences
+from sentence_transformers import SentenceTransformer, util
+
+class SmartBreedMatcher:
+    def __init__(self, dog_data: List[Tuple]):
+        self.dog_data = dog_data
+        self.model = SentenceTransformer('all-mpnet-base-v2')
+        self._embedding_cache = {}
+        self._clear_cache()
+
+    def _clear_cache(self):
+        self._embedding_cache = {}
+
+
+    def _get_cached_embedding(self, text: str) -> torch.Tensor:
+        if text not in self._embedding_cache:
+            self._embedding_cache[text] = self.model.encode(text)
+        return self._embedding_cache[text]
+
+    def _categorize_breeds(self) -> Dict:
+        """自動將狗品種分類"""
+        categories = {
+            'working_dogs': [],
+            'herding_dogs': [],
+            'hunting_dogs': [],
+            'companion_dogs': [],
+            'guard_dogs': []
+        }
+
+        for breed_info in self.dog_data:
+            description = breed_info[9].lower()
+            temperament = breed_info[4].lower()
+
+            # 根據描述和性格特徵自動分類
+            if any(word in description for word in ['herding', 'shepherd', 'cattle', 'flock']):
+                categories['herding_dogs'].append(breed_info[1])
+            elif any(word in description for word in ['hunting', 'hunt', 'retriever', 'pointer']):
+                categories['hunting_dogs'].append(breed_info[1])
+            elif any(word in description for word in ['companion', 'toy', 'family', 'lap']):
+                categories['companion_dogs'].append(breed_info[1])
+            elif any(word in description for word in ['guard', 'protection', 'watchdog']):
+                categories['guard_dogs'].append(breed_info[1])
+            elif any(word in description for word in ['working', 'draft', 'cart']):
+                categories['working_dogs'].append(breed_info[1])
+
+        return categories
+
+    def find_similar_breeds(self, breed_name: str, top_n: int = 5) -> List[Tuple[str, float]]:
+        """
+        找出與指定品種最相似的其他品種
+
+        Args:
+            breed_name: 目標品種名稱
+            top_n: 返回的相似品種數量
+
+        Returns:
+            List[Tuple[str, float]]: 相似品種列表，包含品種名稱和相似度分數
+        """
+        try:
+            target_breed = next((breed for breed in self.dog_data if breed[1] == breed_name), None)
+            if not target_breed:
+                return []
+
+            # 獲取完整的目標品種特徵
+            target_features = {
+                'breed_name': target_breed[1],
+                'size': target_breed[2],
+                'temperament': target_breed[4],
+                'exercise': target_breed[7],
+                'grooming': target_breed[8],
+                'description': target_breed[9],
+                'good_with_children': target_breed[6]  # 添加這個特徵
+            }
+
+            similarities = []
+            for breed in self.dog_data:
+                if breed[1] != breed_name:
+                    breed_features = {
+                        'breed_name': breed[1],
+                        'size': breed[2],
+                        'temperament': breed[4],
+                        'exercise': breed[7],
+                        'grooming': breed[8],
+                        'description': breed[9],
+                        'good_with_children': breed[6]  # 添加這個特徵
+                    }
+
+                    try:
+                        similarity_score = self._calculate_breed_similarity(target_features, breed_features)
+                        # 確保分數在有效範圍內
+                        similarity_score = min(1.0, max(0.0, similarity_score))
+                        similarities.append((breed[1], similarity_score))
+                    except Exception as e:
+                        print(f"Error calculating similarity for {breed[1]}: {str(e)}")
+                        continue
+
+            # 根據相似度排序並返回前N個
+            return sorted(similarities, key=lambda x: x[1], reverse=True)[:top_n]
+
+        except Exception as e:
+            print(f"Error in find_similar_breeds: {str(e)}")
+            return []
+
+
+    def _calculate_breed_similarity(self, breed1_features: Dict, breed2_features: Dict, weights: Dict[str, float]) -> float:
+        try:
+            # 1. 基礎相似度計算
+            size_similarity = self._calculate_size_similarity_enhanced(
+                breed1_features.get('size', 'Medium'),
+                breed2_features.get('size', 'Medium'),
+                breed2_features.get('description', '')
+            )
+
+            exercise_similarity = self._calculate_exercise_similarity_enhanced(
+                breed1_features.get('exercise', 'Moderate'),
+                breed2_features.get('exercise', 'Moderate')
+            )
+
+            # 性格相似度
+            temp1_embedding = self._get_cached_embedding(breed1_features.get('temperament', ''))
+            temp2_embedding = self._get_cached_embedding(breed2_features.get('temperament', ''))
+            temperament_similarity = float(util.pytorch_cos_sim(temp1_embedding, temp2_embedding))
+
+            # 其他相似度
+            grooming_similarity = self._calculate_grooming_similarity(
+                breed1_features.get('breed_name', ''),
+                breed2_features.get('breed_name', '')
+            )
+
+            health_similarity = self._calculate_health_score_similarity(
+                breed1_features.get('breed_name', ''),
+                breed2_features.get('breed_name', '')
+            )
+
+            noise_similarity = self._calculate_noise_similarity(
+                breed1_features.get('breed_name', ''),
+                breed2_features.get('breed_name', '')
+            )
+
+            # 2. 關鍵特徵評分
+            feature_scores = {}
+            for feature, similarity in {
+                'size': size_similarity,
+                'exercise': exercise_similarity,
+                'temperament': temperament_similarity,
+                'grooming': grooming_similarity,
+                'health': health_similarity,
+                'noise': noise_similarity
+            }.items():
+                # 根據權重調整每個特徵分數
+                importance = weights.get(feature, 0.1)
+                if importance > 0.3:  # 高權重特徵
+                    if similarity < 0.5:  # 若關鍵特徵匹配度低
+                        feature_scores[feature] = similarity * 0.5  # 大幅降低分數
+                    else:
+                        feature_scores[feature] = similarity * 1.2  # 提高匹配度好的分數
+                else:  # 一般特徵
+                    feature_scores[feature] = similarity
+
+            # 3. 計算最終相似度
+            weighted_sum = 0
+            weight_sum = 0
+            for feature, score in feature_scores.items():
+                feature_weight = weights.get(feature, 0.1)
+                weighted_sum += score * feature_weight
+                weight_sum += feature_weight
+
+            final_similarity = weighted_sum / weight_sum if weight_sum > 0 else 0.5
+
+            return min(1.0, max(0.2, final_similarity))  # 設定最低分數為0.2
+
+        except Exception as e:
+            print(f"Error in calculate_breed_similarity: {str(e)}")
+            return 0.5
+
+    def get_breed_characteristics_score(self, breed_features: Dict, description: str) -> float:
+        score = 1.0
+        description_lower = description.lower()
+        breed_score_multipliers = []
+
+        # 運動需求評估
+        exercise_needs = breed_features.get('exercise', 'Moderate')
+        exercise_keywords = ['active', 'running', 'energetic', 'athletic']
+        if any(keyword in description_lower for keyword in exercise_keywords):
+            multipliers = {
+                'Very High': 1.5,
+                'High': 1.3,
+                'Moderate': 0.7,
+                'Low': 0.4
+            }
+            breed_score_multipliers.append(multipliers.get(exercise_needs, 1.0))
+
+        # 體型評估
+        size = breed_features.get('size', 'Medium')
+        if 'apartment' in description_lower:
+            size_multipliers = {
+                'Giant': 0.3,
+                'Large': 0.6,
+                'Medium-Large': 0.8,
+                'Medium': 1.4,
+                'Small': 1.0,
+                'Tiny': 0.9
+            }
+            breed_score_multipliers.append(size_multipliers.get(size, 1.0))
+        elif 'house' in description_lower:
+            size_multipliers = {
+                'Giant': 0.8,
+                'Large': 1.2,
+                'Medium-Large': 1.3,
+                'Medium': 1.2,
+                'Small': 0.9,
+                'Tiny': 0.7
+            }
+            breed_score_multipliers.append(size_multipliers.get(size, 1.0))
+
+        # 家庭適應性評估
+        if any(keyword in description_lower for keyword in ['family', 'children', 'kids']):
+            good_with_children = breed_features.get('good_with_children', False)
+            breed_score_multipliers.append(1.3 if good_with_children else 0.6)
+
+        # 噪音評估
+        if 'quiet' in description_lower:
+            noise_level = breed_features.get('noise_level', 'Moderate')
+            noise_multipliers = {
+                'Low': 1.3,
+                'Moderate': 0.9,
+                'High': 0.5
+            }
+            breed_score_multipliers.append(noise_multipliers.get(noise_level, 1.0))
+
+        # 應用所有乘數
+        for multiplier in breed_score_multipliers:
+            score *= multiplier
+
+        # 確保分數在合理範圍內
+        return min(1.5, max(0.3, score))
+
+    def _calculate_size_similarity_enhanced(self, size1: str, size2: str, description: str) -> float:
+        """
+        增強版尺寸相似度計算
+        """
+        try:
+            # 更細緻的尺寸映射
+            size_map = {
+                'Tiny': 0,
+                'Small': 1,
+                'Small-Medium': 2,
+                'Medium': 3,
+                'Medium-Large': 4,
+                'Large': 5,
+                'Giant': 6
+            }
+
+            # 標準化並獲取數值
+            value1 = size_map.get(self._normalize_size(size1), 3)
+            value2 = size_map.get(self._normalize_size(size2), 3)
+
+            # 基礎相似度計算
+            base_similarity = 1.0 - (abs(value1 - value2) / 6.0)
+
+            # 環境適應性調整
+            if 'apartment' in description.lower():
+                if size2 in ['Large', 'Giant']:
+                    base_similarity *= 0.7  # 大型犬在公寓降低相似度
+                elif size2 in ['Medium', 'Medium-Large']:
+                    base_similarity *= 1.2  # 中型犬更適合
+                elif size2 in ['Small', 'Tiny']:
+                    base_similarity *= 0.8  # 過小的狗也不是最佳選擇
+
+            return min(1.0, base_similarity)
+        except Exception as e:
+            print(f"Error in calculate_size_similarity_enhanced: {str(e)}")
+            return 0.5
+
+    def _normalize_size(self, size: str) -> str:
+        """
+        標準化犬種尺寸分類
+
+        Args:
+            size: 原始尺寸描述
+
+        Returns:
+            str: 標準化後的尺寸類別
+        """
+        try:
+            size = size.lower()
+            if 'tiny' in size:
+                return 'Tiny'
+            elif 'small' in size and 'medium' in size:
+                return 'Small-Medium'
+            elif 'small' in size:
+                return 'Small'
+            elif 'medium' in size and 'large' in size:
+                return 'Medium-Large'
+            elif 'medium' in size:
+                return 'Medium'
+            elif 'giant' in size:
+                return 'Giant'
+            elif 'large' in size:
+                return 'Large'
+            return 'Medium'  # 默認為 Medium
+        except Exception as e:
+            print(f"Error in normalize_size: {str(e)}")
+            return 'Medium'
+
+    def _calculate_exercise_similarity_enhanced(self, exercise1: str, exercise2: str) -> float:
+        try:
+            exercise_values = {
+                'Very High': 4,
+                'High': 3,
+                'Moderate': 2,
+                'Low': 1
+            }
+
+            value1 = exercise_values.get(exercise1, 2)
+            value2 = exercise_values.get(exercise2, 2)
+
+            # 計算差異
+            diff = abs(value1 - value2)
+
+            if diff == 0:
+                return 1.0
+            elif diff == 1:
+                return 0.7
+            elif diff == 2:
+                return 0.4
+            else:
+                return 0.2
+
+        except Exception as e:
+            print(f"Error in calculate_exercise_similarity_enhanced: {str(e)}")
+            return 0.5
+
+    def _calculate_grooming_similarity(self, breed1: str, breed2: str) -> float:
+        """
+        計算美容需求相似度
+
+        Args:
+            breed1: 第一個品種名稱
+            breed2: 第二個品種名稱
+
+        Returns:
+            float: 相似度分數 (0-1)
+        """
+        try:
+            grooming_map = {
+                'Low': 1,
+                'Moderate': 2,
+                'High': 3
+            }
+
+            # 從dog_data中獲取美容需求
+            breed1_info = next((dog for dog in self.dog_data if dog[1] == breed1), None)
+            breed2_info = next((dog for dog in self.dog_data if dog[1] == breed2), None)
+
+            if not breed1_info or not breed2_info:
+                return 0.5  # 數據缺失時返回中等相似度
+
+            grooming1 = breed1_info[8]  # Grooming_Needs index
+            grooming2 = breed2_info[8]
+
+            # 獲取數值，默認為 Moderate
+            value1 = grooming_map.get(grooming1, 2)
+            value2 = grooming_map.get(grooming2, 2)
+
+            # 基礎相似度計算
+            base_similarity = 1.0 - (abs(value1 - value2) / 2.0)
+
+            # 美容需求調整
+            if grooming2 == 'Moderate':
+                base_similarity *= 1.1  # 中等美容需求略微加分
+            elif grooming2 == 'High':
+                base_similarity *= 0.9  # 高美容需求略微降分
+
+            return min(1.0, base_similarity)
+        except Exception as e:
+            print(f"Error in calculate_grooming_similarity: {str(e)}")
+            return 0.5
+
+    def _calculate_health_score_similarity(self, breed1: str, breed2: str) -> float:
+        """
+        計算兩個品種的健康評分相似度
+        """
+        try:
+            score1 = self._calculate_health_score(breed1)
+            score2 = self._calculate_health_score(breed2)
+            return 1.0 - abs(score1 - score2)
+        except Exception as e:
+            print(f"Error in calculate_health_score_similarity: {str(e)}")
+            return 0.5
+
+    def _calculate_health_score(self, breed_name: str) -> float:
+        """
+        計算品種的健康評分
+
+        Args:
+            breed_name: 品種名稱
+
+        Returns:
+            float: 健康評分 (0-1)
+        """
+        try:
+            if breed_name not in breed_health_info:
+                return 0.5
+
+            health_notes = breed_health_info[breed_name]['health_notes'].lower()
+
+            # 嚴重健康問題
+            severe_conditions = [
+                'cancer', 'cardiomyopathy', 'epilepsy', 'dysplasia',
+                'bloat', 'progressive', 'syndrome'
+            ]
+
+            # 中等健康問題
+            moderate_conditions = [
+                'allergies', 'infections', 'thyroid', 'luxation',
+                'skin problems', 'ear'
+            ]
+
+            # 計算問題數量
+            severe_count = sum(1 for condition in severe_conditions if condition in health_notes)
+            moderate_count = sum(1 for condition in moderate_conditions if condition in health_notes)
+
+            # 基礎健康評分
+            health_score = 1.0
+            health_score -= (severe_count * 0.15)  # 嚴重問題扣分更多
+            health_score -= (moderate_count * 0.05)  # 中等問題扣分較少
+
+            # 確保評分在合理範圍內
+            return max(0.3, min(1.0, health_score))
+        except Exception as e:
+            print(f"Error in calculate_health_score: {str(e)}")
+            return 0.5
+
+
+    def _calculate_noise_similarity(self, breed1: str, breed2: str) -> float:
+        """計算兩個品種的噪音相似度"""
+        noise_levels = {
+            'Low': 1,
+            'Moderate': 2,
+            'High': 3,
+            'Unknown': 2  # 默認為中等
+        }
+
+        noise1 = breed_noise_info.get(breed1, {}).get('noise_level', 'Unknown')
+        noise2 = breed_noise_info.get(breed2, {}).get('noise_level', 'Unknown')
+
+        # 獲取數值級別
+        level1 = noise_levels.get(noise1, 2)
+        level2 = noise_levels.get(noise2, 2)
+
+        # 計算差異並歸一化
+        difference = abs(level1 - level2)
+        similarity = 1.0 - (difference / 2)  # 最大差異是2，所以除以2來歸一化
+
+        return similarity
+
+    # bonus score zone
+    def _calculate_size_bonus(self, size: str, living_space: str) -> float:
+        """
+        計算尺寸匹配的獎勵分數
+
+        Args:
+            size: 品種尺寸
+            living_space: 居住空間類型
+
+        Returns:
+            float: 獎勵分數 (-0.25 到 0.15)
+        """
+        try:
+            if living_space == "apartment":
+                size_scores = {
+                    'Tiny': -0.15,
+                    'Small': 0.10,
+                    'Medium': 0.15,
+                    'Large': 0.10,
+                    'Giant': -0.30
+                }
+            else:  # house
+                size_scores = {
+                    'Tiny': -0.10,
+                    'Small': 0.05,
+                    'Medium': 0.15,
+                    'Large': 0.15,
+                    'Giant': -0.15
+                }
+            return size_scores.get(size, 0.0)
+        except Exception as e:
+            print(f"Error in calculate_size_bonus: {str(e)}")
+            return 0.0
+
+    def _calculate_exercise_bonus(self, exercise_needs: str, exercise_time: int) -> float:
+        """
+        計算運動需求匹配的獎勵分數
+
+        Args:
+            exercise_needs: 品種運動需求
+            exercise_time: 用戶可提供的運動時間（分鐘）
+
+        Returns:
+            float: 獎勵分數 (-0.20 到 0.20)
+        """
+        try:
+            if exercise_time >= 120:  # 高運動量需求
+                exercise_scores = {
+                    'Low': -0.30,
+                    'Moderate': -0.10,
+                    'High': 0.15,
+                    'Very High': 0.30
+                }
+            elif exercise_time >= 60:  # 中等運動量需求
+                exercise_scores = {
+                    'Low': -0.05,
+                    'Moderate': 0.15,
+                    'High': 0.05,
+                    'Very High': -0.10
+                }
+            else:  # 低運動量需求
+                exercise_scores = {
+                    'Low': 0.15,
+                    'Moderate': 0.05,
+                    'High': -0.15,
+                    'Very High': -0.20
+                }
+            return exercise_scores.get(exercise_needs, 0.0)
+        except Exception as e:
+            print(f"Error in calculate_exercise_bonus: {str(e)}")
+            return 0.0
+
+    def _calculate_grooming_bonus(self, grooming: str, commitment: str) -> float:
+        """
+        計算美容需求匹配的獎勵分數
+
+        Args:
+            grooming: 品種美容需求
+            commitment: 用戶美容投入程度
+
+        Returns:
+            float: 獎勵分數 (-0.15 到 0.10)
+        """
+        try:
+            if commitment == "high":
+                grooming_scores = {
+                    'Low': -0.05,
+                    'Moderate': 0.05,
+                    'High': 0.10
+                }
+            else:  # medium or low commitment
+                grooming_scores = {
+                    'Low': 0.10,
+                    'Moderate': 0.05,
+                    'High': -0.20
+                }
+            return grooming_scores.get(grooming, 0.0)
+        except Exception as e:
+            print(f"Error in calculate_grooming_bonus: {str(e)}")
+            return 0.0
+
+    def _calculate_family_bonus(self, breed_info: Dict) -> float:
+        """
+        計算家庭適應性的獎勵分數
+
+        Args:
+            breed_info: 品種信息字典
+
+        Returns:
+            float: 獎勵分數 (0 到 0.20)
+        """
+        try:
+            bonus = 0.0
+            temperament = breed_info.get('Temperament', '').lower()
+            good_with_children = breed_info.get('Good_With_Children', False)
+
+            if good_with_children:
+                bonus += 0.20
+            if any(trait in temperament for trait in ['gentle', 'patient', 'friendly']):
+                bonus += 0.10
+
+            return min(0.20, bonus)
+        except Exception as e:
+            print(f"Error in calculate_family_bonus: {str(e)}")
+            return 0.0
+
+
+    def _detect_scenario(self, description: str) -> Dict[str, float]:
+        """
+        檢測場景並返回對應權重
+        """
+        # 基礎場景定義
+        scenarios = {
+            'athletic': {
+                'keywords': ['active', 'exercise', 'running', 'athletic', 'energetic', 'sports'],
+                'weights': {
+                    'exercise': 0.40,
+                    'size': 0.25,
+                    'temperament': 0.20,
+                    'health': 0.15
+                }
+            },
+            'apartment': {
+                'keywords': ['apartment', 'flat', 'condo'],
+                'weights': {
+                    'size': 0.35,
+                    'noise': 0.30,
+                    'exercise': 0.20,
+                    'temperament': 0.15
+                }
+            },
+            'family': {
+                'keywords': ['family', 'children', 'kids', 'friendly'],
+                'weights': {
+                    'temperament': 0.35,
+                    'safety': 0.30,
+                    'noise': 0.20,
+                    'exercise': 0.15
+                }
+            },
+            'novice': {
+                'keywords': ['first time', 'beginner', 'new owner', 'inexperienced'],
+                'weights': {
+                    'trainability': 0.35,
+                    'temperament': 0.30,
+                    'care_level': 0.20,
+                    'health': 0.15
+                }
+            }
+        }
+
+        # 檢測匹配的場景
+        matched_scenarios = []
+        for scenario, config in scenarios.items():
+            if any(keyword in description.lower() for keyword in config['keywords']):
+                matched_scenarios.append(scenario)
+
+        # 默認權重
+        default_weights = {
+            'exercise': 0.20,
+            'size': 0.20,
+            'temperament': 0.20,
+            'health': 0.15,
+            'noise': 0.10,
+            'grooming': 0.10,
+            'trainability': 0.05
+        }
+
+        # 如果沒有匹配場景，返回默認權重
+        if not matched_scenarios:
+            return default_weights
+
+        # 合併匹配場景的權重
+        final_weights = default_weights.copy()
+        for scenario in matched_scenarios:
+            scenario_weights = scenarios[scenario]['weights']
+            for feature, weight in scenario_weights.items():
+                if feature in final_weights:
+                    final_weights[feature] = max(final_weights[feature], weight)
+
+        return final_weights
+
+
+    def _calculate_final_scores(self, breed_name: str, base_scores: Dict,
+                          smart_score: float, is_preferred: bool,
+                          similarity_score: float = 0.0,
+                          characteristics_score: float = 1.0,
+                          weights: Dict[str, float] = None) -> Dict:
+        try:
+            # 使用傳入的權重或默認權重
+            if weights is None:
+                weights = {
+                    'base': 0.35,
+                    'smart': 0.35,
+                    'bonus': 0.15,
+                    'characteristics': 0.15
+                }
+
+            # 確保 base_scores 包含所有必要的鍵
+            base_scores = {
+                'overall': base_scores.get('overall', smart_score),
+                'size': base_scores.get('size', 0.0),
+                'exercise': base_scores.get('exercise', 0.0),
+                'temperament': base_scores.get('temperament', 0.0),
+                'grooming': base_scores.get('grooming', 0.0),
+                'health': base_scores.get('health', 0.0),
+                'noise': base_scores.get('noise', 0.0)
+            }
+
+            # 計算基礎分數
+            base_score = base_scores['overall']
+
+            # 計算獎勵分數
+            bonus_score = 0.0
+            if is_preferred:
+                bonus_score = 0.95
+            elif similarity_score > 0:
+                bonus_score = min(0.8, similarity_score) * 0.95
+
+            # 特徵匹配度調整
+            if characteristics_score < 0.5:
+                base_score *= 0.7  # 降低基礎分數
+                smart_score *= 0.7  # 降低智能匹配分數
+
+            # 計算最終分數
+            final_score = (
+                base_score * weights.get('base', 0.35) +
+                smart_score * weights.get('smart', 0.35) +
+                bonus_score * weights.get('bonus', 0.15) +
+                characteristics_score * weights.get('characteristics', 0.15)
+            )
+
+            # 確保分數在合理範圍內
+            final_score = min(1.0, max(0.3, final_score))
+
+            return {
+                'final_score': round(final_score, 4),
+                'base_score': round(base_score, 4),
+                'smart_score': round(smart_score, 4),
+                'bonus_score': round(bonus_score, 4),
+                'characteristics_score': round(characteristics_score, 4),
+                'detailed_scores': base_scores
+            }
+
+        except Exception as e:
+            print(f"Error in calculate_final_scores: {str(e)}")
+            return {
+                'final_score': 0.5,
+                'base_score': 0.5,
+                'smart_score': 0.5,
+                'bonus_score': 0.0,
+                'characteristics_score': 0.5,
+                'detailed_scores': {
+                    'overall': 0.5,
+                    'size': 0.5,
+                    'exercise': 0.5,
+                    'temperament': 0.5,
+                    'grooming': 0.5,
+                    'health': 0.5,
+                    'noise': 0.5
+                }
+            }
+
+    def _general_matching(self, description: str, weights: Dict[str, float], top_n: int = 10) -> List[Dict]:
+        """基本的品種匹配邏輯，考慮描述、性格、噪音和健康因素"""
+        try:
+            matches = []
+            desc_embedding = self._get_cached_embedding(description)
+
+            for breed in self.dog_data:
+                breed_name = breed[1]
+                breed_features = self._extract_breed_features(breed)
+                breed_description = breed[9]
+                temperament = breed[4]
+
+                breed_desc_embedding = self._get_cached_embedding(breed_description)
+                breed_temp_embedding = self._get_cached_embedding(temperament)
+
+                desc_similarity = float(util.pytorch_cos_sim(desc_embedding, breed_desc_embedding))
+                temp_similarity = float(util.pytorch_cos_sim(desc_embedding, breed_temp_embedding))
+
+                noise_similarity = self._calculate_noise_similarity(breed_name, breed_name)
+                health_score = self._calculate_health_score(breed_name)
+                health_similarity = 1.0 - abs(health_score - 0.8)
+
+                # 使用傳入的權重
+                final_score = (
+                    desc_similarity * weights.get('description', 0.35) +
+                    temp_similarity * weights.get('temperament', 0.25) +
+                    noise_similarity * weights.get('noise', 0.2) +
+                    health_similarity * weights.get('health', 0.2)
+                )
+
+                # 計算特徵分數
+                characteristics_score = self.get_breed_characteristics_score(breed_features, description)
+
+                # 構建完整的 scores 字典
+                scores = {
+                    'overall': final_score,
+                    'size': breed_features.get('size_score', 0.0),
+                    'exercise': breed_features.get('exercise_score', 0.0),
+                    'temperament': temp_similarity,
+                    'grooming': breed_features.get('grooming_score', 0.0),
+                    'health': health_score,
+                    'noise': noise_similarity
+                }
+
+                matches.append({
+                    'breed': breed_name,
+                    'scores': scores,
+                    'final_score': final_score,
+                    'base_score': final_score,
+                    'characteristics_score': characteristics_score,
+                    'bonus_score': 0.0,
+                    'is_preferred': False,
+                    'similarity': final_score,
+                    'health_score': health_score,
+                    'reason': "Matched based on description and characteristics"
+                })
+
+            return sorted(matches, key=lambda x: (-x['characteristics_score'], -x['final_score']))[:top_n]
+
+        except Exception as e:
+            print(f"Error in _general_matching: {str(e)}")
+            return []
+
+
+    def _detect_breed_preference(self, description: str) -> Optional[str]:
+        """檢測用戶是否提到特定品種"""
+        description_lower = f" {description.lower()} "
+
+        for breed_info in self.dog_data:
+            breed_name = breed_info[1]
+            normalized_breed = breed_name.lower().replace('_', ' ')
+
+            pattern = rf"\b{re.escape(normalized_breed)}\b"
+
+            if re.search(pattern, description_lower):
+                return breed_name
+
+        return None
+
+    def _extract_breed_features(self, breed_info: Tuple) -> Dict:
+        """
+        從品種信息中提取特徵
+
+        Args:
+            breed_info: 品種信息元組
+
+        Returns:
+            Dict: 包含品種特徵的字典
+        """
+        try:
+            return {
+                'breed_name': breed_info[1],
+                'size': breed_info[2],
+                'temperament': breed_info[4],
+                'exercise': breed_info[7],
+                'grooming': breed_info[8],
+                'description': breed_info[9],
+                'good_with_children': breed_info[6]
+            }
+        except Exception as e:
+            print(f"Error in extract_breed_features: {str(e)}")
+            return {
+                'breed_name': '',
+                'size': 'Medium',
+                'temperament': '',
+                'exercise': 'Moderate',
+                'grooming': 'Moderate',
+                'description': '',
+                'good_with_children': False
+            }
+
+    def match_user_preference(self, description: str, top_n: int = 10) -> List[Dict]:
+        try:
+            # 獲取場景權重
+            weights = self._detect_scenario(description)
+            matches = []
+            preferred_breed = self._detect_breed_preference(description)
+
+            # 處理用戶明確提到的品種
+            if preferred_breed:
+                breed_info = next((breed for breed in self.dog_data if breed[1] == preferred_breed), None)
+                if breed_info:
+                    breed_features = self._extract_breed_features(breed_info)
+                    base_similarity = self._calculate_breed_similarity(breed_features, breed_features, weights)
+
+                    # 計算特徵分數
+                    characteristics_score = self.get_breed_characteristics_score(breed_features, description)
+
+                    # 計算最終分數
+                    scores = self._calculate_final_scores(
+                        preferred_breed,
+                        {'overall': base_similarity},
+                        smart_score=base_similarity,
+                        is_preferred=True,
+                        similarity_score=1.0,
+                        characteristics_score=characteristics_score,
+                        weights=weights
+                    )
+
+                    matches.append({
+                        'breed': preferred_breed,
+                        'scores': scores['detailed_scores'],
+                        'final_score': scores['final_score'],
+                        'base_score': scores['base_score'],
+                        'bonus_score': scores['bonus_score'],
+                        'characteristics_score': characteristics_score,
+                        'is_preferred': True,
+                        'priority': 1,
+                        'health_score': self._calculate_health_score(preferred_breed),
+                        'reason': "Directly matched your preferred breed"
+                    })
+
+                    # 尋找相似品種
+                    similar_breeds = self.find_similar_breeds(preferred_breed, top_n=top_n-1)
+                    for breed_name, similarity in similar_breeds:
+                        if breed_name != preferred_breed:
+                            breed_info = next((breed for breed in self.dog_data if breed[1] == breed_name), None)
+                            if breed_info:
+                                breed_features = self._extract_breed_features(breed_info)
+                                characteristics_score = self.get_breed_characteristics_score(breed_features, description)
+
+                                scores = self._calculate_final_scores(
+                                    breed_name,
+                                    {'overall': similarity},
+                                    smart_score=similarity,
+                                    is_preferred=False,
+                                    similarity_score=similarity,
+                                    characteristics_score=characteristics_score,
+                                    weights=weights
+                                )
+
+                                if scores['final_score'] >= 0.4:  # 設定最低分數門檻
+                                    matches.append({
+                                        'breed': breed_name,
+                                        'scores': scores['detailed_scores'],
+                                        'final_score': scores['final_score'],
+                                        'base_score': scores['base_score'],
+                                        'bonus_score': scores['bonus_score'],
+                                        'characteristics_score': characteristics_score,
+                                        'is_preferred': False,
+                                        'priority': 2,
+                                        'health_score': self._calculate_health_score(breed_name),
+                                        'reason': f"Similar to {preferred_breed}"
+                                    })
+
+            # 如果沒有找到偏好品種或需要更多匹配
+            if len(matches) < top_n:
+                general_matches = self._general_matching(description, weights, top_n - len(matches))
+                for match in general_matches:
+                    if match['breed'] not in [m['breed'] for m in matches]:
+                        match['priority'] = 3
+                        if match['final_score'] >= 0.4:  # 分數門檻
+                            matches.append(match)
+
+            # 最終排序
+            matches.sort(key=lambda x: (
+                -x.get('characteristics_score', 0),  # 首先考慮特徵匹配度
+                -x.get('final_score', 0),           # 然後是總分
+                -x.get('base_score', 0),            # 最後是基礎分數
+                x.get('breed', '')                  # 字母順序
+            ))
+
+            # 取前N個結果
+            final_matches = matches[:top_n]
+
+            # 更新排名
+            for i, match in enumerate(final_matches, 1):
+                match['rank'] = i
+
+            return final_matches
+
+        except Exception as e:
+            print(f"Error in match_user_preference: {str(e)}")
+            return []