def train(args):
print(args)
dataset = MovieLens(
args.data_name,
args.ctx,
use_one_hot_fea=args.use_one_hot_fea,
symm=args.gcn_agg_norm_symm,
test_ratio=args.data_test_ratio,
valid_ratio=args.data_valid_ratio,
)
print("Loading data finished ...\n")
args.src_in_units = dataset.user_feature_shape[1]
args.dst_in_units = dataset.movie_feature_shape[1]
args.rating_vals = dataset.possible_rating_values
### build the net
net = Net(args=args)
net.initialize(init=mx.init.Xavier(factor_type="in"), ctx=args.ctx)
net.hybridize()
nd_possible_rating_values = mx.nd.array(dataset.possible_rating_values,
ctx=args.ctx,
dtype=np.float32)
rating_loss_net = gluon.loss.SoftmaxCELoss()
rating_loss_net.hybridize()
trainer = gluon.Trainer(net.collect_params(), args.train_optimizer,
{"learning_rate": args.train_lr})
print("Loading network finished ...\n")
### perpare training data
train_gt_labels = dataset.train_labels
train_gt_ratings = dataset.train_truths
### prepare the logger
train_loss_logger = MetricLogger(
["iter", "loss", "rmse"],
["%d", "%.4f", "%.4f"],
os.path.join(args.save_dir, "train_loss%d.csv" % args.save_id),
)
valid_loss_logger = MetricLogger(
["iter", "rmse"],
["%d", "%.4f"],
os.path.join(args.save_dir, "valid_loss%d.csv" % args.save_id),
)
test_loss_logger = MetricLogger(
["iter", "rmse"],
["%d", "%.4f"],
os.path.join(args.save_dir, "test_loss%d.csv" % args.save_id),
)
### declare the loss information
best_valid_rmse = np.inf
no_better_valid = 0
best_iter = -1
avg_gnorm = 0
count_rmse = 0
count_num = 0
count_loss = 0
print("Start training ...")
dur = []
for iter_idx in range(1, args.train_max_iter):
if iter_idx > 3:
t0 = time.time()
with mx.autograd.record():
pred_ratings = net(
dataset.train_enc_graph,
dataset.train_dec_graph,
dataset.user_feature,
dataset.movie_feature,
)
loss = rating_loss_net(pred_ratings, train_gt_labels).mean()
loss.backward()
count_loss += loss.asscalar()
gnorm = params_clip_global_norm(net.collect_params(),
args.train_grad_clip, args.ctx)
avg_gnorm += gnorm
trainer.step(1.0)
if iter_idx > 3:
dur.append(time.time() - t0)
if iter_idx == 1:
print("Total #Param of net: %d" % (gluon_total_param_num(net)))
print(
gluon_net_info(net,
save_path=os.path.join(
args.save_dir, "net%d.txt" % args.save_id)))
real_pred_ratings = (mx.nd.softmax(pred_ratings, axis=1) *
nd_possible_rating_values.reshape(
(1, -1))).sum(axis=1)
rmse = mx.nd.square(real_pred_ratings - train_gt_ratings).sum()
count_rmse += rmse.asscalar()
count_num += pred_ratings.shape[0]
if iter_idx % args.train_log_interval == 0:
train_loss_logger.log(iter=iter_idx,
loss=count_loss / (iter_idx + 1),
rmse=count_rmse / count_num)
logging_str = "Iter={}, gnorm={:.3f}, loss={:.4f}, rmse={:.4f}, time={:.4f}".format(
iter_idx,
avg_gnorm / args.train_log_interval,
count_loss / iter_idx,
count_rmse / count_num,
np.average(dur),
)
avg_gnorm = 0
count_rmse = 0
count_num = 0
if iter_idx % args.train_valid_interval == 0:
valid_rmse = evaluate(args=args,
net=net,
dataset=dataset,
segment="valid")
valid_loss_logger.log(iter=iter_idx, rmse=valid_rmse)
logging_str += ",\tVal RMSE={:.4f}".format(valid_rmse)
if valid_rmse < best_valid_rmse:
best_valid_rmse = valid_rmse
no_better_valid = 0
best_iter = iter_idx
net.save_parameters(filename=os.path.join(
args.save_dir, "best_valid_net{}.params".format(
args.save_id)))
test_rmse = evaluate(args=args,
net=net,
dataset=dataset,
segment="test")
best_test_rmse = test_rmse
test_loss_logger.log(iter=iter_idx, rmse=test_rmse)
logging_str += ", Test RMSE={:.4f}".format(test_rmse)
else:
no_better_valid += 1
if (no_better_valid > args.train_early_stopping_patience
and trainer.learning_rate <= args.train_min_lr):
logging.info(
"Early stopping threshold reached. Stop training.")
break
if no_better_valid > args.train_decay_patience:
new_lr = max(
trainer.learning_rate * args.train_lr_decay_factor,
args.train_min_lr)
if new_lr < trainer.learning_rate:
logging.info("\tChange the LR to %g" % new_lr)
trainer.set_learning_rate(new_lr)
no_better_valid = 0
if iter_idx % args.train_log_interval == 0:
print(logging_str)
print("Best Iter Idx={}, Best Valid RMSE={:.4f}, Best Test RMSE={:.4f}".
format(best_iter, best_valid_rmse, best_test_rmse))
train_loss_logger.close()
valid_loss_logger.close()
test_loss_logger.close()
def train(args):
dataset = MovieLens(args.data_name,
args.ctx,
use_one_hot_fea=args.use_one_hot_fea,
symm=args.gcn_agg_norm_symm)
print("Loading data finished ...\n")
args.src_key = dataset.name_user
args.dst_key = dataset.name_movie
args.src_in_units = dataset.user_feature.shape[1]
args.dst_in_units = dataset.movie_feature.shape[1]
args.nratings = dataset.possible_rating_values.size
### build the net
net = Net(args=args)
net.initialize(init=mx.init.Xavier(factor_type='in'), ctx=args.ctx)
net.hybridize()
if args.gen_r_use_classification:
nd_possible_rating_values = mx.nd.array(dataset.possible_rating_values,
ctx=args.ctx,
dtype=np.float32)
rating_loss_net = gluon.loss.SoftmaxCELoss()
else:
rating_mean = dataset.train_rating_values.mean()
rating_std = dataset.train_rating_values.std()
rating_loss_net = gluon.loss.L2Loss()
rating_loss_net.hybridize()
trainer = gluon.Trainer(net.collect_params(), args.train_optimizer,
{'learning_rate': args.train_lr})
print("Loading network finished ...\n")
### perpare training data
train_rating_pairs = mx.nd.array(dataset.train_rating_pairs,
ctx=args.ctx,
dtype=np.int64)
train_gt_ratings = mx.nd.array(dataset.train_rating_values,
ctx=args.ctx,
dtype=np.float32)
### prepare the logger
train_loss_logger = MetricLogger(
['iter', 'loss', 'rmse'], ['%d', '%.4f', '%.4f'],
os.path.join(args.save_dir, 'train_loss%d.csv' % args.save_id))
valid_loss_logger = MetricLogger(['iter', 'rmse'], ['%d', '%.4f'],
os.path.join(
args.save_dir,
'valid_loss%d.csv' % args.save_id))
test_loss_logger = MetricLogger(['iter', 'rmse'], ['%d', '%.4f'],
os.path.join(
args.save_dir,
'test_loss%d.csv' % args.save_id))
### declare the loss information
best_valid_rmse = np.inf
no_better_valid = 0
best_iter = -1
avg_gnorm = 0
count_rmse = 0
count_num = 0
count_loss = 0
print("Start training ...")
for iter_idx in range(1, args.train_max_iter):
if args.gen_r_use_classification:
train_gt_label = mx.nd.array(np.searchsorted(
dataset.possible_rating_values, dataset.train_rating_values),
ctx=args.ctx,
dtype=np.int32)
with mx.autograd.record():
pred_ratings = net(dataset.train_graph, train_rating_pairs)
if args.gen_r_use_classification:
loss = rating_loss_net(pred_ratings, train_gt_label).mean()
else:
loss = rating_loss_net(
mx.nd.reshape(pred_ratings, shape=(-1, )),
(train_gt_ratings - rating_mean) / rating_std).mean()
#loss.wait_to_read()
loss.backward()
count_loss += loss.asscalar()
gnorm = params_clip_global_norm(net.collect_params(),
args.train_grad_clip, args.ctx)
avg_gnorm += gnorm
trainer.step(1.0) #, ignore_stale_grad=True)
if iter_idx == 1:
print("Total #Param of net: %d" % (gluon_total_param_num(net)))
print(
gluon_net_info(net,
save_path=os.path.join(
args.save_dir, 'net%d.txt' % args.save_id)))
if args.gen_r_use_classification:
real_pred_ratings = (mx.nd.softmax(pred_ratings, axis=1) *
nd_possible_rating_values.reshape(
(1, -1))).sum(axis=1)
rmse = mx.nd.square(real_pred_ratings - train_gt_ratings).sum()
else:
rmse = mx.nd.square(
pred_ratings.reshape((-1, )) * rating_std + rating_mean -
train_gt_ratings).sum()
count_rmse += rmse.asscalar()
count_num += pred_ratings.shape[0]
if iter_idx % args.train_log_interval == 0:
train_loss_logger.log(iter=iter_idx,
loss=count_loss / (iter_idx + 1),
rmse=count_rmse / count_num)
logging_str = "Iter={}, gnorm={:.3f}, loss={:.4f}, rmse={:.4f}".format(
iter_idx, avg_gnorm / args.train_log_interval,
count_loss / iter_idx, count_rmse / count_num)
avg_gnorm = 0
count_rmse = 0
count_num = 0
if iter_idx % args.train_valid_interval == 0:
valid_rmse = evaluate(args=args,
net=net,
dataset=dataset,
segment='valid')
valid_loss_logger.log(iter=iter_idx, rmse=valid_rmse)
logging_str += ',\tVal RMSE={:.4f}'.format(valid_rmse)
if valid_rmse < best_valid_rmse:
best_valid_rmse = valid_rmse
no_better_valid = 0
best_iter = iter_idx
#net.save_parameters(filename=os.path.join(args.save_dir, 'best_valid_net{}.params'.format(args.save_id)))
test_rmse = evaluate(args=args,
net=net,
dataset=dataset,
segment='test')
best_test_rmse = test_rmse
test_loss_logger.log(iter=iter_idx, rmse=test_rmse)
logging_str += ', Test RMSE={:.4f}'.format(test_rmse)
else:
no_better_valid += 1
if no_better_valid > args.train_early_stopping_patience\
and trainer.learning_rate <= args.train_min_lr:
logging.info(
"Early stopping threshold reached. Stop training.")
break
if no_better_valid > args.train_decay_patience:
new_lr = max(
trainer.learning_rate * args.train_lr_decay_factor,
args.train_min_lr)
if new_lr < trainer.learning_rate:
logging.info("\tChange the LR to %g" % new_lr)
trainer.set_learning_rate(new_lr)
no_better_valid = 0
if iter_idx % args.train_log_interval == 0:
print(logging_str)
print('Best Iter Idx={}, Best Valid RMSE={:.4f}, Best Test RMSE={:.4f}'.
format(best_iter, best_valid_rmse, best_test_rmse))
train_loss_logger.close()
valid_loss_logger.close()
test_loss_logger.close()
def train(args):
print(args)
dataset = MovieLens(args.data_name, args.ctx, use_one_hot_fea=args.use_one_hot_fea, symm=args.gcn_agg_norm_symm,
test_ratio=args.data_test_ratio, valid_ratio=args.data_valid_ratio)
print("Loading data finished ...\n")
args.src_in_units = dataset.user_feature_shape[1]
args.dst_in_units = dataset.movie_feature_shape[1]
args.rating_vals = dataset.possible_rating_values
### build the net
net = Net(args=args)
net.initialize(init=mx.init.Xavier(factor_type='in'), ctx=args.ctx)
net.hybridize()
rating_loss_net = gluon.loss.SoftmaxCELoss()
rating_loss_net.hybridize()
trainer = gluon.Trainer(net.collect_params(), args.train_optimizer, {'learning_rate': args.train_lr})
print("Loading network finished ...\n")
### perpare training data
train_gt_labels = dataset.train_labels
train_gt_ratings = dataset.train_truths
### prepare the logger
train_loss_logger = MetricLogger(['iter', 'idx', 'loss', 'rmse'], ['%d', '%d', '%.4f', '%.4f'],
os.path.join(args.save_dir, 'train_loss%d.csv' % args.save_id))
valid_loss_logger = MetricLogger(['iter', 'rmse'], ['%d', '%.4f'],
os.path.join(args.save_dir, 'valid_loss%d.csv' % args.save_id))
test_loss_logger = MetricLogger(['iter', 'rmse'], ['%d', '%.4f'],
os.path.join(args.save_dir, 'test_loss%d.csv' % args.save_id))
### declare the loss information
best_valid_rmse = np.inf
no_better_valid = 0
best_iter = -1
enc_graph = dataset.train_enc_graph
nd_possible_rating_values = mx.nd.array(dataset.possible_rating_values, ctx=args.ctx, dtype=np.float32)
g_user_fea = mx.nd.zeros((dataset.num_user,))
g_movie_fea = mx.nd.zeros((dataset.num_movie,))
train_truths = dataset.train_truths
train_labels = dataset.train_labels
print("Start training ...")
dur = []
for iter_idx in range(1, args.train_max_iter):
if iter_idx > 3:
t0 = time.time()
num_edges = dataset.train_truths.shape[0]
seed = mx.nd.arange(num_edges, dtype='int64')
edges = mx.nd.shuffle(seed)
# each iteration will go through all edges
for sample_idx in range(0, (num_edges + args.minibatch_size - 1) // args.minibatch_size):
edge_ids = edges[sample_idx * args.minibatch_size: (sample_idx + 1) * args.minibatch_size if (sample_idx + 1) * args.minibatch_size < num_edges else num_edges]
head_ids, tail_ids = dataset.train_dec_graph.find_edges(edge_ids.asnumpy())
head_subgraphs = {}
tail_subgraphs = {}
head_node_ids = np.unique(head_ids.asnumpy())
tail_node_ids = np.unique(tail_ids.asnumpy())
for i, _ in enumerate(args.rating_vals):
t = enc_graph.canonical_etypes[i * 2]
rev_t = enc_graph.canonical_etypes[i * 2 + 1]
head_in_edges = enc_graph.in_edges(head_node_ids, 'eid', etype=rev_t)
tail_in_edges = enc_graph.in_edges(tail_node_ids, 'eid', etype=t)
if head_in_edges.shape[0] > 0:
head_subgraphs[rev_t] = head_in_edges
if tail_in_edges.shape[0] > 0:
tail_subgraphs[t] = tail_in_edges
head_subgraph = enc_graph.edge_subgraph(head_subgraphs, preserve_nodes=True)
tail_subgraph = enc_graph.edge_subgraph(tail_subgraphs, preserve_nodes=True)
edge_ids = edge_ids.as_in_context(args.ctx)
true_relation_ratings = train_truths[edge_ids]
true_relation_labels = train_labels[edge_ids]
head_NID = head_subgraph.nodes['user'].data[dgl.NID]
tail_NID = tail_subgraph.nodes['movie'].data[dgl.NID]
g_user_fea[head_NID] = mx.nd.arange(head_NID.shape[0], dtype='int32')
g_movie_fea[tail_NID] = mx.nd.arange(tail_NID.shape[0], dtype='int32')
true_head_idx = g_user_fea[head_ids].as_in_context(args.ctx)
true_tail_idx = g_movie_fea[tail_ids].as_in_context(args.ctx)
with mx.autograd.record():
pred_ratings = net(head_subgraph, tail_subgraph,
true_head_idx, true_tail_idx)
loss = rating_loss_net(pred_ratings, true_relation_labels).mean()
loss.backward()
gnorm = params_clip_global_norm(net.collect_params(), args.train_grad_clip, args.ctx)
trainer.step(1.0, ignore_stale_grad=True)
real_pred_ratings = (mx.nd.softmax(pred_ratings, axis=1) *
nd_possible_rating_values.reshape((1, -1))).sum(axis=1)
rmse = mx.nd.square(real_pred_ratings - true_relation_ratings).mean().asscalar()
rmse = np.sqrt(rmse)
loss = loss.asscalar()
if sample_idx % 100 == 0:
train_loss_logger.log(iter=iter_idx, idx=sample_idx,
loss=loss, rmse=rmse)
print("Iter={}, sample_idx={}, gnorm={:.3f}, loss={:.4f}, rmse={:.4f}".format(iter_idx,
sample_idx, gnorm, loss, rmse))
gc.collect()
if iter_idx > 3:
dur.append(time.time() - t0)
if iter_idx == 1:
print("Total #Param of net: %d" % (gluon_total_param_num(net)))
print(gluon_net_info(net, save_path=os.path.join(args.save_dir, 'net%d.txt' % args.save_id)))
if iter_idx % args.train_log_interval == 0:
logging_str = "Iter={}, time={:.4f}".format(
iter_idx, np.average(dur))
if iter_idx % args.train_valid_interval == 0:
valid_rmse = evaluate(args=args, net=net, dataset=dataset, segment='valid')
valid_loss_logger.log(iter = iter_idx, rmse = valid_rmse)
logging_str += ',\tVal RMSE={:.4f}'.format(valid_rmse)
if valid_rmse < best_valid_rmse:
best_valid_rmse = valid_rmse
no_better_valid = 0
best_iter = iter_idx
#net.save_parameters(filename=os.path.join(args.save_dir, 'best_valid_net{}.params'.format(args.save_id)))
test_rmse = evaluate(args=args, net=net, dataset=dataset, segment='test')
best_test_rmse = test_rmse
test_loss_logger.log(iter=iter_idx, rmse=test_rmse)
logging_str += ', Test RMSE={:.4f}'.format(test_rmse)
else:
no_better_valid += 1
if no_better_valid > args.train_early_stopping_patience\
and trainer.learning_rate <= args.train_min_lr:
logging.info("Early stopping threshold reached. Stop training.")
break
if no_better_valid > args.train_decay_patience:
new_lr = max(trainer.learning_rate * args.train_lr_decay_factor, args.train_min_lr)
if new_lr < trainer.learning_rate:
logging.info("\tChange the LR to %g" % new_lr)
trainer.set_learning_rate(new_lr)
no_better_valid = 0
if iter_idx % args.train_log_interval == 0:
print(logging_str)
print('Best Iter Idx={}, Best Valid RMSE={:.4f}, Best Test RMSE={:.4f}'.format(
best_iter, best_valid_rmse, best_test_rmse))
train_loss_logger.close()
valid_loss_logger.close()
test_loss_logger.close()