def _initialize_teacher(self, interactions):
# initialize teacher model
self._num_items = interactions.num_items
self._num_users = interactions.num_users
self._teacher_net = gpu(
Caser(self._num_users, self._num_items, self._teacher_model_args),
self._use_cuda)
# load teacher model
if os.path.isfile(self._teacher_model_path):
output_str = ("loading teacher model %s" %
self._teacher_model_path)
print(output_str)
checkpoint = torch.load(self._teacher_model_path)
self._teacher_net.load_state_dict(checkpoint['state_dict'])
output_str = "loaded model %s (epoch %d)" % (
self._teacher_model_path, checkpoint['epoch_num'])
print(output_str)
else:
output_str = "no model found at %s" % self._teacher_model_path
print output_str
# set teacher model to evaluation mode
self._teacher_net.eval()
def _initialize(self, interactions):
self._num_items = interactions.num_items
self._num_users = interactions.num_users
self.test_sequence = interactions.test_sequences
self._net = Caser(self._num_users, self._num_items, self.args)
self.sess = tf.Session()
init = tf.global_variables_initializer()
self.sess.run(init)
def _initialize(self, interactions):
self._num_items = interactions.num_items
self._num_users = interactions.num_users
self.test_sequence = interactions.test_sequences
self._net = Caser(self._num_users, self._num_items, self.model_args)
self._optimizer = optim.Adam(self._net.parameters(),
weight_decay=self._l2,
lr=self._learning_rate)
def _initialize_student(self, interactions):
self._num_items = interactions.num_items
self._num_users = interactions.num_users
self.test_sequence = interactions.test_sequences
self._net = gpu(
Caser(self._num_users, self._num_items, self._student_model_args),
self._use_cuda)
self._optimizer = optim.Adam(self._net.parameters(),
weight_decay=self._l2,
lr=self._learning_rate)
self._loss_func = weighted_sigmoid_log_loss
def test(args):
data = Interactions(args.test_root)
data.to_sequence(args.L, args.T)
sequences_np = data.sequences.sequences
targets_np = data.sequences.targets
users_np = data.sequences.user_ids.reshape(-1, 1)
n_test = sequences_np.shape[0]
print('total test instances: %d' % n_test)
num_users = data.num_users
num_items = data.num_items
NDCG, HR, MRR = 0.0, 0.0, 0.0
item_ids = np.zeros((args.batch_size,num_items))
for i in range(args.batch_size):
item_ids[i] = np.arange(num_items)
test_batches = n_test // args.batch_size
model=Caser(num_users,num_items,args)
gpu_config = tf.ConfigProto()
gpu_config.gpu_options.allow_growth = True
with tf.Session(config=gpu_config) as sess:
saver = tf.train.Saver(tf.global_variables())
ckpt = tf.train.get_checkpoint_state(args.check_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print('Restore model from {} successfully!'.format(args.check_dir))
else:
print('Restore model from {} failed!'.format(args.check_dir))
return
for i in range(test_batches):
sequences = sequences_np[i * args.batch_size: (i + 1) * args.batch_size]
targets = targets_np[i * args.batch_size: (i + 1) * args.batch_size]
users = users_np[i * args.batch_size: (i + 1) * args.batch_size]
_, top_k_index = model.predict(sess, sequences, users, item_ids)
hr, ndcg, mrr = 0.0, 0.0, 0.0
for i in range(args.batch_size):
cur_user = top_k_index[i]
for j in range(args.top_k):
if targets[i][0] == cur_user[j]:
hr += 1
mrr += 1 / (1 + j)
dcg = 1 / np.log2(1 + 1 + j)
idcg = 1 / np.log2(1 + 1)
ndcg += dcg / idcg
break
HR += hr / args.batch_size
NDCG += ndcg / args.batch_size
MRR += mrr / args.batch_size
return HR / test_batches, NDCG / test_batches, MRR / test_batches
def _initialize(self):
print("train/test examination...")
n_user, n_item, item_map = examination(self.train_path, self.test_path)
self._num_items = len(item_map) + 1 # for 0 padding
self._num_users = n_user
self.item_map = item_map
self.item_cumsum = self._get_item_cumsum()
#items = [i[0] for i in self.item_map.values()]
#print(max(items),self._num_items)
# get pr_etrain embeddings
print(self.pre_train_path)
print(os.path.isfile(self.pre_train_path))
if self.pre_train_path and os.path.isfile(self.pre_train_path):
print("loading pre_train value")
w2v = Word2Vec.load(self.pre_train_path)
dims = w2v.trainables.layer1_size
pre_train_array = list()
sort_index = list()
for k, v in item_map.items():
sort_index.append(v[0])
try:
pre_train_array.append(w2v.wv.get_vector(str(k)))
except KeyError:
pre_train_array.append(np.random.randn(dims))
# add 0 padding:
if 0 not in sort_index:
sort_index.append(0)
pre_train_array.append(np.random.randn(dims))
pre_train_array = np.array(pre_train_array)
pre_train_array = pre_train_array[np.argsort(sort_index)]
else:
print("no pre_train value")
pre_train_array = None
self._net = gpu(
Caser(self._num_users, self._num_items, self.model_args,
pre_train_array), self._use_cuda)
par = filter(lambda p: p.requires_grad, self._net.parameters())
#self._net.parameters()
self._optimizer = optim.Adam(par,
weight_decay=self._l2,
lr=self._learning_rate)
