Spaces:
Running
on
Zero
Running
on
Zero
| 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 [] | |