-- coding: utf-8 --
"""
简化版AI志愿推荐引擎
功能：基于协同过滤 + 基于内容的混合推荐
"""
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from collections import defaultdict

class SimpleVolunteerRecommender:
    """AI志愿助手推荐引擎简化版"""
    
    def __init__(self):
         模拟院校数据库：{院校ID: [特征向量，历年录取分数]}
        self.universities = {
            '清华计算机': {'features': [0.95, 0.90, 0.88], 'avg_score': 700},
            '北大计算机': {'features': [0.93, 0.92, 0.85], 'avg_score': 698},
            '北航计算机': {'features': [0.88, 0.85, 0.80], 'avg_score': 680},
            '北理工计算机': {'features': [0.85, 0.82, 0.78], 'avg_score': 672},
            '北交计算机': {'features': [0.80, 0.78, 0.75], 'avg_score': 660},
            '北工大计算机': {'features': [0.72, 0.70, 0.68], 'avg_score': 640},
        }
        
         用户历史交互记录（简化的行为矩阵）
        self.user_history = {
            'user1': ['清华计算机', '北航计算机'],
            'user2': ['北大计算机', '北交计算机', '北工大计算机'],
        }
    
    def content_based_recommend(self, user_preference_vec, top_k=3):
        """
        基于内容的推荐：根据用户偏好特征向量匹配院校
        适用场景：冷启动、新用户无历史行为时
        """
        scores = []
        for uni_name, info in self.universities.items():
            features = np.array(info['features'])
             计算余弦相似度
            sim = cosine_similarity([user_preference_vec], [features])[0][0]
            scores.append((uni_name, sim))
        
        scores.sort(key=lambda x: x[1], reverse=True)
        return scores[:top_k]
    
    def collaborative_filtering_recommend(self, target_user, top_k=3):
        """
        协同过滤推荐：基于用户相似度
        适用场景：有历史行为数据时
        """
        if target_user not in self.user_history:
            return None   冷启动问题
        
         获取目标用户已选院校集合
        target_set = set(self.user_history[target_user])
        
         计算其他用户的相似度（Jaccard相似度）
        similarities = {}
        for user, items in self.user_history.items():
            if user == target_user:
                continue
            user_set = set(items)
            jaccard = len(target_set & user_set) / len(target_set | user_set) if len(target_set | user_set) > 0 else 0
            similarities[user] = jaccard
        
        if not similarities:
            return None
        
         找到最相似的用户
        most_similar_user = max(similarities, key=similarities.get)
        
         推荐相似用户选择但目标用户未选的院校
        similar_user_set = set(self.user_history[most_similar_user])
        recommendations = similar_user_set - target_set
        return list(recommendations)[:top_k]
    
    def hybrid_recommend(self, user_preference_vec, target_user=None, top_k=3):
        """
        混合推荐：融合协同过滤和基于内容的推荐
        解决协同过滤的冷启动问题
        """
         1. 优先尝试协同过滤
        cf_result = None
        if target_user:
            cf_result = self.collaborative_filtering_recommend(target_user, top_k)
        
         2. 如果协同过滤无结果（冷启动），使用基于内容推荐
        if not cf_result:
            cf_result = [item[0] for item in self.content_based_recommend(user_preference_vec, top_k)]
        
         3. 录取概率计算（简化的规则评分）
        result_with_prob = []
        for uni in cf_result:
            base_score = self.universities[uni]['avg_score']
             根据用户分数动态计算录取概率（实际应用中需接入XGBoost模型）
            prob = min(0.95, max(0.05, 1.0 / (1 + np.exp((base_score - 650) / 20))))
            result_with_prob.append({
                'university': uni,
                'probability': round(prob  100, 2),
                'level': self._risk_level(prob)
            })
        
        return result_with_prob
    
    def _risk_level(self, prob):
        """根据录取概率划分风险等级"""
        if prob >= 0.7:
            return '稳'
        elif prob >= 0.4:
            return '冲'
        else:
            return '保'


 ========== 使用示例 ==========
if __name__ == '__main__':
    recommender = SimpleVolunteerRecommender()
    
     场景1：新用户（冷启动），使用基于内容的推荐
    print("="  50)
    print("【场景1】新用户冷启动 → 基于内容的推荐")
    print("用户偏好特征：[0.85, 0.80, 0.78]（偏向高排名+强科研）")
    result = recommender.content_based_recommend([0.85, 0.80, 0.78], top_k=3)
    for uni, score in result:
        print(f"  ✅ {uni} | 匹配度: {score:.3f}")
    
     场景2：混合推荐（协同过滤 + 内容推荐）
    print("\n" + "="  50)
    print("【场景2】混合推荐 → 协同过滤+录取概率")
    result = recommender.hybrid_recommend([0.85, 0.80, 0.78], target_user='user1', top_k=3)
    for item in result:
        print(f"  🎯 {item['university']} | 录取概率: {item['probability']}% | 等级: {item['level']}")