Delete smart_breed_matcher.py

smart_breed_matcher.py

@@ -1,1001 +0,0 @@
-import torch
-import re
-import numpy as np
-import spaces
-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
-from functools import wraps
-
-def gpu_init_wrapper(func):
-    @spaces.GPU
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-    return wrapper
-
-def safe_prediction(func):
-    """錯誤處理裝飾器，提供 GPU 到 CPU 的降級機制"""
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except RuntimeError as e:
-            if "CUDA" in str(e):
-                print("GPU 操作失敗，嘗試使用 CPU")
-                return func(*args, **kwargs)
-            raise
-    return wrapper
-
-class SmartBreedMatcher:
-
-    def __init__(self, dog_data: List[Tuple]):
-        self.dog_data = dog_data
-        self.model = None
-        self._embedding_cache = {}
-        self._clear_cache()
-
-    def _initialize_model(self):
-        """延遲初始化模型，只在需要時才創建"""
-        if self.model is None:
-            self.model = SentenceTransformer('all-mpnet-base-v2')
-
-    def _clear_cache(self):
-        self._embedding_cache = {}
-
-
-    @spaces.GPU
-    def _get_cached_embedding(self, text: str) -> torch.Tensor:
-        """使用 GPU 裝飾器確保在正確的時機初始化 CUDA"""
-        if self.model is None:
-            self._initialize_model()
-            
-        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:
-            if self.model is None:
-                self._initialize_model()
-            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
-            }
-
-    @gpu_init_wrapper
-    @safe_prediction
-    def match_user_preference(self, description: str, top_n: int = 10) -> List[Dict]:
-        try:
-            if self.model is None:
-                self._initialize_model()
-            # 獲取場景權重
-            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 []