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 = {} 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]]: """找出與指定品種最相似的其他品種""" 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], 'description': target_breed[9] } 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], 'description': breed[9] } similarity_score = self._calculate_breed_similarity(target_features, breed_features) similarities.append((breed[1], similarity_score)) return sorted(similarities, key=lambda x: x[1], reverse=True)[:top_n] # def _calculate_breed_similarity(self, breed1_features: Dict, breed2_features: Dict) -> float: # """計算兩個品種之間的相似度，包含健康和噪音因素""" # # 計算描述文本的相似度 # desc1_embedding = self._get_cached_embedding(breed1_features['description']) # desc2_embedding = self._get_cached_embedding(breed2_features['description']) # description_similarity = float(util.pytorch_cos_sim(desc1_embedding, desc2_embedding)) # # 基本特徵相似度 # size_similarity = 1.0 if breed1_features['size'] == breed2_features['size'] else 0.5 # exercise_similarity = 1.0 if breed1_features['exercise'] == breed2_features['exercise'] else 0.5 # # 性格相似度 # temp1_embedding = self._get_cached_embedding(breed1_features['temperament']) # temp2_embedding = self._get_cached_embedding(breed2_features['temperament']) # temperament_similarity = float(util.pytorch_cos_sim(temp1_embedding, temp2_embedding)) # # 健康分數相似度 # health_score1 = self._calculate_health_score(breed1_features['breed_name']) # health_score2 = self._calculate_health_score(breed2_features['breed_name']) # health_similarity = 1.0 - abs(health_score1 - health_score2) # # 噪音水平相似度 # noise_similarity = self._calculate_noise_similarity( # breed1_features['breed_name'], # breed2_features['breed_name'] # ) # # 加權計算 # weights = { # 'description': 0.25, # 'temperament': 0.20, # 'exercise': 0.2, # 'size': 0.05, # 'health': 0.15, # 'noise': 0.15 # } # final_similarity = ( # description_similarity * weights['description'] + # temperament_similarity * weights['temperament'] + # exercise_similarity * weights['exercise'] + # size_similarity * weights['size'] + # health_similarity * weights['health'] + # noise_similarity * weights['noise'] # ) # return final_similarity def _calculate_breed_similarity(self, breed1_features: Dict, breed2_features: Dict) -> float: """增強版品種相似度計算""" # 基礎相似度計算 desc1_embedding = self._get_cached_embedding(breed1_features['description']) desc2_embedding = self._get_cached_embedding(breed2_features['description']) description_similarity = float(util.pytorch_cos_sim(desc1_embedding, desc2_embedding)) # 尺寸相似度（加強版） size_similarity = self._calculate_size_similarity_enhanced( breed1_features['size'], breed2_features['size'], breed2_features['description'] # 加入描述以判斷適應性 ) # 運動需求相似度（加強版） exercise_similarity = self._calculate_exercise_similarity_enhanced( breed1_features['exercise'], breed2_features['exercise'] ) # 美容需求相似度 grooming_similarity = self._calculate_grooming_similarity( breed1_features['breed_name'], breed2_features['breed_name'] ) # 其他相似度計算保持不變 temp1_embedding = self._get_cached_embedding(breed1_features['temperament']) temp2_embedding = self._get_cached_embedding(breed2_features['temperament']) temperament_similarity = float(util.pytorch_cos_sim(temp1_embedding, temp2_embedding)) health_score1 = self._calculate_health_score(breed1_features['breed_name']) health_score2 = self._calculate_health_score(breed2_features['breed_name']) health_similarity = 1.0 - abs(health_score1 - health_score2) noise_similarity = self._calculate_noise_similarity( breed1_features['breed_name'], breed2_features['breed_name'] ) # 調整權重分配 weights = { 'size': 0.20, # 仍然重要但不過分主導 'exercise': 0.20, # 保持高權重因為這是主要需求 'temperament': 0.15, # 保持不變因為性格很重要 'grooming': 0.15, # 保持不變 'health': 0.15, # 提高一點因為這影響長期生活 'description': 0.10, # 保持不變 'noise': 0.05 # 保持不變因為不是主要考慮因素 } final_similarity = ( size_similarity * weights['size'] + exercise_similarity * weights['exercise'] + grooming_similarity * weights['grooming'] + temperament_similarity * weights['temperament'] + description_similarity * weights['description'] + health_similarity * weights['health'] + noise_similarity * weights['noise'] ) return final_similarity def _calculate_final_scores(self, breed_name: str, base_scores: Dict, smart_score: float, is_preferred: bool, similarity_score: float = 0.0) -> Dict: """ 計算最終分數，包含基礎分數和獎勵分數 Args: breed_name: 品種名稱 base_scores: 基礎評分 (空間、運動等) smart_score: 智能匹配分數 is_preferred: 是否為用戶指定品種 similarity_score: 與指定品種的相似度 (0-1) """ # 基礎權重 weights = { 'base': 0.6, # 基礎分數權重 'smart': 0.25, # 智能匹配權重 'bonus': 0.15 # 獎勵分數權重 } # 計算基礎分數 base_score = base_scores.get('overall', 0.7) # 計算獎勵分數 bonus_score = 0.0 if is_preferred: # 用戶指定品種獲得最高獎勵 bonus_score = 0.95 elif similarity_score > 0: # 相似品種獲得部分獎勵，但不超過80%的最高獎勵 bonus_score = min(0.8, similarity_score) * 0.95 # 計算最終分數 final_score = ( base_score * weights['base'] + smart_score * weights['smart'] + bonus_score * weights['bonus'] ) # 更新各項分數 scores = base_scores.copy() # 如果是用戶指定品種，稍微提升各項基礎分數，但保持合理範圍 if is_preferred: for key in scores: if key != 'overall': scores[key] = min(1.0, scores[key] * 1.1) # 最多提升10% # 為相似品種調整分數 elif similarity_score > 0: boost_factor = 1.0 + (similarity_score * 0.05) # 最多提升5% for key in scores: if key != 'overall': scores[key] = min(0.95, scores[key] * boost_factor) # 確保不超過95% return { 'final_score': round(final_score, 4), 'base_score': round(base_score, 4), 'bonus_score': round(bonus_score, 4), 'scores': {k: round(v, 4) for k, v in scores.items()} } def _calculate_size_similarity_enhanced(self, size1: str, size2: str, description: str) -> float: """增強版尺寸相似度計算""" # 更細緻的尺寸映射 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) # 預設為 Medium value2 = size_map.get(self._normalize_size(size2), 3) # 計算基礎相似度 base_similarity = 1.0 - (abs(value1 - value2) / 6.0) # 根據用戶需求的尺寸偏好調整分數 if size2 in ['Small', 'Tiny']: base_similarity *= 0.5 # 顯著降低小型犬的分數 elif size2 == 'Giant': base_similarity *= 0.6 # 顯著降低巨型犬的分數 elif size2 in ['Medium', 'Medium-Large']: base_similarity *= 1.2 # 提高中型和中大型犬的分數 # 考慮適應性 if 'apartment' in description.lower() and size2 in ['Large', 'Giant']: base_similarity *= 0.8 # 降低大型犬在公寓的適應性分數 return min(1.0, base_similarity) # 確保不超過1.0 def _normalize_size(self, size: str) -> str: """標準化尺寸分類""" size = size.lower() if 'tiny' in size: return 'Tiny' 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' # 預設 def _calculate_exercise_similarity_enhanced(self, exercise1: str, exercise2: str) -> float: """增強版運動需求相似度計算""" exercise_map = { 'Low': 1, 'Moderate': 2, 'High': 3, 'Very High': 4 } value1 = exercise_map.get(exercise1, 2) value2 = exercise_map.get(exercise2, 2) # 基礎相似度 base_similarity = 1.0 - abs(value1 - value2) / 3.0 # 根據用戶需求調整 if exercise2 in ['High', 'Very High']: base_similarity *= 1.2 # 提高高運動量品種的分數 elif exercise2 == 'Low': base_similarity *= 0.7 # 降低低運動量品種的分數 return min(1.0, base_similarity) def _calculate_grooming_similarity(self, breed1: str, breed2: str) -> float: """計算美容需求相似度""" 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] 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) def _calculate_health_score(self, breed_name: str) -> float: """計算品種的健康分數""" 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.1) health_score -= (moderate_count * 0.05) # 特殊條件調整（根據用戶偏好） if hasattr(self, 'user_preferences'): if self.user_preferences.has_children: if 'requires frequent' in health_notes or 'regular monitoring' in health_notes: health_score *= 0.9 if self.user_preferences.health_sensitivity == 'high': health_score *= 0.9 return max(0.3, min(1.0, health_score)) 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 def _general_matching(self, description: str, top_n: int = 10) -> List[Dict]: """基本的品種匹配邏輯，考慮描述、性格、噪音和健康因素""" matches = [] # 預先計算描述的 embedding 並快取 desc_embedding = self._get_cached_embedding(description) for breed in self.dog_data: breed_name = breed[1] 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) weights = { 'description': 0.35, 'temperament': 0.25, 'noise': 0.2, 'health': 0.2 } final_score = ( desc_similarity * weights['description'] + temp_similarity * weights['temperament'] + noise_similarity * weights['noise'] + health_similarity * weights['health'] ) matches.append({ 'breed': breed_name, 'score': final_score, 'is_preferred': False, 'similarity': final_score, 'reason': "Matched based on description, temperament, noise level, and health score" }) return sorted(matches, key=lambda x: -x['score'])[:top_n] 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 match_user_preference(self, description: str, top_n: int = 10) -> List[Dict]: """根據用戶描述匹配最適合的品種""" preferred_breed = self._detect_breed_preference(description) matches = [] if preferred_breed: # 首先添加偏好品種 breed_info = next((breed for breed in self.dog_data if breed[1] == preferred_breed), None) if breed_info: base_scores = {'overall': 1.0} # 給予最高基礎分數 # 計算偏好品種的最終分數 scores = self._calculate_final_scores( preferred_breed, base_scores, smart_score=1.0, is_preferred=True, similarity_score=1.0 ) matches.append({ 'breed': preferred_breed, 'score': 1.0, # 確保最高分 'final_score': scores['final_score'], 'base_score': scores['base_score'], 'bonus_score': scores['bonus_score'], 'is_preferred': True, 'priority': 1, # 最高優先級 'health_score': self._calculate_health_score(preferred_breed), 'noise_level': breed_noise_info.get(preferred_breed, {}).get('noise_level', 'Unknown'), '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: # 使用 _calculate_final_scores 計算相似品種分數 scores = self._calculate_final_scores( breed_name, {'overall': similarity * 0.9}, # 基礎分數略低於偏好品種 smart_score=similarity, is_preferred=False, similarity_score=similarity ) matches.append({ 'breed': breed_name, 'score': min(0.95, similarity), # 確保不超過偏好品種 'final_score': scores['final_score'], 'base_score': scores['base_score'], 'bonus_score': scores['bonus_score'], 'is_preferred': False, 'priority': 2, 'health_score': self._calculate_health_score(breed_name), 'noise_level': breed_noise_info.get(breed_name, {}).get('noise_level', 'Unknown'), 'reason': f"Similar to {preferred_breed}" }) else: matches = self._general_matching(description, top_n) for match in matches: match['priority'] = 3 # 使用複合排序鍵 final_matches = sorted( matches, key=lambda x: ( x.get('priority', 3) * -1, # 優先級倒序（1最高） x.get('is_preferred', False) * 1, # 偏好品種優先 float(x.get('final_score', 0)) * -1, # 分數倒序 x.get('breed', '') # 品種名稱正序 ) )[:top_n] return final_matches