本文是对论文《一种基于标签的电影组推荐方法》熊聪聪，林 颖，史艳翠，冯 阔 (天津科技大学人工智能学院，天津 300457)中，一些算法的实现。
基于标签的用户相似度
代码实现：
# coding = utf-8
# 基于用户的协同过滤推荐算法实现
import random
import math
from operator import itemgetter
import pickle
class UserBasedCF():
# 初始化相关参数
def __init__(self):
# 找到与目标用户兴趣相似的20个用户，为其推荐10部电影
self.n_sim_user = 20
self.n_rec_movie = 10
# 将数据集划分为训练集和测试集
self.trainSet = {}
self.testSet = {}
# 用户相似度矩阵
self.user_sim_matrix = {}
self.movie_count = 0
print('Similar user number = %d' % self.n_sim_user)
print('Recommneded movie number = %d' % self.n_rec_movie)
# 读文件得到“用户-电影”数据
def get_dataset(self, filename, pivot=0.75):
trainSet_len = 0
testSet_len = 0
for line in self.load_file(filename):
user, movie, rating, timestamp = line.split('\t')
if random.random() < pivot:
self.trainSet.setdefault(user, {})
self.trainSet[user][movie] = rating
trainSet_len += 1
else:
self.testSet.setdefault(user, {})
self.testSet[user][movie] = rating
testSet_len += 1
print('Split trainingSet and testSet success!')
print('TrainSet = %s' % trainSet_len)
print('TestSet = %s' % testSet_len)
# 读文件，返回文件的每一行
def load_file(self, filename):
with open(filename, 'r') as f:
for i, line in enumerate(f):
if i == 0: # 去掉文件第一行的title
continue
yield line.strip('\r\n')
print('Load %s success!' % filename)
def user_label(self, user, label):#计算用户对某一标签的偏好
#label 标签下标 0-19
#user 用户id
f_utk = 0 #这里计算该用户所有标签数的总和
for num in self.f_ut[user]:
f_utk += num
p_ut = (self.f_ut[user][label]/f_utk)*math.log(self.m_t/self.m_tj[label])
return p_ut
def importanceOfLabel(self, label): #标签的重要性（权重）
t = self.t #表示所有电影的标签出现次数
t_j = self.m_tj #表示标签tj在总标签中出现次数
n = self.user_n #n表示用户数
# n_tj #n_tj表示看过标签tj的用户数
w_tj = math.log((t/t_j[label])*(n/self.n_tj[label]))
return w_tj
def user_label_w(self, p_ut, label):
return p_ut*self.importanceOfLabel(label)
def calc_user_sim_of_label(self, user1, user2, label_list):
#label_list user1和user2均观看过的标签
p_ui = {} #标签偏好权重均值
p_uj = {} #标签偏好权重均值
p_ui_avg = 0
p_uj_avg = 0
for label in label_list:
p_ui[label] = self.user_label_w(self.user_label(user1, label), label)
p_uj[label] = self.user_label_w(self.user_label(user2, label), label)
p_ui_avg += p_ui[label]
p_uj_avg += p_uj[label]
p_ui_avg /= len(label_list)
p_uj_avg /= len(label_list)
result_fenzi = 0
for label in label_list:
result_fenzi += ((p_ui[label]-p_ui_avg)*(p_uj[label]-p_uj_avg))
user1_fenmu = 0
user2_fenmu = 0
for label in label_list:
user1_fenmu += (p_ui[label]-p_ui_avg)**2
user2_fenmu += (p_uj[label]-p_uj_avg)**2
return (result_fenzi)/(math.sqrt(user1_fenmu * user2_fenmu))
# 计算用户之间的相似度
def calc_user_sim(self):
# 构建“电影-用户”倒排索引
# key = movieID, value = list of userIDs who have seen this movie
# self.movie_label mt
self.f_ut = {}#用户u观看的电影的标签t的个数
self.m_tj = [0 for n in range(19)] #用包含标签tj的电影数
self.m_t = 0 #有标签的电影数，这里的数据集每个电影都有标签
self.t = 0
self.user_n = 0 #用户数
self.n_tj = [0 for n in range(19)] #统计观看的label对应的用户数
print('Building movie-user table ...')
movie_user = {}
for user, movies in self.trainSet.items():
self.user_n += 1
is_collect = [False for n in range(19)]
if user not in self.f_ut:
self.f_ut[user] = [0 for n in range(19)]
for movie in movies:
indexs = 0
for num in self.movie_label[int(movie)]:#电影总共有19个标签
if num!=0:
self.f_ut[user][indexs] += num
self.m_tj[indexs] += 1
self.t += 1
if is_collect[indexs]==False:
self.n_tj[indexs] += 1
is_collect[indexs] = True
indexs += 1
if movie not in movie_user:
movie_user[movie] = set()
movie_user[movie].add(user)
print('Build movie-user table success!')
self.m_t = self.movie_count = len(movie_user)
print('Total movie number = %d' % self.movie_count)
print('Build user co-rated movies matrix ...')
for movie, users in movie_user.items():
for u in users:
for v in users:
if u == v:
continue
if u not in self.user_sim_matrix:
self.user_sim_matrix.setdefault(u, {})
if v not in self.user_sim_matrix[u]:
self.user_sim_matrix[u].setdefault(v, 0)
self.user_sim_matrix[u][v] += 1
print('Build user co-rated movies matrix success!')
# 计算相似性
print('Calculating user similarity matrix ...')
alpha = 0.3
for u, related_users in self.user_sim_matrix.items():
for v, count in related_users.items():
self.user_sim_matrix[u][v] = count / math.sqrt(len(self.trainSet[u]) * len(self.trainSet[v]))
label_list = list()
for index in range(19):
if self.f_ut[u][index]!=0 and self.f_ut[v][index]!=0:
label_list.append(index)
# self.user_sim_matrix[u][v] += self.calc_user_sim_of_label(u, v, label_list)
#计算总体偏好相似度
self.user_sim_matrix[u][v] = (1-alpha)*self.user_sim_matrix[u][v] + alpha*self.calc_user_sim_of_label(u, v, label_list)
print('Calculate user similarity matrix success!')
# 针对目标用户U，找到其最相似的K个用户，产生N个推荐
def recommend(self, user):
K = self.n_sim_user
N = self.n_rec_movie
rank = {}
watched_movies = self.trainSet[user]
# v=similar user, wuv=similar factor
for v, wuv in sorted(self.user_sim_matrix[user].items(), key=itemgetter(1), reverse=True)[0:K]:
for movie in self.trainSet[v]:
if movie in watched_movies:
continue
rank.setdefault(movie, 0)
rank[movie] += wuv
return sorted(rank.items(), key=itemgetter(1), reverse=True)[0:N]
# 产生推荐并通过准确率、召回率和覆盖率进行评估
def evaluate(self):
print("Evaluation start ...")
N = self.n_rec_movie
# 准确率和召回率
hit = 0
rec_count = 0
test_count = 0
# 覆盖率
all_rec_movies = set()
for i, user, in enumerate(self.trainSet):
test_movies = self.testSet.get(user, {})
rec_movies = self.recommend(user)
print("rec_movies = ",rec_movies)
for movie, w in rec_movies:
if movie in test_movies:
hit += 1
all_rec_movies.add(movie)
rec_count += N
test_count += len(test_movies)
precision = hit / (1.0 * rec_count)
recall = hit / (1.0 * test_count)
coverage = len(all_rec_movies) / (1.0 * self.movie_count)
# print('precisioin=%.4f\trecall=%.4f\tcoverage=%.4f' % (precision, recall, coverage))
print('precisioin=%.2f%%\t recall=%.2f%%\t coverage=%.2f%%' % (precision*100, recall*100, coverage*100))
return precision, recall, coverage
def get_label(self):
fs=open('movie_label.pkl','rb')
self.movie_label=pickle.load(fs)
if __name__ == '__main__':
rating_file = '../ItemCF/ml-100k/u.data'
precision, recall, coverage = 0,0,0
for i in range(10):
userCF = UserBasedCF()
userCF.get_dataset(rating_file)
userCF.get_label()
userCF.calc_user_sim()
t1, t2, t3 = userCF.evaluate()
precision += t1
recall += t2
coverage += t3
print('precisioin=%.2f%%\t recall=%.2f%%\t coverage=%.2f%%' % ((precision/10)*100, (recall/10)*100, (coverage/10)*100))
结果：
使用数据集：https://share.weiyun.com/2UP7O67E
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
