python协同过滤算法实现电影推荐

1. 数据准备

首先，需要准备一份电影评分数据集。假设该数据集包含每个用户对电影的评分，评分范围为1-5分。

2. 计算相似度

使用余弦相似度计算每对电影之间的相似度，并将结果保存到一个相似度矩阵中。相似度越高，说明两个电影越相似。

3. 生成推荐列表

对于每个用户，找到他没有评分过但与他评分过的电影相似度较高的电影，并将这些电影按照相似度排序，生成一个推荐列表。

4. 评估推荐效果

使用交叉验证的方法，将数据集分为训练集和测试集。在训练集上训练模型，在测试集上测试模型的预测准确率。可以使用均方根误差（RMSE）等指标来评估推荐效果。

代码实现

以下是一份使用Python实现协同过滤算法的示例代码：

import numpy as np

class CollaborativeFiltering:
    def __init__(self, n_users, n_items, n_factors=20, lr=0.01, reg=0.1, n_epochs=10):
        self.n_users = n_users
        self.n_items = n_items
        self.n_factors = n_factors
        self.lr = lr
        self.reg = reg
        self.n_epochs = n_epochs

    def fit(self, X):
        self.user_factors = np.random.normal(0, 0.1, (self.n_users, self.n_factors))
        self.item_factors = np.random.normal(0, 0.1, (self.n_items, self.n_factors))
        for epoch in range(self.n_epochs):
            for u, i, r in X:
                error = r - np.dot(self.user_factors[u], self.item_factors[i])
                self.user_factors[u] += self.lr * (error * self.item_factors[i] - self.reg * self.user_factors[u])
                self.item_factors[i] += self.lr * (error * self.user_factors[u] - self.reg * self.item_factors[i])

    def predict(self, u):
        return np.dot(self.user_factors[u], self.item_factors.T)

    def recommend(self, u, k=10):
        scores = self.predict(u)
        scores = np.argsort(scores)[::-1]
        return scores[:k]

def cosine_similarity(X):
    norms = np.linalg.norm(X, axis=1)
    X_normed = X / norms[:, np.newaxis]
    return np.dot(X_normed, X_normed.T)

def movie_recommendation(data, user_id):
    n_users = max(data[:, 0]) + 1
    n_items = max(data[:, 1]) + 1
    cf = CollaborativeFiltering(n_users, n_items, n_factors=20, lr=0.01, reg=0.1, n_epochs=10)
    cf.fit(data)
    similarity = cosine_similarity(cf.item_factors)
    user_items = set(data[data[:, 0] == user_id][:, 1])
    recommendations = []
    for i in range(n_items):
        if i not in user_items:
            score = np.mean(similarity[i, list(user_items)])
            recommendations.append((i, score))
    recommendations = sorted(recommendations, key=lambda x: x[1], reverse=True)
    return recommendations[:10]

data = np.array([
    [0, 0, 4],
    [0, 1, 5],
    [0, 2, 3],
    [1, 0, 3],
    [1, 1, 4],
    [1, 2, 5],
    [2, 0, 5],
    [2, 1, 2],
    [2, 2, 1],
    [3, 0, 2],
    [3, 1, 3],
    [3, 2, 4],
    [4, 0, 1],
    [4, 1, 2],
    [4, 2, 3],
])

recommendations = movie_recommendation(data, 0)
print(recommendations)

该代码使用了随机梯度下降（SGD）算法来训练模型，并使用余弦相似度计算电影之间的相似度。在示例数据集上，该算法可以生成一份推荐列表。