推荐系统

import numpy as np
 
def cofiCostFunc(params, Y, R, num_users, num_movies, num_features, lambda_reg):
    """
    协同过滤代价函数
    params: 展开的参数向量 [X; Theta]
    Y: 评分矩阵
    R: 评分指示矩阵
    """
    # 恢复参数
    X = params[:num_movies * num_features].reshape(num_movies, num_features)
    Theta = params[num_movies * num_features:].reshape(num_users, num_features)
    
    # 计算代价
    predictions = X @ Theta.T
    errors = (predictions - Y) * R
    J = 0.5 * np.sum(errors ** 2) + \
        0.5 * lambda_reg * (np.sum(Theta ** 2) + np.sum(X ** 2))
    
    # 计算梯度
    X_grad = (errors @ Theta) + lambda_reg * X
    Theta_grad = (errors.T @ X) + lambda_reg * Theta
    
    grad = np.concatenate([X_grad.ravel(), Theta_grad.ravel()])
    
    return J, grad
 
def trainCollaborativeFiltering(Y, R, num_features, lambda_reg, num_iters=400):
    """
    训练协同过滤模型
    """
    num_movies, num_users = Y.shape
    
    # 随机初始化
    X = np.random.randn(num_movies, num_features)
    Theta = np.random.randn(num_users, num_features)
    initial_params = np.concatenate([X.ravel(), Theta.ravel()])
    
    # 优化（这里简化使用梯度下降，实践中用更高级的优化器）
    params = initial_params.copy()
    alpha = 0.001
    
    for i in range(num_iters):
        J, grad = cofiCostFunc(params, Y, R, num_users, num_movies, 
                               num_features, lambda_reg)
        params -= alpha * grad
        
        if (i+1) % 100 == 0:
            print(f"迭代 {i+1}: 代价 = {J:.4f}")
    
    # 恢复参数
    X = params[:num_movies * num_features].reshape(num_movies, num_features)
    Theta = params[num_movies * num_features:].reshape(num_users, num_features)
    
    return X, Theta

def predictRatings(X, Theta):
    """
    预测所有评分
    返回: num_movies x num_users 的预测矩阵
    """
    return X @ Theta.T
 
def recommendMovies(user_id, X, Theta, movie_names, num_recommendations=10):
    """
    为用户推荐电影
    """
    # 预测该用户对所有电影的评分
    predictions = X @ Theta[user_id]
    
    # 排序并选择top-K
    top_indices = np.argsort(predictions)[::-1][:num_recommendations]
    
    print(f"\n为用户 {user_id} 推荐的电影:")
    for i, idx in enumerate(top_indices, 1):
        print(f"{i}. {movie_names[idx]} (预测评分: {predictions[idx]:.2f})")
    
    return top_indices

def findSimilarMovies(movie_id, X, movie_names, num_similar=5):
    """
    找到相似的电影
    """
    # 计算与所有电影的距离
    distances = np.sum((X - X[movie_id])**2, axis=1)
    
    # 排序（排除自己）
    similar_indices = np.argsort(distances)[1:num_similar+1]
    
    print(f"\n与 '{movie_names[movie_id]}' 相似的电影:")
    for i, idx in enumerate(similar_indices, 1):
        print(f"{i}. {movie_names[idx]} (距离: {distances[idx]:.2f})")
    
    return similar_indices

def normalizeMeanRatings(Y, R):
    """
    均值归一化
    Y: 评分矩阵
    R: 评分指示矩阵
    """
    m, n = Y.shape
    Ymean = np.zeros(m)
    Ynorm = Y.copy()
    
    for i in range(m):
        idx = R[i, :] == 1
        if np.sum(idx) > 0:
            Ymean[i] = np.mean(Y[i, idx])
            Ynorm[i, idx] -= Ymean[i]
    
    return Ynorm, Ymean

# 完整的电影推荐系统
class MovieRecommender:
    def __init__(self, num_features=10, lambda_reg=1.0):
        self.num_features = num_features
        self.lambda_reg = lambda_reg
        self.X = None
        self.Theta = None
        self.Ymean = None
    
    def fit(self, Y, R, num_iters=400):
        """
        训练模型
        Y: 评分矩阵 (num_movies x num_users)
        R: 评分指示矩阵
        """
        # 均值归一化
        Ynorm, self.Ymean = normalizeMeanRatings(Y, R)
        
        # 训练协同过滤
        self.X, self.Theta = trainCollaborativeFiltering(
            Ynorm, R, self.num_features, self.lambda_reg, num_iters
        )
    
    def predict(self, user_id, movie_id=None):
        """
        预测评分
        """
        if movie_id is None:
            # 预测该用户对所有电影的评分
            predictions = self.X @ self.Theta[user_id] + self.Ymean
            return predictions
        else:
            # 预测特定评分
            prediction = self.X[movie_id] @ self.Theta[user_id] + self.Ymean[movie_id]
            return prediction
    
    def recommend(self, user_id, num_recommendations=10):
        """
        推荐电影
        """
        predictions = self.predict(user_id)
        top_indices = np.argsort(predictions)[::-1][:num_recommendations]
        return top_indices, predictions[top_indices]
 
# 使用
recommender = MovieRecommender(num_features=10, lambda_reg=10)
recommender.fit(Y, R, num_iters=400)
 
# 为用户0推荐电影
recommendations, scores = recommender.recommend(user_id=0, num_recommendations=10)