def __init__(self, params, device='cuda:0'):
if params.method == 'tenet' and 'gnn' in params.include_networks and 'seq' in params.include_networks:
self.model = Tenet_Gnn_Seq(params, device)
elif params.method == 'tenet' and 'gnn' in params.include_networks:
self.model = Tenet_Gnn_Seq(params, device)
elif params.method == 'tenet' and 'seq' in params.include_networks:
self.model = Tenet_Gnn_Seq(params, device)
elif params.method == 'bpr':
self.model = BPR(params)
elif params.method == 'mf':
self.model = MF(params)
elif params.method == 'gmf':
self.model = GMF(params)
def loadModel(dataset, aname):
if aname == 'BPR':
f = open('./models/' + dataset + '/bpr_model.pkl', 'rb')
model = BPR()
bpr_params = pickle.load(f)['blobs']
model.user_factors = bpr_params['user_factors']
model.item_factors = bpr_params['item_factors']
bpr = model
f.close()
elif aname == 'SBPR1':
f = open('./models/' + dataset + '/sbpr1_model.pkl', 'rb')
model = SBPR1()
sbpr1_params = pickle.load(f)['blobs']
model.user_factors = sbpr1_params['user_factors']
model.item_factors = sbpr1_params['item_factors']
sbpr1 = model
f.close()
elif aname == 'SBPR2':
f = open('./models/' + dataset + '/sbpr2_model.pkl', 'rb')
model = SBPR2()
sbpr2_params = pickle.load(f)['blobs']
model.user_factors = sbpr2_params['user_factors']
model.item_factors = sbpr2_params['item_factors']
sbpr2 = model
f.close()
elif aname == 'RandomRanking':
f = open('./models/' + dataset + '/random_model.pkl', 'rb')
model = RandomRanking()
rr_params = pickle.load(f)['blobs']
model.n_users = rr_params['n_users']
model.n_items = rr_params['n_items']
rr = model
f.close()
elif aname == 'MostPopular':
f = open('./models/' + dataset + '/mp_model.pkl', 'rb')
model = MostPopular()
mp_params = pickle.load(f)['blobs']
model.mappings = mp_params['mappings']
model.topN = mp_params['topN']
mp = model
f.close()
return model
from RandomRanking import RandomRanking
from MostPopular import MostPopular
from lenskit import topn
import os
import numpy as np
import random
import scipy.sparse as sparse
from scipy.sparse import *
from sklearn.utils import shuffle
import pandas as pd
from math import ceil
from tqdm import trange
from sklearn.metrics import *
from itertools import islice
bpr = BPR()
sbpr1 = SBPR1()
sbpr2 = SBPR2()
rr = RandomRanking()
mp = MostPopular()
def saveAUCPlot(dataset, aname):
f = open('./results/' + dataset + '/' + aname + '_AUC.pkl', 'rb')
auc = pickle.load(f)
f.close()
plt.plot(range(len(auc)), auc)
plt.savefig('./results/' + dataset + '/' + aname + '_100epochs.png')
def loadModel(dataset, aname):
from openrec.utils.evaluators import AUC
from openrec.utils.samplers import RandomPairwiseSampler
from openrec.utils.samplers import EvaluationSampler
import dataloader
raw_data = dataloader.load_citeulike()
dim_embed = 100
total_iter = 10000
batch_size = 1000
eval_iter = 10000
save_iter = eval_iter
train_dataset = Dataset(raw_data['train_data'], raw_data['total_users'], raw_data['total_items'], name='Train')
val_dataset = Dataset(raw_data['val_data'], raw_data['total_users'], raw_data['total_items'], name='Val', num_negatives=500)
test_dataset = Dataset(raw_data['test_data'], raw_data['total_users'], raw_data['total_items'], name='Test', num_negatives=500)
train_sampler = RandomPairwiseSampler(batch_size=batch_size, dataset=train_dataset, num_process=5)
val_sampler = EvaluationSampler(batch_size=batch_size, dataset=val_dataset)
test_sampler = EvaluationSampler(batch_size=batch_size, dataset=test_dataset)
bpr_model = BPR(batch_size=batch_size, total_users=train_dataset.total_users(), total_items=train_dataset.total_items(),
l2_reg=0.01,
dim_user_embed=dim_embed, dim_item_embed=dim_embed, save_model_dir='bpr_recommender/', train=True, serve=True)
model_trainer = ModelTrainer(model=bpr_model)
auc_evaluator = AUC()
model_trainer.train(total_iter=total_iter, eval_iter=eval_iter, save_iter=save_iter, train_sampler=train_sampler,
eval_samplers=[val_sampler], evaluators=[auc_evaluator])
"Initialize APR")
# start training
training(AMF,
dataset,
args,
runName,
epoch_start=args.adv_epoch,
epoch_end=args.epochs,
time_stamp=time_stamp)
else:
runName = "%s_%s_d%d_%s" % (args.dataset, args.model, args.embed_size,
time_stamp)
if args.model == "bpe-keras":
ranker = BPR(dataset.num_users, dataset.num_items, args.embed_size)
elif args.model == "sasrec":
maxlen = int(dataset.df.groupby("uid").size().mean())
ranker = SASRec(dataset.num_users, dataset.num_items,
args.embed_size, maxlen, dataset.testNegatives)
ranker.init(dataset.trainSeq, args.batch_size)
# samples = sampling(dataset)
# samples = ()
eval_feed_dicts = init_eval_model(ranker, dataset)
# initialize the max_ndcg to memorize the best result
max_ndcg = 0
best_res = {}
reg = 1e-6
top_k = 10
# =============== 准备数据 ===============
params_dict, train_df, val_df, test_data = preprocess(
args.file_path, args.test_neg_num)
user_num, item_num = params_dict['user_num'], params_dict['item_num']
train_dataset = BPRDataset(train_df)
val_dataset = BPRDataset(val_df)
train_loader = DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True)
val_loader = DataLoader(val_dataset,
batch_size=args.batch_size,
shuffle=True)
# =============== 创建模型 ===============
bpr_model = BPR(user_num, item_num, embed_dim)
loss_func = BPRLoss()
optimizer = optim.Adam(bpr_model.parameters(),
lr=args.learning_rate,
weight_decay=reg)
# =============== 模型训练与测试 ===============
train(bpr_model, args.epochs, train_loader, loss_func, optimizer)
test(bpr_model, val_loader, loss_func)
# =============== 模型评估 ===============
HR, NDCG = evaluate(bpr_model, test_data, top_k)
print("HR: ", HR, "NDCG: ", NDCG)
#!/usr/bin/env python
# coding: utf-8
from preprocessor import Data_preprocessor
from BPR import BPR
import pandas as pd
import tensorflow_io as tfio
from tensorflow_io.kafka.python.ops import (
kafka_ops, ) # pylint: disable=wrong-import-position
import tensorflow_io.kafka as kafka_io # pylint: disable=wrong-import-position
__author__ = "Bo-Syun Cheng"
__email__ = "*****@*****.**"
if __name__ == "__main__":
data = pd.read_csv('data/ratings_small.csv')
dp = Data_preprocessor(data)
train, test = dp.preprocess()
bpr = BPR(train)
bpr.fit()
#!/usr/bin/env python
# coding: utf-8
from preprocessor import Data_preprocessor
from BPR import BPR
import pandas as pd
__author__ = "Bo-Syun Cheng"
__email__ = "*****@*****.**"
if __name__ == "__main__":
data = pd.read_csv('ratings_small.csv')
dp = Data_preprocessor(data)
processed_data = dp.preprocess()
bpr = BPR(processed_data)
bpr.fit()
dataset = getDataset(data, path, evalMode)
train, trainSeq, df, testRatings, testNegatives = dataset.trainMatrix, dataset.trainSeq, dataset.df, dataset.testRatings, dataset.testNegatives
uNum, iNum = df.uid.max() + 1, df.iid.max() + 1
# uNum = max(uNum, len(testRatings))
stat = "Load data done [%.1f s]. #user=%d, #item=%d, #train=%d, #test=%d" % (
time() - t1, uNum, iNum, len(df), len(testRatings)
) # user and item index start at 1, not zero, so the exact number of users and items = num - 1
# Initialise Model
if modelName == "mf":
ranker = MatrixFactorization(uNum, iNum, dim)
elif modelName == "bpr":
ranker = BPR(uNum, iNum, dim)
elif modelName == "amf":
ranker = AdversarialMatrixFactorisation(uNum, iNum, dim, weight,
pop_percent)
x_train, y_train = ranker.get_train_instances(train)
ranker.init(x_train[0], x_train[1])
elif modelName == "abpr":
ranker = AdversarialBPR(uNum, iNum, dim, weight, pop_percent)
x_train, y_train = ranker.get_train_instances(train)
ranker.init(x_train[0], x_train[1])
elif modelName == "amf2":
ranker = FastAdversarialMF(uNum, iNum, dim, weight, pop_percent)
elif modelName == "neumf":