构建AI智能体：潜藏秩序的发现：隐因子视角下的SVD推荐知识提取与机理阐释

import numpy as np
import pandas as pd
from scipy.sparse.linalg import svds
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import seaborn as sns

# 设置中文字体（用于可视化）
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

print(" 开始构建可解释的SVD推荐系统...")

# 模拟一个用户-物品评分矩阵（在实际中使用pd.read_csv()加载真实数据如MovieLens）
def create_sample_rating_data():
    """创建一个模拟的评分数据集"""
    np.random.seed(42)
    n_users = 100
    n_items = 50
    
    # 生成一个低秩矩阵模拟真实用户偏好，加上一些噪声
    latent_user = np.random.randn(n_users, 3)
    latent_item = np.random.randn(n_items, 3)
    true_ratings = latent_user @ latent_item.T  # 真实的低秩结构
    
    # 添加噪声并转换为1-5的评分
    noise = np.random.randn(n_users, n_items) * 0.5
    ratings = true_ratings + noise
    ratings = (ratings - ratings.min()) / (ratings.max() - ratings.min())  # 归一化到0-1
    ratings = ratings * 4 + 1  # 缩放到1-5分
    
    # 创建稀疏矩阵（只有30%的评分是已知的）
    mask = np.random.random((n_users, n_items)) < 0.3
    sparse_ratings = np.where(mask, ratings, np.nan)
    
    # 创建DataFrame
    users = [f'User_{i}' for i in range(n_users)]
    items = [f'Movie_{i}' for i in range(n_items)]
    
    ratings_df = pd.DataFrame(sparse_ratings, index=users, columns=items)
    return ratings_df

# 加载数据
ratings_df = create_sample_rating_data()
print(f" 数据形状: {ratings_df.shape}")
print(f"数据稀疏度: {(1 - ratings_df.count().sum() / (ratings_df.shape[0] * ratings_df.shape[1])):.2%}")
print("\n评分矩阵样例:")
print(ratings_df.iloc[:5, :5])

class InterpretableSVDRecommender:
    """可解释的SVD推荐器"""
    
    def __init__(self, n_factors=5):
        self.n_factors = n_factors
        self.user_factors = None
        self.item_factors = None
        self.singular_values = None
        self.user_ids = None
        self.item_ids = None
        self.global_bias = None
        self.user_biases = None
        self.item_biases = None
        
    def fit(self, ratings_df):
        """训练SVD模型"""
        print(f"\n 开始SVD分解，隐因子数: {self.n_factors}")
        
        self.user_ids = ratings_df.index
        self.item_ids = ratings_df.columns
        
        # 1. 填充缺失值（用全局平均或用户平均）
        filled_ratings = ratings_df.copy()
        self.global_bias = np.nanmean(ratings_df.values)
        filled_ratings = filled_ratings.fillna(self.global_bias)
        
        # 2. 计算偏置 (可选，让SVD更专注于学习交互部分)
        self.user_biases = filled_ratings.mean(axis=1) - self.global_bias
        self.item_biases = filled_ratings.mean(axis=0) - self.global_bias
        
        # 偏置调整后的评分矩阵
        adjusted_ratings = filled_ratings.values - self.global_bias
        adjusted_ratings = (adjusted_ratings.T - self.user_biases.values).T
        adjusted_ratings = adjusted_ratings - self.item_biases.values
        
        # 3. 执行SVD
        U, sigma, Vt = svds(adjusted_ratings, k=self.n_factors)
        
        # 调整顺序（svds返回的奇异值是递增的，我们需要递减）
        idx = np.argsort(-sigma)
        self.singular_values = sigma[idx]
        self.user_factors = U[:, idx]
        self.item_factors = Vt[idx, :].T  # 转置回来，使得每行是一个物品的隐向量
        
        print(" SVD分解完成!")
        print(f"奇异值: {self.singular_values}")
        
        return self
    
    def predict_rating(self, user_id, item_id):
        """预测用户对物品的评分"""
        user_idx = list(self.user_ids).index(user_id)
        item_idx = list(self.item_ids).index(item_id)
        
        # 预测评分 = 全局偏置 + 用户偏置 + 物品偏置 + 用户隐向量 · 物品隐向量
        prediction = (self.global_bias + 
                     self.user_biases.iloc[user_idx] + 
                     self.item_biases.iloc[item_idx] +
                     self.user_factors[user_idx, :] @ self.item_factors[item_idx, :])
        
        # 限制在1-5分之间
        return np.clip(prediction, 1, 5)
    
    def recommend_for_user(self, user_id, top_n=5):
        """为用户生成Top-N推荐"""
        user_idx = list(self.user_ids).index(user_id)
        
        # 计算用户对所有物品的预测评分
        user_vector = self.user_factors[user_idx, :]
        all_predictions = (self.global_bias + 
                          self.user_biases.iloc[user_idx] + 
                          self.item_biases.values +
                          user_vector @ self.item_factors.T)
        
        # 创建结果DataFrame
        recommendations = pd.DataFrame({
            'item_id': self.item_ids,
            'predicted_rating': all_predictions
        })
        
        # 排序并返回Top-N
        return recommendations.sort_values('predicted_rating', ascending=False).head(top_n)

# 训练模型
recommender = InterpretableSVDRecommender(n_factors=5)
recommender.fit(ratings_df)

def analyze_latent_factors(recommender, item_names=None):
    """分析隐因子的语义含义"""
    print("\n" + "="*60)
    print(" 隐因子语义分析")
    print("="*60)
    
    item_factors_df = pd.DataFrame(
        recommender.item_factors,
        index=recommender.item_ids,
        columns=[f'Factor_{i}' for i in range(recommender.n_factors)]
    )
    
    # 分析每个因子最具代表性的物品（正向和负向）
    for factor in range(recommender.n_factors):
        print(f"\n 分析隐因子 {factor} (奇异值: {recommender.singular_values[factor]:.3f}):")
        
        # 找到在该因子上得分最高和最低的物品
        top_items = item_factors_df.nlargest(3, f'Factor_{factor}')
        bottom_items = item_factors_df.nsmallest(3, f'Factor_{factor}')
        
        print(f"  正向代表 (高权重):")
        for item_id, weight in top_items[f'Factor_{factor}'].items():
            print(f"    - {item_id}: {weight:.3f}")
            
        print(f"  负向代表 (低权重):")
        for item_id, weight in bottom_items[f'Factor_{factor}'].items():
            print(f"    - {item_id}: {weight:.3f}")
        
        # 尝试自动推断因子含义（在实际应用中，需要结合物品元数据）
        factor_range = top_items[f'Factor_{factor}'].mean() - bottom_items[f'Factor_{factor}'].mean()
        print(f"  因子强度: {factor_range:.3f}")
        
        # 基于代表性物品的名称模式，尝试自动标注（这里是模拟）
        possible_interpretations = [
            "制作规模/特效", "浪漫/情感深度", "喜剧/轻松程度", 
            "艺术性/导演风格", "年代感/经典程度"
        ]
        if factor < len(possible_interpretations):
            print(f"  推测语义: {possible_interpretations[factor]}")
    
    return item_factors_df

# 执行隐因子分析
item_factors_df = analyze_latent_factors(recommender)

def analyze_user_profile(recommender, user_id):
    """分析特定用户的隐因子画像"""
    print(f"\n 用户画像分析: {user_id}")
    print("-" * 40)
    
    user_idx = list(recommender.user_ids).index(user_id)
    user_factor_weights = recommender.user_factors[user_idx, :]
    
    user_profile = pd.DataFrame({
        'Factor': [f'Factor_{i}' for i in range(recommender.n_factors)],
        'Weight': user_factor_weights,
        'Importance': user_factor_weights * recommender.singular_values
    })
    
    user_profile = user_profile.sort_values('Importance', key=abs, ascending=False)
    
    print("用户的隐因子偏好 (按重要性排序):")
    for _, row in user_profile.iterrows():
        preference = "喜欢" if row['Weight'] > 0 else "不喜欢"
        print(f"  {row['Factor']}: {preference} (强度: {abs(row['Weight']):.3f})")
    
    return user_profile

# 分析示例用户
user_profile = analyze_user_profile(recommender, 'User_0')

def generate_explainable_recommendations(recommender, user_id, top_n=3):
    """生成带有解释的推荐"""
    print(f"\n 为 {user_id} 生成可解释的推荐:")
    print("-" * 50)
    
    # 获取推荐结果
    recommendations = recommender.recommend_for_user(user_id, top_n=top_n)
    user_profile = analyze_user_profile(recommender, user_id)
    
    user_idx = list(recommender.user_ids).index(user_id)
    user_factors = recommender.user_factors[user_idx, :]
    
    for _, rec in recommendations.iterrows():
        item_id = rec['item_id']
        item_idx = list(recommender.item_ids).index(item_id)
        item_factors = recommender.item_factors[item_idx, :]
        
        print(f"\n 推荐物品: {item_id} (预测评分: {rec['predicted_rating']:.2f})")
        print("   推荐理由:")
        
        # 计算每个因子对预测的贡献
        factor_contributions = user_factors * item_factors * recommender.singular_values
        
        # 只显示最重要的几个理由
        top_contributions = np.argsort(-np.abs(factor_contributions))[:2]
        
        for factor_idx in top_contributions:
            contribution = factor_contributions[factor_idx]
            user_weight = user_factors[factor_idx]
            item_weight = item_factors[factor_idx]
            
            if abs(contribution) > 0.1:  # 只显示显著贡献
                if user_weight > 0 and item_weight > 0:
                    reason = f"       • 您喜欢{get_factor_interpretation(factor_idx)}，而该物品在这方面很突出"
                elif user_weight < 0 and item_weight < 0:
                    reason = f"       • 您不喜欢{get_factor_interpretation(factor_idx)}，而该物品在这方面也很弱"
                elif user_weight > 0 and item_weight < 0:
                    reason = f"       • 虽然您喜欢{get_factor_interpretation(factor_idx)}，但该物品在这方面稍弱（其他方面很匹配）"
                else:
                    reason = f"       • 虽然您不喜欢{get_factor_interpretation(factor_idx)}，但该物品在这方面很突出（形成了良好互补）"
                
                print(reason)

def get_factor_interpretation(factor_idx):
    """获取因子的语义解释（在实际中应基于元数据分析）"""
    interpretations = [
        "大制作、特效震撼的电影",
        "浪漫深情、情感丰富的作品", 
        "轻松幽默的喜剧内容",
        "艺术性强、导演风格独特的影片",
        "经典怀旧、有年代感的电影"
    ]
    return interpretations[factor_idx] if factor_idx < len(interpretations) else f"特征{factor_idx}"

# 生成可解释的推荐
generate_explainable_recommendations(recommender, 'User_0', top_n=3)

def visualize_svd_insights(recommender, item_factors_df):
    """可视化SVD分析结果"""
    print("\n 生成可视化分析...")
    
    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
    
    # 1. 奇异值重要性（碎石图）
    axes[0, 0].plot(range(1, len(recommender.singular_values) + 1), 
                   recommender.singular_values, 'bo-')
    axes[0, 0].set_title('奇异值碎石图 (Scree Plot)')
    axes[0, 0].set_xlabel('隐因子')
    axes[0, 0].set_ylabel('奇异值')
    axes[0, 0].grid(True, alpha=0.3)
    
    # 2. 前两个隐因子的物品分布
    sample_items = np.random.choice(len(recommender.item_ids), 30, replace=False)
    sample_df = item_factors_df.iloc[sample_items]
    
    axes[0, 1].scatter(sample_df['Factor_0'], sample_df['Factor_1'], alpha=0.6)
    axes[0, 1].set_title('物品在隐空间中的分布 (Factor 0 vs Factor 1)')
    axes[0, 1].set_xlabel('隐因子 0 - 制作规模')
    axes[0, 1].set_ylabel('隐因子 1 - 浪漫程度')
    
    # 标注几个点
    for i, (idx, row) in enumerate(sample_df.iterrows()):
        if i % 5 == 0:  # 只标注部分点
            axes[0, 1].annotate(idx, (row['Factor_0'], row['Factor_1']), 
                               xytext=(5, 5), textcoords='offset points', fontsize=8)
    
    # 3. 用户隐因子分布热力图
    user_sample = recommender.user_factors[:20, :]  # 前20个用户
    im = axes[1, 0].imshow(user_sample, cmap='RdBu_r', aspect='auto')
    axes[1, 0].set_title('用户隐因子权重热力图')
    axes[1, 0].set_xlabel('隐因子')
    axes[1, 0].set_ylabel('用户')
    axes[1, 0].set_xticks(range(recommender.n_factors))
    axes[1, 0].set_xticklabels([f'F{i}' for i in range(recommender.n_factors)])
    plt.colorbar(im, ax=axes[1, 0])
    
    # 4. 因子贡献度分析
    user_idx = 0  # 分析第一个用户
    item_idx = 5  # 分析一个物品
    
    user_vec = recommender.user_factors[user_idx, :]
    item_vec = recommender.item_factors[item_idx, :]
    contributions = user_vec * item_vec * recommender.singular_values
    
    factors = [f'F{i}' for i in range(recommender.n_factors)]
    axes[1, 1].bar(factors, contributions, color=['red' if x < 0 else 'blue' for x in contributions])
    axes[1, 1].set_title(f'用户{user_idx}对物品{recommender.item_ids[item_idx]}的评分因子贡献')
    axes[1, 1].set_ylabel('贡献度')
    axes[1, 1].axhline(y=0, color='black', linestyle='-', alpha=0.3)
    
    plt.tight_layout()
    plt.show()

# 执行可视化
visualize_svd_insights(recommender, item_factors_df)

import numpy as np
import pandas as pd
from scipy.sparse.linalg import svds
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import seaborn as sns

# 设置中文字体（用于可视化）
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

print(" 开始构建可解释的SVD推荐系统...")

# 模拟一个用户-物品评分矩阵（在实际中使用pd.read_csv()加载真实数据如MovieLens）
def create_sample_rating_data():
    """创建一个模拟的评分数据集"""
    np.random.seed(42)
    n_users = 100
    n_items = 50
    
    # 生成一个低秩矩阵模拟真实用户偏好，加上一些噪声
    latent_user = np.random.randn(n_users, 3)
    latent_item = np.random.randn(n_items, 3)
    true_ratings = latent_user @ latent_item.T  # 真实的低秩结构
    
    # 添加噪声并转换为1-5的评分
    noise = np.random.randn(n_users, n_items) * 0.5
    ratings = true_ratings + noise
    ratings = (ratings - ratings.min()) / (ratings.max() - ratings.min())  # 归一化到0-1
    ratings = ratings * 4 + 1  # 缩放到1-5分
    
    # 创建稀疏矩阵（只有30%的评分是已知的）
    mask = np.random.random((n_users, n_items)) < 0.3
    sparse_ratings = np.where(mask, ratings, np.nan)
    
    # 创建DataFrame
    users = [f'User_{i}' for i in range(n_users)]
    items = [f'Movie_{i}' for i in range(n_items)]
    
    ratings_df = pd.DataFrame(sparse_ratings, index=users, columns=items)
    return ratings_df

# 加载数据
ratings_df = create_sample_rating_data()
print(f" 数据形状: {ratings_df.shape}")
print(f"数据稀疏度: {(1 - ratings_df.count().sum() / (ratings_df.shape[0] * ratings_df.shape[1])):.2%}")
print("\n评分矩阵样例:")
print(ratings_df.iloc[:5, :5])

class InterpretableSVDRecommender:
    """可解释的SVD推荐器"""
    
    def __init__(self, n_factors=5):
        self.n_factors = n_factors
        self.user_factors = None
        self.item_factors = None
        self.singular_values = None
        self.user_ids = None
        self.item_ids = None
        self.global_bias = None
        self.user_biases = None
        self.item_biases = None
        
    def fit(self, ratings_df):
        """训练SVD模型"""
        print(f"\n 开始SVD分解，隐因子数: {self.n_factors}")
        
        self.user_ids = ratings_df.index
        self.item_ids = ratings_df.columns
        
        # 1. 填充缺失值（用全局平均或用户平均）
        filled_ratings = ratings_df.copy()
        self.global_bias = np.nanmean(ratings_df.values)
        filled_ratings = filled_ratings.fillna(self.global_bias)
        
        # 2. 计算偏置 (可选，让SVD更专注于学习交互部分)
        self.user_biases = filled_ratings.mean(axis=1) - self.global_bias
        self.item_biases = filled_ratings.mean(axis=0) - self.global_bias
        
        # 偏置调整后的评分矩阵
        adjusted_ratings = filled_ratings.values - self.global_bias
        adjusted_ratings = (adjusted_ratings.T - self.user_biases.values).T
        adjusted_ratings = adjusted_ratings - self.item_biases.values
        
        # 3. 执行SVD
        U, sigma, Vt = svds(adjusted_ratings, k=self.n_factors)
        
        # 调整顺序（svds返回的奇异值是递增的，我们需要递减）
        idx = np.argsort(-sigma)
        self.singular_values = sigma[idx]
        self.user_factors = U[:, idx]
        self.item_factors = Vt[idx, :].T  # 转置回来，使得每行是一个物品的隐向量
        
        print(" SVD分解完成!")
        print(f"奇异值: {self.singular_values}")
        
        return self
    
    def predict_rating(self, user_id, item_id):
        """预测用户对物品的评分"""
        user_idx = list(self.user_ids).index(user_id)
        item_idx = list(self.item_ids).index(item_id)
        
        # 预测评分 = 全局偏置 + 用户偏置 + 物品偏置 + 用户隐向量 · 物品隐向量
        prediction = (self.global_bias + 
                     self.user_biases.iloc[user_idx] + 
                     self.item_biases.iloc[item_idx] +
                     self.user_factors[user_idx, :] @ self.item_factors[item_idx, :])
        
        # 限制在1-5分之间
        return np.clip(prediction, 1, 5)
    
    def recommend_for_user(self, user_id, top_n=5):
        """为用户生成Top-N推荐"""
        user_idx = list(self.user_ids).index(user_id)
        
        # 计算用户对所有物品的预测评分
        user_vector = self.user_factors[user_idx, :]
        all_predictions = (self.global_bias + 
                          self.user_biases.iloc[user_idx] + 
                          self.item_biases.values +
                          user_vector @ self.item_factors.T)
        
        # 创建结果DataFrame
        recommendations = pd.DataFrame({
            'item_id': self.item_ids,
            'predicted_rating': all_predictions
        })
        
        # 排序并返回Top-N
        return recommendations.sort_values('predicted_rating', ascending=False).head(top_n)

# 训练模型
recommender = InterpretableSVDRecommender(n_factors=5)
recommender.fit(ratings_df)

def analyze_latent_factors(recommender, item_names=None):
    """分析隐因子的语义含义"""
    print("\n" + "="*60)
    print(" 隐因子语义分析")
    print("="*60)
    
    item_factors_df = pd.DataFrame(
        recommender.item_factors,
        index=recommender.item_ids,
        columns=[f'Factor_{i}' for i in range(recommender.n_factors)]
    )
    
    # 分析每个因子最具代表性的物品（正向和负向）
    for factor in range(recommender.n_factors):
        print(f"\n 分析隐因子 {factor} (奇异值: {recommender.singular_values[factor]:.3f}):")
        
        # 找到在该因子上得分最高和最低的物品
        top_items = item_factors_df.nlargest(3, f'Factor_{factor}')
        bottom_items = item_factors_df.nsmallest(3, f'Factor_{factor}')
        
        print(f"  正向代表 (高权重):")
        for item_id, weight in top_items[f'Factor_{factor}'].items():
            print(f"    - {item_id}: {weight:.3f}")
            
        print(f"  负向代表 (低权重):")
        for item_id, weight in bottom_items[f'Factor_{factor}'].items():
            print(f"    - {item_id}: {weight:.3f}")
        
        # 尝试自动推断因子含义（在实际应用中，需要结合物品元数据）
        factor_range = top_items[f'Factor_{factor}'].mean() - bottom_items[f'Factor_{factor}'].mean()
        print(f"  因子强度: {factor_range:.3f}")
        
        # 基于代表性物品的名称模式，尝试自动标注（这里是模拟）
        possible_interpretations = [
            "制作规模/特效", "浪漫/情感深度", "喜剧/轻松程度", 
            "艺术性/导演风格", "年代感/经典程度"
        ]
        if factor < len(possible_interpretations):
            print(f"   推测语义: {possible_interpretations[factor]}")
    
    return item_factors_df

# 执行隐因子分析
item_factors_df = analyze_latent_factors(recommender)

def analyze_user_profile(recommender, user_id):
    """分析特定用户的隐因子画像"""
    print(f"\n 用户画像分析: {user_id}")
    print("-" * 40)
    
    user_idx = list(recommender.user_ids).index(user_id)
    user_factor_weights = recommender.user_factors[user_idx, :]
    
    user_profile = pd.DataFrame({
        'Factor': [f'Factor_{i}' for i in range(recommender.n_factors)],
        'Weight': user_factor_weights,
        'Importance': user_factor_weights * recommender.singular_values
    })
    
    user_profile = user_profile.sort_values('Importance', key=abs, ascending=False)
    
    print("用户的隐因子偏好 (按重要性排序):")
    for _, row in user_profile.iterrows():
        preference = "喜欢" if row['Weight'] > 0 else "不喜欢"
        print(f"  {row['Factor']}: {preference} (强度: {abs(row['Weight']):.3f})")
    
    return user_profile

# 分析示例用户
user_profile = analyze_user_profile(recommender, 'User_0')

def generate_explainable_recommendations(recommender, user_id, top_n=3):
    """生成带有解释的推荐"""
    print(f"\n 为 {user_id} 生成可解释的推荐:")
    print("-" * 50)
    
    # 获取推荐结果
    recommendations = recommender.recommend_for_user(user_id, top_n=top_n)
    user_profile = analyze_user_profile(recommender, user_id)
    
    user_idx = list(recommender.user_ids).index(user_id)
    user_factors = recommender.user_factors[user_idx, :]
    
    for _, rec in recommendations.iterrows():
        item_id = rec['item_id']
        item_idx = list(recommender.item_ids).index(item_id)
        item_factors = recommender.item_factors[item_idx, :]
        
        print(f"\n 推荐物品: {item_id} (预测评分: {rec['predicted_rating']:.2f})")
        print("   推荐理由:")
        
        # 计算每个因子对预测的贡献
        factor_contributions = user_factors * item_factors * recommender.singular_values
        
        # 只显示最重要的几个理由
        top_contributions = np.argsort(-np.abs(factor_contributions))[:2]
        
        for factor_idx in top_contributions:
            contribution = factor_contributions[factor_idx]
            user_weight = user_factors[factor_idx]
            item_weight = item_factors[factor_idx]
            
            if abs(contribution) > 0.1:  # 只显示显著贡献
                if user_weight > 0 and item_weight > 0:
                    reason = f"       • 您喜欢{get_factor_interpretation(factor_idx)}，而该物品在这方面很突出"
                elif user_weight < 0 and item_weight < 0:
                    reason = f"       • 您不喜欢{get_factor_interpretation(factor_idx)}，而该物品在这方面也很弱"
                elif user_weight > 0 and item_weight < 0:
                    reason = f"       • 虽然您喜欢{get_factor_interpretation(factor_idx)}，但该物品在这方面稍弱（其他方面很匹配）"
                else:
                    reason = f"       • 虽然您不喜欢{get_factor_interpretation(factor_idx)}，但该物品在这方面很突出（形成了良好互补）"
                
                print(reason)

def get_factor_interpretation(factor_idx):
    """获取因子的语义解释（在实际中应基于元数据分析）"""
    interpretations = [
        "大制作、特效震撼的电影",
        "浪漫深情、情感丰富的作品", 
        "轻松幽默的喜剧内容",
        "艺术性强、导演风格独特的影片",
        "经典怀旧、有年代感的电影"
    ]
    return interpretations[factor_idx] if factor_idx < len(interpretations) else f"特征{factor_idx}"

# 生成可解释的推荐
generate_explainable_recommendations(recommender, 'User_0', top_n=3)

def visualize_svd_insights(recommender, item_factors_df):
    """可视化SVD分析结果"""
    print("\n 生成可视化分析...")
    
    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
    
    # 1. 奇异值重要性（碎石图）
    axes[0, 0].plot(range(1, len(recommender.singular_values) + 1), 
                   recommender.singular_values, 'bo-')
    axes[0, 0].set_title('奇异值碎石图 (Scree Plot)')
    axes[0, 0].set_xlabel('隐因子')
    axes[0, 0].set_ylabel('奇异值')
    axes[0, 0].grid(True, alpha=0.3)
    
    # 2. 前两个隐因子的物品分布
    sample_items = np.random.choice(len(recommender.item_ids), 30, replace=False)
    sample_df = item_factors_df.iloc[sample_items]
    
    axes[0, 1].scatter(sample_df['Factor_0'], sample_df['Factor_1'], alpha=0.6)
    axes[0, 1].set_title('物品在隐空间中的分布 (Factor 0 vs Factor 1)')
    axes[0, 1].set_xlabel('隐因子 0 - 制作规模')
    axes[0, 1].set_ylabel('隐因子 1 - 浪漫程度')
    
    # 标注几个点
    for i, (idx, row) in enumerate(sample_df.iterrows()):
        if i % 5 == 0:  # 只标注部分点
            axes[0, 1].annotate(idx, (row['Factor_0'], row['Factor_1']), 
                               xytext=(5, 5), textcoords='offset points', fontsize=8)
    
    # 3. 用户隐因子分布热力图
    user_sample = recommender.user_factors[:20, :]  # 前20个用户
    im = axes[1, 0].imshow(user_sample, cmap='RdBu_r', aspect='auto')
    axes[1, 0].set_title('用户隐因子权重热力图')
    axes[1, 0].set_xlabel('隐因子')
    axes[1, 0].set_ylabel('用户')
    axes[1, 0].set_xticks(range(recommender.n_factors))
    axes[1, 0].set_xticklabels([f'F{i}' for i in range(recommender.n_factors)])
    plt.colorbar(im, ax=axes[1, 0])
    
    # 4. 因子贡献度分析
    user_idx = 0  # 分析第一个用户
    item_idx = 5  # 分析一个物品
    
    user_vec = recommender.user_factors[user_idx, :]
    item_vec = recommender.item_factors[item_idx, :]
    contributions = user_vec * item_vec * recommender.singular_values
    
    factors = [f'F{i}' for i in range(recommender.n_factors)]
    axes[1, 1].bar(factors, contributions, color=['red' if x < 0 else 'blue' for x in contributions])
    axes[1, 1].set_title(f'用户{user_idx}对物品{recommender.item_ids[item_idx]}的评分因子贡献')
    axes[1, 1].set_ylabel('贡献度')
    axes[1, 1].axhline(y=0, color='black', linestyle='-', alpha=0.3)
    
    plt.tight_layout()
    plt.show()

# 执行可视化
visualize_svd_insights(recommender, item_factors_df)