def calculate_stats_users(pct_train):
dat_file = 'user_data_working.csv'
data = Data()
data.load(dat_file,
sep=',',
format={
'col': 0,
'row': 1,
'value': 2,
'ids': int
})
train, test = data.split_train_test(percent=pct_train)
svd = SVD()
svd.set_data(train)
svd.compute(k=100,
min_values=2,
pre_normalize=None,
mean_center=True,
post_normalize=False)
rmse = RMSE()
mae = MAE()
for rating, item_id, user_id in test.get():
try:
pred_rating = svd.predict(item_id, user_id)
rmse.add(rating, pred_rating)
mae.add(rating, pred_rating)
except KeyError:
continue
print 'RMSE=%s' % rmse.compute()
print 'MAE=%s\n' % mae.compute()
def evaluate(data, count=5, K=100):
results = []
for i in range(count):
train, test = data.split_train_test(percent=PERCENT_TRAIN)
print len(data.get()), len(train.get()), len(test.get())
#test_in_train(test, train)
#print train.get()
svd = SVD()
svd.set_data(train)
svd.compute(k=K, min_values=5, pre_normalize=None, mean_center=True, post_normalize=True)
#Evaluation using prediction-based metrics
rmse = RMSE()
mae = MAE()
for rating, item_id, user_id in test.get():
try:
pred_rating = svd.predict(item_id, user_id)
rmse.add(rating, pred_rating)
mae.add(rating, pred_rating)
except KeyError:
#print "keyerror: ===========================================================>"
continue
try:
rsu = {}
rsu["RMSE"] = rmse.compute()
rsu["MAE"] = mae.compute()
print rsu
results.append(rsu)
except:
print "one error....++++++++++++++++++++++++++++++++++++++++++++++++++++"
return results
def ex1(dat_file='./ml-1m/ratings.dat',
pct_train=0.5):
data = Data()
data.load(dat_file, sep='::', format={'col':0, 'row':1, 'value':2,'ids':int})
# create train/test split
train, test = data.split_train_test(percent=pct_train)
# create svd
K=100
svd = SVD()
svd.set_data(train)
svd.compute(k=K, min_values=5, pre_normalize=None, mean_center=True, post_normalize=True)
# evaluate performance
rmse = RMSE()
mae = MAE()
for rating, item_id, user_id in test.get():
try:
pred_rating = svd.predict(item_id, user_id)
rmse.add(rating, pred_rating)
mae.add(rating, pred_rating)
except KeyError:
continue
print 'RMSE=%s' % rmse.compute()
print 'MAE=%s' % mae.compute()
def __init__(self):
super(TestPrediction, self).__init__()
# Prediction-based metrics: MAE, RMSE, Pearson
self.mae = MAE(self.DATA_PRED)
self.rmse = RMSE(self.DATA_PRED)
self.R = 3 # Real Rating (ground truth)
self.R_PRED = 2.1 # Predicted Rating
def test_SVD(svd, train, test, pct_train):
rmse = RMSE()
mae = MAE()
for rating, item_id, user_id in test.get():
try:
pred_rating = svd.predict(item_id, user_id)
rmse.add(rating, pred_rating)
mae.add(rating, pred_rating)
except KeyError:
continue
print 'RMSE=%s' % rmse.compute()
print 'MAE=%s\n' % mae.compute()
def eval_reco(model, test):
""" Compute RMSE and MAE on test set
"""
#Evaluation using prediction-based metrics
rmse = RMSE()
mae = MAE()
for rating, item_id, user_id in test.get():
try:
pred_rating = model.predict(item_id, user_id)
rmse.add(rating, pred_rating)
mae.add(rating, pred_rating)
except KeyError:
continue
return rmse, mae
def ex1(dat_file=DATA_DIR + 'ml-1m-ratings.dat', pct_train=0.5):
data = Data()
data.load(dat_file,
sep='::',
format={
'col': 0,
'row': 1,
'value': 2,
'ids': int
})
# About format parameter:
# 'row': 1 -> Rows in matrix come from column 1 in ratings.dat file
# 'col': 0 -> Cols in matrix come from column 0 in ratings.dat file
# 'value': 2 -> Values (Mij) in matrix come from column 2 in ratings.dat
# file
# 'ids': int -> Ids (row and col ids) are integers (not strings)
# create train/test split
train, test = data.split_train_test(percent=pct_train)
# create svd
K = 100
svd = SVD()
svd.set_data(train)
svd.compute(k=K,
min_values=5,
pre_normalize=None,
mean_center=True,
post_normalize=True)
# evaluate performance
rmse = RMSE()
# mae is mean ABSOLUTE error
# ... in this case it will return 1.09 which means there is an error of almost 1 point out of 5
mae = MAE()
for rating, item_id, user_id in test.get():
try:
pred_rating = svd.predict(item_id, user_id)
rmse.add(rating, pred_rating)
mae.add(rating, pred_rating)
except KeyError:
continue
print 'RMSE=%s' % rmse.compute()
print 'MAE=%s' % mae.compute()
def __init__(self, filename, sep, **format):
# 文件信息
self.filename = filename
self.sep = sep
self.format = format
# 初始化矩阵分解
self.svd = SVD()
# 矩阵信息
self.k = 100 # 矩阵的隐因子睡昂
self.min_values = 10 # 删除评分少于10人的电影
self.post_normalize = False
# 设置是否加载模型标志
self.load_model = False
# 初始化均方误差
self.rmse = RMSE()
def __init__(self, filename, sep, **format):
self.filename = filename
self.sep = sep
self.format = format
# 训练参数
self.k = 100
self.min_values = 10
self.post_normalize = True
self.svd = SVD()
# 判断是否加载
self.is_load = False
# 添加数据处理
self.data = Data()
# 添加模型评估
self.rmse = RMSE()
def test_PRED_RMSE_load_test(self):
rmse = RMSE()
self.TEST_DATA = [2.3, 0.9, 4.9, 0.9, 1.5]
rmse.load_test(self.TEST_DATA)
assert_equal(len(rmse.get_test()), len(self.TEST_DATA))
def test_PRED_RMSE_compute_one_empty_datasets(self):
rmse = RMSE()
assert_equal(rmse.compute(self.R, self.R_PRED), 0.9)
def test_PRED_RMSE_numpy_array(self):
rmse = RMSE()
rmse.load(array(self.GT_DATA), array(self.TEST_DATA))
assert (rmse.compute(), 0.891067)
def test_PRED_RMSE_different_list_sizes(self):
rmse = RMSE()
GT = [3, 1, 5, 2]
# GT list has one element less than self.TEST_DATA
rmse.load(GT, self.TEST_DATA)
assert_raises(ValueError, rmse.compute)
def evaluate_matrices_rmse(self, original_matrix, imputed_matrix):
return self.evaluate_matrices(original_matrix,
imputed_matrix,
evaluator=RMSE())
svd_neig.set_data(train)
#Compute SVD
svd.compute(k=K,
min_values=None,
pre_normalize=None,
mean_center=True,
post_normalize=True)
svd_neig.compute(k=K,
min_values=None,
pre_normalize=None,
mean_center=True,
post_normalize=True)
# Evaluate
rmse_svd = RMSE()
mae_svd = MAE()
rmse_svd_neig = RMSE()
mae_svd_neig = MAE()
i = 1
total = len(test.get())
print 'Total Test ratings: %s' % total
for rating, item_id, user_id in test:
try:
pred_rating_svd = svd.predict(item_id, user_id)
rmse_svd.add(rating, pred_rating_svd)
mae_svd.add(rating, pred_rating_svd)
pred_rating_svd_neig = svd_neig.predict(item_id,
user_id) #Koren & co.
get_name_item_reviewed(10, user_full, items_full)
#3.12
items_full[str(2628)].get_data()
users_for_star_wars = svd.recommend(2628, only_unknowns=True)
users_for_star_wars
#3.13
movies_reviewed_by_sw_rec = [
get_name_item_reviewed(x[0], user_full, items_full)
for x in users_for_star_wars
]
movies_flatten = [
movie for movie_list in movies_reviewed_by_sw_rec for movie in movie_list
]
movie_aggregate = movies_by_category(movies_flatten, 3)
movies_sort = sorted(movie_aggregate, key=lambda x: x[1], reverse=True)
movies_sort
#3.14
from recsys.evaluation.prediction import RMSE
err = RMSE()
for rating, item_id, user_id in data.get():
try:
prediction = svd.predict(item_id, user_id)
err.add(rating, prediction)
except KeyError, k:
continue
print 'RMSE is ' + str(err.compute())
print ''
print 'GENERATING PREDICTION'
MIN_RATING = 0.0
MAX_RATING = 5.0
ITEMID = 1
USERID = 1
print svd.predict(ITEMID, USERID, MIN_RATING,
MAX_RATING) # predicted rating value
print svd.get_matrix().value(ITEMID, USERID) # real rating value
print ''
print 'GENERATING RECOMMENDATION'
print svd.recommend(USERID, n=5, only_unknowns=True, is_row=False)
#Evaluation using prediction-based metrics
rmse = RMSE()
mae = MAE()
spearman = SpearmanRho()
kendall = KendallTau()
#decision = PrecisionRecallF1()
for rating, item_id, user_id in test.get():
try:
pred_rating = svd.predict(item_id, user_id)
rmse.add(rating, pred_rating)
mae.add(rating, pred_rating)
spearman.add(rating, pred_rating)
kendall.add(rating, pred_rating)
except KeyError:
continue
print ''
