import random import hashlib import numpy as np import sqlite3 import re import traceback from typing import List, Dict, Tuple, Optional, Any from dataclasses import dataclass from sentence_transformers import SentenceTransformer import torch from sklearn.metrics.pairwise import cosine_similarity from dog_database import get_dog_description 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, UnifiedScoringSystem, calculate_unified_breed_scores from query_understanding import QueryUnderstandingEngine, analyze_user_query from constraint_manager import ConstraintManager, apply_breed_constraints from multi_head_scorer import MultiHeadScorer, score_breed_candidates, BreedScore from score_calibrator import ScoreCalibrator, calibrate_breed_scores from config_manager import get_config_manager, get_standardized_breed_data class MatchingScoreCalculator: """ 匹配評分計算器 處理多維度匹配計算、約束條件過濾和評分校準 """ def __init__(self, breed_list: List[str]): """初始化匹配評分計算器""" self.breed_list = breed_list def apply_size_distribution_correction(self, recommendations: List[Dict]) -> List[Dict]: """應用尺寸分佈修正以防止大型品種偏差""" if len(recommendations) < 10: return recommendations # 分析尺寸分佈 size_counts = {'toy': 0, 'small': 0, 'medium': 0, 'large': 0, 'giant': 0} for rec in recommendations: breed_info = get_dog_description(rec['breed']) if breed_info: size = self._normalize_breed_size(breed_info.get('Size', 'Medium')) size_counts[size] += 1 total_recs = len(recommendations) large_giant_ratio = (size_counts['large'] + size_counts['giant']) / total_recs # 如果超過 70% 是大型/巨型品種，應用修正 if large_giant_ratio > 0.7: corrected_recommendations = [] size_quotas = {'toy': 2, 'small': 4, 'medium': 6, 'large': 2, 'giant': 1} current_counts = {'toy': 0, 'small': 0, 'medium': 0, 'large': 0, 'giant': 0} # 第一輪：在配額內添加品種 for rec in recommendations: breed_info = get_dog_description(rec['breed']) if breed_info: size = self._normalize_breed_size(breed_info.get('Size', 'Medium')) if current_counts[size] < size_quotas[size]: corrected_recommendations.append(rec) current_counts[size] += 1 # 第二輪：用最佳剩餘候選品種填滿剩餘位置 remaining_slots = 15 - len(corrected_recommendations) remaining_breeds = [rec for rec in recommendations if rec not in corrected_recommendations] corrected_recommendations.extend(remaining_breeds[:remaining_slots]) return corrected_recommendations return recommendations def _normalize_breed_size(self, size: str) -> str: """標準化品種尺寸到標準分類""" if not isinstance(size, str): return 'medium' size_lower = size.lower() if any(term in size_lower for term in ['toy', 'tiny']): return 'toy' elif 'small' in size_lower: return 'small' elif 'medium' in size_lower: return 'medium' elif 'large' in size_lower: return 'large' elif any(term in size_lower for term in ['giant', 'extra large']): return 'giant' else: return 'medium' def apply_hard_constraints(self, breed: str, user_input: str, breed_characteristics: Dict[str, Any]) -> float: """增強硬約束，具有更嚴格的懲罰""" penalty = 0.0 user_text_lower = user_input.lower() # 獲取品種信息 breed_info = get_dog_description(breed) if not breed_info: return 0.0 breed_size = breed_info.get('Size', '').lower() exercise_needs = breed_info.get('Exercise Needs', '').lower() # 公寓居住約束 - 更嚴格 if any(term in user_text_lower for term in ['apartment', 'flat', 'studio', 'small space']): if 'giant' in breed_size: return -2.0 # 完全淘汰 elif 'large' in breed_size: if any(term in exercise_needs for term in ['high', 'very high']): return -2.0 # 完全淘汰 else: penalty -= 0.5 # 仍有顯著懲罰 elif 'medium' in breed_size and 'very high' in exercise_needs: penalty -= 0.6 # 運動不匹配約束 if "don't exercise much" in user_text_lower or "low exercise" in user_text_lower: if any(term in exercise_needs for term in ['very high', 'extreme', 'intense']): return -2.0 # 完全淘汰 elif 'high' in exercise_needs: penalty -= 0.8 # 中等生活方式檢測 if any(term in user_text_lower for term in ['moderate', 'balanced', '30 minutes', 'half hour']): # 懲罰極端情況 if 'giant' in breed_size: penalty -= 0.7 # 對巨型犬的強懲罰 elif 'very high' in exercise_needs: penalty -= 0.5 # 兒童安全（現有邏輯保持但增強） if any(term in user_text_lower for term in ['child', 'kids', 'family', 'baby']): good_with_children = breed_info.get('Good with Children', '').lower() if good_with_children == 'no': return -2.0 # 為了安全完全淘汰 return penalty def calculate_lifestyle_bonus(self, breed_characteristics: Dict[str, Any], lifestyle_keywords: Dict[str, List[str]]) -> float: """增強生活方式匹配獎勵計算""" bonus = 0.0 penalties = 0.0 # 增強尺寸匹配 breed_size = breed_characteristics.get('size', '').lower() size_prefs = lifestyle_keywords.get('size_preference', []) for pref in size_prefs: if pref in breed_size: bonus += 0.25 # 尺寸匹配的強獎勵 elif (pref == 'small' and 'large' in breed_size) or \ (pref == 'large' and 'small' in breed_size): penalties += 0.15 # 尺寸不匹配的懲罰 # 增強活動水平匹配 breed_exercise = breed_characteristics.get('exercise_needs', '').lower() activity_prefs = lifestyle_keywords.get('activity_level', []) if 'high' in activity_prefs: if 'high' in breed_exercise or 'very high' in breed_exercise: bonus += 0.2 elif 'low' in breed_exercise: penalties += 0.2 elif 'low' in activity_prefs: if 'low' in breed_exercise: bonus += 0.2 elif 'high' in breed_exercise or 'very high' in breed_exercise: penalties += 0.25 elif 'moderate' in activity_prefs: if 'moderate' in breed_exercise: bonus += 0.15 # 增強家庭情況匹配 good_with_children = breed_characteristics.get('good_with_children', 'Yes') family_prefs = lifestyle_keywords.get('family_situation', []) if 'children' in family_prefs: if good_with_children == 'Yes': bonus += 0.15 else: penalties += 0.3 # 對非兒童友好品種的強懲罰 # 增強居住空間匹配 living_prefs = lifestyle_keywords.get('living_space', []) if 'apartment' in living_prefs: if 'small' in breed_size: bonus += 0.2 elif 'medium' in breed_size and 'low' in breed_exercise: bonus += 0.1 elif 'large' in breed_size or 'giant' in breed_size: penalties += 0.2 # 公寓中大型犬的懲罰 # 噪音偏好匹配 noise_prefs = lifestyle_keywords.get('noise_preference', []) temperament = breed_characteristics.get('temperament', '').lower() if 'low' in noise_prefs: # 獎勵安靜品種 if any(term in temperament for term in ['gentle', 'calm', 'quiet']): bonus += 0.1 # 照護水平匹配 grooming_needs = breed_characteristics.get('grooming_needs', '').lower() care_prefs = lifestyle_keywords.get('care_level', []) if 'low' in care_prefs and 'low' in grooming_needs: bonus += 0.1 elif 'high' in care_prefs and 'high' in grooming_needs: bonus += 0.1 elif 'low' in care_prefs and 'high' in grooming_needs: penalties += 0.15 # 特殊需求匹配 special_needs = lifestyle_keywords.get('special_needs', []) if 'guard' in special_needs: if any(term in temperament for term in ['protective', 'alert', 'watchful']): bonus += 0.1 elif 'companion' in special_needs: if any(term in temperament for term in ['affectionate', 'gentle', 'loyal']): bonus += 0.1 # 計算包含懲罰的最終獎勵 final_bonus = bonus - penalties return max(-0.3, min(0.5, final_bonus)) # 允許負獎勵但限制範圍 def apply_intelligent_trait_matching(self, recommendations: List[Dict], user_input: str) -> List[Dict]: """基於增強關鍵字提取和數據庫挖掘應用智能特徵匹配""" try: # 從用戶輸入提取增強關鍵字 extracted_keywords = self._extract_enhanced_lifestyle_keywords(user_input) # 對每個推薦應用智能特徵匹配 enhanced_recommendations = [] for rec in recommendations: breed_name = rec['breed'].replace(' ', '_') # 獲取品種數據庫信息 breed_info = get_dog_description(breed_name) or {} # 計算智能特徵獎勵 intelligence_bonus = 0.0 trait_match_details = {} # 1. 智力匹配 if extracted_keywords.get('intelligence_preference'): intelligence_pref = extracted_keywords['intelligence_preference'][0] breed_desc = breed_info.get('Description', '').lower() if intelligence_pref == 'high': if any(word in breed_desc for word in ['intelligent', 'smart', 'clever', 'quick to learn', 'trainable']): intelligence_bonus += 0.05 trait_match_details['intelligence_match'] = 'High intelligence match detected' elif any(word in breed_desc for word in ['stubborn', 'independent', 'difficult']): intelligence_bonus -= 0.02 trait_match_details['intelligence_warning'] = 'May be challenging to train' elif intelligence_pref == 'independent': if any(word in breed_desc for word in ['independent', 'stubborn', 'strong-willed']): intelligence_bonus += 0.03 trait_match_details['independence_match'] = 'Independent nature match' # 2. 美容偏好匹配 if extracted_keywords.get('grooming_preference'): grooming_pref = extracted_keywords['grooming_preference'][0] breed_grooming = breed_info.get('Grooming Needs', '').lower() if grooming_pref == 'low' and 'low' in breed_grooming: intelligence_bonus += 0.03 trait_match_details['grooming_match'] = 'Low maintenance grooming match' elif grooming_pref == 'high' and 'high' in breed_grooming: intelligence_bonus += 0.03 trait_match_details['grooming_match'] = 'High maintenance grooming match' elif grooming_pref == 'low' and 'high' in breed_grooming: intelligence_bonus -= 0.04 trait_match_details['grooming_mismatch'] = 'High grooming needs may not suit preferences' # 3. 氣質偏好匹配 if extracted_keywords.get('temperament_preference'): temp_prefs = extracted_keywords['temperament_preference'] breed_temperament = breed_info.get('Temperament', '').lower() breed_desc = breed_info.get('Description', '').lower() temp_text = (breed_temperament + ' ' + breed_desc).lower() for temp_pref in temp_prefs: if temp_pref == 'gentle' and any(word in temp_text for word in ['gentle', 'calm', 'peaceful', 'mild']): intelligence_bonus += 0.04 trait_match_details['temperament_match'] = f'Gentle temperament match: {temp_pref}' elif temp_pref == 'playful' and any(word in temp_text for word in ['playful', 'energetic', 'lively', 'fun']): intelligence_bonus += 0.04 trait_match_details['temperament_match'] = f'Playful temperament match: {temp_pref}' elif temp_pref == 'protective' and any(word in temp_text for word in ['protective', 'guard', 'alert', 'watchful']): intelligence_bonus += 0.04 trait_match_details['temperament_match'] = f'Protective temperament match: {temp_pref}' elif temp_pref == 'friendly' and any(word in temp_text for word in ['friendly', 'social', 'outgoing', 'people']): intelligence_bonus += 0.04 trait_match_details['temperament_match'] = f'Friendly temperament match: {temp_pref}' # 4. 經驗水平匹配 if extracted_keywords.get('experience_level'): exp_level = extracted_keywords['experience_level'][0] breed_desc = breed_info.get('Description', '').lower() if exp_level == 'beginner': # 為初學者偏愛易於處理的品種 if any(word in breed_desc for word in ['easy', 'gentle', 'good for beginners', 'family', 'calm']): intelligence_bonus += 0.06 trait_match_details['beginner_friendly'] = 'Good choice for first-time owners' elif any(word in breed_desc for word in ['challenging', 'dominant', 'requires experience', 'strong-willed']): intelligence_bonus -= 0.08 trait_match_details['experience_warning'] = 'May be challenging for first-time owners' elif exp_level == 'advanced': # 高級用戶可以處理更具挑戰性的品種 if any(word in breed_desc for word in ['working', 'requires experience', 'intelligent', 'strong']): intelligence_bonus += 0.03 trait_match_details['advanced_suitable'] = 'Good match for experienced owners' # 5. 壽命偏好匹配 if extracted_keywords.get('lifespan_preference'): lifespan_pref = extracted_keywords['lifespan_preference'][0] breed_lifespan = breed_info.get('Lifespan', '10-12 years') try: import re years = re.findall(r'\d+', breed_lifespan) if years: avg_years = sum(int(y) for y in years) / len(years) if lifespan_pref == 'long' and avg_years >= 13: intelligence_bonus += 0.02 trait_match_details['longevity_match'] = f'Long lifespan match: {breed_lifespan}' elif lifespan_pref == 'healthy' and avg_years >= 12: intelligence_bonus += 0.02 trait_match_details['health_match'] = f'Healthy lifespan: {breed_lifespan}' except: pass # 將智力獎勵應用到總分 original_score = rec['overall_score'] enhanced_score = min(1.0, original_score + intelligence_bonus) # 創建包含特徵匹配詳細信息的增強推薦 enhanced_rec = rec.copy() enhanced_rec['overall_score'] = enhanced_score enhanced_rec['intelligence_bonus'] = intelligence_bonus enhanced_rec['trait_match_details'] = trait_match_details # 如果發生顯著增強，添加詳細說明 if abs(intelligence_bonus) > 0.02: enhancement_explanation = [] for detail_key, detail_value in trait_match_details.items(): enhancement_explanation.append(detail_value) if enhancement_explanation: current_explanation = enhanced_rec.get('explanation', '') enhanced_explanation = current_explanation + f" Enhanced matching: {'; '.join(enhancement_explanation)}" enhanced_rec['explanation'] = enhanced_explanation enhanced_recommendations.append(enhanced_rec) # 按增強總分重新排序 enhanced_recommendations.sort(key=lambda x: x['overall_score'], reverse=True) # 更新排名 for i, rec in enumerate(enhanced_recommendations): rec['rank'] = i + 1 print(f"Applied intelligent trait matching with average bonus: {sum(r['intelligence_bonus'] for r in enhanced_recommendations) / len(enhanced_recommendations):.3f}") return enhanced_recommendations except Exception as e: print(f"Error in intelligent trait matching: {str(e)}") # 如果特徵匹配失敗，返回原始推薦 return recommendations def _extract_enhanced_lifestyle_keywords(self, user_input: str) -> Dict[str, List[str]]: """提取增強的生活方式關鍵字（用於智能特徵匹配）""" keywords = { 'intelligence_preference': [], 'grooming_preference': [], 'temperament_preference': [], 'experience_level': [], 'lifespan_preference': [] } text = user_input.lower() # 智力偏好檢測 smart_terms = ['smart', 'intelligent', 'clever', 'bright', 'quick learner', 'easy to train', 'trainable', 'genius', 'brilliant'] independent_terms = ['independent', 'stubborn', 'strong-willed', 'less trainable', 'thinks for themselves'] if any(term in text for term in smart_terms): keywords['intelligence_preference'].append('high') if any(term in text for term in independent_terms): keywords['intelligence_preference'].append('independent') # 美容偏好檢測 low_grooming_terms = ['low grooming', 'minimal grooming', 'easy care', 'wash and wear', 'no grooming', 'simple coat'] high_grooming_terms = ['high grooming', 'professional grooming', 'lots of care', 'high maintenance coat', 'daily brushing', 'regular grooming'] if any(term in text for term in low_grooming_terms): keywords['grooming_preference'].append('low') if any(term in text for term in high_grooming_terms): keywords['grooming_preference'].append('high') # 氣質偏好檢測 gentle_terms = ['gentle', 'calm', 'peaceful', 'laid back', 'chill', 'mellow', 'docile'] playful_terms = ['playful', 'energetic', 'fun', 'active personality', 'lively', 'spirited', 'bouncy'] protective_terms = ['protective', 'guard', 'watchdog', 'alert', 'vigilant', 'defensive'] friendly_terms = ['friendly', 'social', 'outgoing', 'loves people', 'sociable', 'gregarious'] if any(term in text for term in gentle_terms): keywords['temperament_preference'].append('gentle') if any(term in text for term in playful_terms): keywords['temperament_preference'].append('playful') if any(term in text for term in protective_terms): keywords['temperament_preference'].append('protective') if any(term in text for term in friendly_terms): keywords['temperament_preference'].append('friendly') # 經驗水平檢測 beginner_terms = ['first time', 'beginner', 'new to dogs', 'never had', 'novice', 'inexperienced'] advanced_terms = ['experienced', 'advanced', 'dog expert', 'many dogs before', 'professional', 'seasoned'] if any(term in text for term in beginner_terms): keywords['experience_level'].append('beginner') if any(term in text for term in advanced_terms): keywords['experience_level'].append('advanced') # 壽命偏好檢測 long_lived_terms = ['long lived', 'long lifespan', 'live long', 'many years', '15+ years', 'longevity'] healthy_terms = ['healthy breed', 'few health issues', 'robust', 'hardy', 'strong constitution'] if any(term in text for term in long_lived_terms): keywords['lifespan_preference'].append('long') if any(term in text for term in healthy_terms): keywords['lifespan_preference'].append('healthy') return keywords def calculate_enhanced_matching_score(self, breed: str, breed_info: dict, user_description: str, base_similarity: float) -> dict: """計算增強的匹配分數，基於用戶描述和品種特性""" try: user_desc = user_description.lower() # 分析用戶需求 space_requirements = self._analyze_space_requirements(user_desc) exercise_requirements = self._analyze_exercise_requirements(user_desc) noise_requirements = self._analyze_noise_requirements(user_desc) size_requirements = self._analyze_size_requirements(user_desc) family_requirements = self._analyze_family_requirements(user_desc) # 獲取品種特性 breed_size = breed_info.get('Size', '').lower() breed_exercise = breed_info.get('Exercise Needs', '').lower() breed_noise = breed_noise_info.get(breed, {}).get('noise_level', 'moderate').lower() breed_temperament = breed_info.get('Temperament', '').lower() breed_good_with_children = breed_info.get('Good with Children', '').lower() # 計算各維度匹配分數 dimension_scores = {} # 空間匹配 (30% 權重) space_score = self._calculate_space_compatibility(space_requirements, breed_size, breed_exercise) dimension_scores['space'] = space_score # 運動需求匹配 (25% 權重) exercise_score = self._calculate_exercise_compatibility(exercise_requirements, breed_exercise) dimension_scores['exercise'] = exercise_score # 噪音匹配 (20% 權重) noise_score = self._calculate_noise_compatibility(noise_requirements, breed_noise) dimension_scores['noise'] = noise_score # 體型匹配 (15% 權重) size_score = self._calculate_size_compatibility(size_requirements, breed_size) dimension_scores['grooming'] = min(0.9, base_similarity + 0.1) # 美容需求基於語意相似度 # 家庭相容性 (10% 權重) family_score = self._calculate_family_compatibility(family_requirements, breed_good_with_children, breed_temperament) dimension_scores['family'] = family_score dimension_scores['experience'] = min(0.9, base_similarity + 0.05) # 經驗需求基於語意相似度 # 應用硬約束過濾 constraint_penalty = self._apply_hard_constraints_enhanced(user_desc, breed_info) # 計算加權總分 - 精確化維度權重配置 # 根據指導建議重新平衡維度權重 weighted_score = ( space_score * 0.30 + # 空間相容性（降低5%） exercise_score * 0.28 + # 運動需求匹配（降低2%） noise_score * 0.18 + # 噪音控制（提升3%） family_score * 0.12 + # 家庭相容性（提升2%） size_score * 0.08 + # 體型匹配（降低2%） min(0.9, base_similarity + 0.1) * 0.04 # 護理需求（新增獨立權重） ) # 優化完美匹配獎勵機制 - 降低觸發門檻並增加層次 perfect_match_bonus = 0.0 if space_score >= 0.88 and exercise_score >= 0.88 and noise_score >= 0.85: perfect_match_bonus = 0.08 # 卓越匹配獎勵 elif space_score >= 0.82 and exercise_score >= 0.82 and noise_score >= 0.75: perfect_match_bonus = 0.04 # 優秀匹配獎勵 elif space_score >= 0.75 and exercise_score >= 0.75: perfect_match_bonus = 0.02 # 良好匹配獎勵 # 結合語意相似度與維度匹配 - 調整為75%維度匹配 25%語義相似度 base_combined_score = (weighted_score * 0.75 + base_similarity * 0.25) + perfect_match_bonus # 應用漸進式約束懲罰，但確保基礎分數保障 raw_final_score = base_combined_score + constraint_penalty # 實施動態分數保障機制 - 提升至40-42%基礎分數 # 根據品種特性動態調整基礎分數 base_guaranteed_score = 0.42 # 提升基礎保障分數 # 特殊品種基礎分數調整 high_adaptability_breeds = ['French_Bulldog', 'Pug', 'Golden_Retriever', 'Labrador_Retriever'] if any(breed in breed for breed in high_adaptability_breeds): base_guaranteed_score = 0.45 # 高適應性品種更高基礎分數 # 動態分數分佈優化 if raw_final_score >= base_guaranteed_score: # 對於高分品種，實施適度壓縮避免過度集中 if raw_final_score > 0.85: compression_factor = 0.92 # 輕度壓縮高分 final_score = 0.85 + (raw_final_score - 0.85) * compression_factor else: final_score = raw_final_score final_score = min(0.93, final_score) # 降低最高分數限制 else: # 對於低分品種，使用改進的保障機制 normalized_raw_score = max(0.15, raw_final_score) # 基礎保障75% + 實際計算25%，保持一定區分度 final_score = base_guaranteed_score * 0.75 + normalized_raw_score * 0.25 final_score = max(base_guaranteed_score, min(0.93, final_score)) lifestyle_bonus = max(0.0, weighted_score - base_similarity) return { 'final_score': final_score, 'weighted_score': weighted_score, 'lifestyle_bonus': lifestyle_bonus, 'dimension_scores': dimension_scores, 'constraint_penalty': constraint_penalty } except Exception as e: print(f"Error in enhanced matching calculation for {breed}: {str(e)}") return { 'final_score': base_similarity, 'weighted_score': base_similarity, 'lifestyle_bonus': 0.0, 'dimension_scores': { 'space': base_similarity * 0.9, 'exercise': base_similarity * 0.85, 'grooming': base_similarity * 0.8, 'experience': base_similarity * 0.75, 'noise': base_similarity * 0.7, 'family': base_similarity * 0.65 }, 'constraint_penalty': 0.0 } def _analyze_space_requirements(self, user_desc: str) -> dict: """分析空間需求 - 增強中等活動量識別""" requirements = {'type': 'unknown', 'size': 'medium', 'importance': 0.5} if any(word in user_desc for word in ['apartment', 'small apartment', 'small space', 'condo', 'flat']): requirements['type'] = 'apartment' requirements['size'] = 'small' requirements['importance'] = 0.95 # 提高重要性 elif any(word in user_desc for word in ['medium-sized house', 'medium house', 'townhouse']): requirements['type'] = 'medium_house' requirements['size'] = 'medium' requirements['importance'] = 0.8 # 中等活動量用戶的特殊標記 elif any(word in user_desc for word in ['large house', 'big house', 'yard', 'garden', 'large space', 'backyard']): requirements['type'] = 'house' requirements['size'] = 'large' requirements['importance'] = 0.7 return requirements def _analyze_exercise_requirements(self, user_desc: str) -> dict: """分析運動需求 - 增強中等活動量識別""" requirements = {'level': 'moderate', 'importance': 0.5} # 低運動量識別 if any(word in user_desc for word in ["don't exercise", "don't exercise much", "low exercise", "minimal", "lazy", "not active"]): requirements['level'] = 'low' requirements['importance'] = 0.95 # 中等運動量的精確識別 elif any(phrase in user_desc for phrase in ['30 minutes', 'half hour', 'moderate', 'balanced', 'walk about']): if 'walk' in user_desc or 'daily' in user_desc: requirements['level'] = 'moderate' requirements['importance'] = 0.85 # 中等活動量的特殊標記 # 高運動量識別 elif any(word in user_desc for word in ['active', 'hiking', 'outdoor activities', 'running', 'outdoors', 'love hiking']): requirements['level'] = 'high' requirements['importance'] = 0.9 return requirements def _analyze_noise_requirements(self, user_desc: str) -> dict: """分析噪音需求""" requirements = {'tolerance': 'medium', 'importance': 0.5} if any(word in user_desc for word in ['quiet', 'no bark', "won't bark", "doesn't bark", 'silent', 'peaceful']): requirements['tolerance'] = 'low' requirements['importance'] = 0.9 elif any(word in user_desc for word in ['loud', 'barking ok', 'noise ok']): requirements['tolerance'] = 'high' requirements['importance'] = 0.7 return requirements def _analyze_size_requirements(self, user_desc: str) -> dict: """分析體型需求""" requirements = {'preferred': 'any', 'importance': 0.5} if any(word in user_desc for word in ['small', 'tiny', 'little', 'lap dog', 'compact']): requirements['preferred'] = 'small' requirements['importance'] = 0.8 elif any(word in user_desc for word in ['large', 'big', 'giant']): requirements['preferred'] = 'large' requirements['importance'] = 0.8 return requirements def _analyze_family_requirements(self, user_desc: str) -> dict: """分析家庭需求""" requirements = {'children': False, 'importance': 0.3} if any(word in user_desc for word in ['children', 'kids', 'family', 'child']): requirements['children'] = True requirements['importance'] = 0.8 return requirements def _calculate_space_compatibility(self, space_req: dict, breed_size: str, breed_exercise: str) -> float: """計算空間相容性分數 - 增強中等活動量處理""" if space_req['type'] == 'apartment': if 'small' in breed_size or 'toy' in breed_size: base_score = 0.95 elif 'medium' in breed_size: if 'low' in breed_exercise: base_score = 0.75 else: base_score = 0.45 # 降低中型犬在公寓的分數 elif 'large' in breed_size: base_score = 0.05 # 大型犬極度不適合公寓 elif 'giant' in breed_size: base_score = 0.01 # 超大型犬完全不適合公寓 else: base_score = 0.7 elif space_req['type'] == 'medium_house': # 中型房屋的特殊處理 - 適合中等活動量用戶 if 'small' in breed_size or 'toy' in breed_size: base_score = 0.9 elif 'medium' in breed_size: base_score = 0.95 # 中型犬在中型房屋很適合 elif 'large' in breed_size: if 'moderate' in breed_exercise or 'low' in breed_exercise: base_score = 0.8 # 低運動量大型犬還可以 else: base_score = 0.6 # 高運動量大型犬不太適合 elif 'giant' in breed_size: base_score = 0.3 # 超大型犬在中型房屋不太適合 else: base_score = 0.85 else: # 大型房屋的情況 if 'small' in breed_size or 'toy' in breed_size: base_score = 0.85 elif 'medium' in breed_size: base_score = 0.9 elif 'large' in breed_size or 'giant' in breed_size: base_score = 0.95 else: base_score = 0.8 return min(0.95, base_score) def _calculate_exercise_compatibility(self, exercise_req: dict, breed_exercise: str) -> float: """計算運動需求相容性分數 - 增強中等活動量處理""" if exercise_req['level'] == 'low': if 'low' in breed_exercise or 'minimal' in breed_exercise: return 0.95 elif 'moderate' in breed_exercise: return 0.5 # 降低不匹配分數 elif 'high' in breed_exercise: return 0.1 # 進一步降低高運動需求的匹配 else: return 0.7 elif exercise_req['level'] == 'high': if 'high' in breed_exercise: return 0.95 elif 'moderate' in breed_exercise: return 0.8 elif 'low' in breed_exercise: return 0.6 else: return 0.7 else: # moderate - 中等活動量的精確處理 if 'moderate' in breed_exercise: return 0.95 # 完美匹配 elif 'low' in breed_exercise: return 0.85 # 低運動需求的品種對中等活動量用戶也不錯 elif 'high' in breed_exercise: return 0.5 # 中等活動量用戶不太適合高運動需求品種 else: return 0.75 return 0.6 def _calculate_noise_compatibility(self, noise_req: dict, breed_noise: str) -> float: """計算噪音相容性分數，更好處理複合等級""" breed_noise_lower = breed_noise.lower() if noise_req['tolerance'] == 'low': if 'low' in breed_noise_lower and 'moderate' not in breed_noise_lower: return 0.95 # 純低噪音 elif 'low-moderate' in breed_noise_lower or 'low to moderate' in breed_noise_lower: return 0.8 # 低到中等噪音，還可接受 elif breed_noise_lower in ['moderate']: return 0.4 # 中等噪音有些問題 elif 'high' in breed_noise_lower: return 0.1 # 高噪音不適合 else: return 0.6 # 未知噪音水平，保守估計 elif noise_req['tolerance'] == 'high': if 'high' in breed_noise_lower: return 0.9 elif 'moderate' in breed_noise_lower: return 0.85 elif 'low' in breed_noise_lower: return 0.8 # 安靜犬對高容忍度的人也很好 else: return 0.8 else: # moderate tolerance if 'moderate' in breed_noise_lower: return 0.9 elif 'low' in breed_noise_lower: return 0.85 elif 'high' in breed_noise_lower: return 0.6 else: return 0.75 return 0.7 def _calculate_size_compatibility(self, size_req: dict, breed_size: str) -> float: """計算體型相容性分數""" if size_req['preferred'] == 'small': if any(word in breed_size for word in ['small', 'toy', 'tiny']): return 0.9 elif 'medium' in breed_size: return 0.6 else: return 0.3 elif size_req['preferred'] == 'large': if any(word in breed_size for word in ['large', 'giant']): return 0.9 elif 'medium' in breed_size: return 0.7 else: return 0.4 return 0.7 # 無特別偏好 def _calculate_family_compatibility(self, family_req: dict, good_with_children: str, temperament: str) -> float: """計算家庭相容性分數""" if family_req['children']: if 'yes' in good_with_children.lower(): return 0.9 elif any(word in temperament for word in ['gentle', 'patient', 'friendly']): return 0.8 elif 'no' in good_with_children.lower(): return 0.2 else: return 0.6 return 0.7 def _apply_hard_constraints_enhanced(self, user_desc: str, breed_info: dict) -> float: """應用品種特性感知的動態懲罰機制""" penalty = 0.0 # 建立懲罰衰減係數和補償機制 penalty_decay_factor = 0.7 breed_adaptability_bonus = 0.0 breed_size = breed_info.get('Size', '').lower() breed_exercise = breed_info.get('Exercise Needs', '').lower() breed_name = breed_info.get('Breed', '').replace(' ', '_') # 公寓空間約束 - 品種特性感知懲罰機制 if 'apartment' in user_desc or 'small apartment' in user_desc: if 'giant' in breed_size: base_penalty = -0.35 # 減少基礎懲罰 # 特定品種適應性補償 adaptable_giants = ['Mastiff', 'Great Dane'] # 相對安靜的巨型犬 if any(adapt_breed in breed_name for adapt_breed in adaptable_giants): breed_adaptability_bonus += 0.08 penalty += base_penalty * penalty_decay_factor elif 'large' in breed_size: base_penalty = -0.25 # 減少大型犬懲罰 # 適合公寓的大型犬補償 apartment_friendly_large = ['Greyhound', 'Great_Dane'] if any(apt_breed in breed_name for apt_breed in apartment_friendly_large): breed_adaptability_bonus += 0.06 penalty += base_penalty * penalty_decay_factor elif 'medium' in breed_size and 'high' in breed_exercise: penalty += -0.15 * penalty_decay_factor # 進一步減少懲罰 # 運動需求不匹配 - 品種特性感知懲罰機制 if any(phrase in user_desc for phrase in ["don't exercise", "not active", "low exercise", "don't exercise much"]): if 'high' in breed_exercise: base_penalty = -0.28 # 減少基礎懲罰 # 低維護高運動犬種補償 adaptable_high_energy = ['Greyhound', 'Whippet'] # 運動爆發型，平時安靜 if any(adapt_breed in breed_name for adapt_breed in adaptable_high_energy): breed_adaptability_bonus += 0.10 penalty += base_penalty * penalty_decay_factor elif 'moderate' in breed_exercise: penalty += -0.08 * penalty_decay_factor # 進一步減少懲罰 # 噪音控制需求不匹配 - 品種特性感知懲罰機制 if any(phrase in user_desc for phrase in ['quiet', "won't bark", "doesn't bark", "silent"]): breed_noise = breed_noise_info.get(breed_name, {}).get('noise_level', 'moderate').lower() if 'high' in breed_noise: base_penalty = -0.18 # 減少基礎懲罰 # 訓練性良好的高噪音品種補償 trainable_vocal_breeds = ['German_Shepherd', 'Golden_Retriever'] if any(train_breed in breed_name for train_breed in trainable_vocal_breeds): breed_adaptability_bonus += 0.05 penalty += base_penalty * penalty_decay_factor elif 'moderate' in breed_noise and 'low' not in breed_noise: penalty += -0.05 * penalty_decay_factor # 體型偏好不匹配 - 漸進式懲罰 if any(phrase in user_desc for phrase in ['small', 'tiny', 'little']): if 'giant' in breed_size: penalty -= 0.35 # 超大型犬懲罰 elif 'large' in breed_size: penalty -= 0.20 # 大型犬懲罰 # 中等活動量用戶的特殊約束處理 - 漸進式懲罰 moderate_activity_terms = ['30 minutes', 'half hour', 'moderate', 'balanced', 'medium-sized house'] if any(term in user_desc for term in moderate_activity_terms): # 超大型犬對中等活動量用戶的適度懲罰 giant_breeds = ['Saint Bernard', 'Tibetan Mastiff', 'Great Dane', 'Mastiff', 'Newfoundland'] if any(giant in breed_name for giant in giant_breeds) or 'giant' in breed_size: penalty -= 0.35 # 適度懲罰，不完全排除 # 中型房屋 + 超大型犬的額外考量 if 'medium-sized house' in user_desc and any(giant in breed_name for giant in giant_breeds): if not any(high_activity in user_desc for high_activity in ['hiking', 'running', 'active', 'outdoor activities']): penalty -= 0.15 # 輕度額外懲罰 # 30分鐘散步對極高運動需求品種的懲罰 if any(term in user_desc for term in ['30 minutes', 'half hour']) and 'walk' in user_desc: high_energy_breeds = ['Siberian Husky', 'Border Collie', 'Jack Russell Terrier', 'Weimaraner'] if any(he_breed in breed_name for he_breed in high_energy_breeds) and 'high' in breed_exercise: penalty -= 0.25 # 適度懲罰極高運動需求品種 # 添加特殊品種適應性補償機制 # 對於邊界適配品種，給予適度補償 boundary_adaptable_breeds = { 'Italian_Greyhound': 0.08, # 安靜、低維護的小型犬 'Boston_Bull': 0.06, # 適應性強的小型犬 'Havanese': 0.05, # 友好適應的小型犬 'Silky_terrier': 0.04, # 安靜的玩具犬 'Basset': 0.07 # 低能量但友好的中型犬 } if breed_name in boundary_adaptable_breeds: breed_adaptability_bonus += boundary_adaptable_breeds[breed_name] # 應用品種適應性補償並設置懲罰上限 final_penalty = penalty + breed_adaptability_bonus # 限制最大懲罰，避免單一約束主導評分 final_penalty = max(-0.4, final_penalty) return final_penalty def get_breed_characteristics_enhanced(self, breed: str) -> Dict[str, Any]: """獲取品種特徵""" breed_info = get_dog_description(breed) if not breed_info: return {} characteristics = { 'size': breed_info.get('Size', 'Unknown'), 'temperament': breed_info.get('Temperament', ''), 'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'), 'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'), 'good_with_children': breed_info.get('Good with Children', 'Unknown'), 'lifespan': breed_info.get('Lifespan', '10-12 years'), 'description': breed_info.get('Description', '') } # 添加噪音資訊 noise_info = breed_noise_info.get(breed, {}) characteristics['noise_level'] = noise_info.get('noise_level', 'moderate') return characteristics def get_breed_info_from_standardized(self, standardized_info) -> Dict[str, Any]: """將標準化品種信息轉換為字典格式""" try: size_map = {1: 'Tiny', 2: 'Small', 3: 'Medium', 4: 'Large', 5: 'Giant'} exercise_map = {1: 'Low', 2: 'Moderate', 3: 'High', 4: 'Very High'} care_map = {1: 'Low', 2: 'Moderate', 3: 'High'} return { 'Size': size_map.get(standardized_info.size_category, 'Medium'), 'Exercise Needs': exercise_map.get(standardized_info.exercise_level, 'Moderate'), 'Grooming Needs': care_map.get(standardized_info.care_complexity, 'Moderate'), 'Good with Children': 'Yes' if standardized_info.child_compatibility >= 0.8 else 'No' if standardized_info.child_compatibility <= 0.2 else 'Unknown', 'Temperament': 'Varies by individual', 'Lifespan': '10-12 years', 'Description': f'A {size_map.get(standardized_info.size_category, "medium")} sized breed' } except Exception as e: print(f"Error converting standardized info: {str(e)}") return {} def get_fallback_recommendations(self, top_k: int = 15) -> List[Dict[str, Any]]: """當增強系統失敗時獲取備用推薦""" try: safe_breeds = [ ('Labrador Retriever', 0.85), ('Golden Retriever', 0.82), ('Cavalier King Charles Spaniel', 0.80), ('French Bulldog', 0.78), ('Boston Terrier', 0.76), ('Bichon Frise', 0.74), ('Pug', 0.72), ('Cocker Spaniel', 0.70) ] recommendations = [] for i, (breed, score) in enumerate(safe_breeds[:top_k]): breed_info = get_dog_description(breed.replace(' ', '_')) or {} recommendation = { 'breed': breed, 'rank': i + 1, 'overall_score': score, 'final_score': score, 'semantic_score': score * 0.8, 'comparative_bonus': 0.0, 'lifestyle_bonus': 0.0, 'size': breed_info.get('Size', 'Unknown'), 'temperament': breed_info.get('Temperament', ''), 'exercise_needs': breed_info.get('Exercise Needs', 'Moderate'), 'grooming_needs': breed_info.get('Grooming Needs', 'Moderate'), 'good_with_children': breed_info.get('Good with Children', 'Yes'), 'lifespan': breed_info.get('Lifespan', '10-12 years'), 'description': breed_info.get('Description', ''), 'search_type': 'fallback' } recommendations.append(recommendation) return recommendations except Exception as e: print(f"Error generating fallback recommendations: {str(e)}") return []