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 []