def resume_policy_from(self, policy_cpt_path):
print('Resume policy from {}'.format(policy_cpt_path))
resume_checkpoint(self.policy_net,
policy_cpt_path,
strict=True,
resume_key='policy',
print_keys=('epoch', ))
def load_pretrain_weights(self):
"""Loading weights from trained MLP model & GMF model"""
config = self.config
config['latent_dim'] = config['latent_dim_mlp']
mlp_model = MLP(config)
if config['use_cuda'] is True:
mlp_model.cuda()
resume_checkpoint(mlp_model,
model_dir=config['pretrain_mlp'],
device_id=config['device_id'])
self.embedding_user_mlp.weight.data = mlp_model.embedding_user.weight.data
self.embedding_item_mlp.weight.data = mlp_model.embedding_item.weight.data
for idx in range(len(self.fc_layers)):
self.fc_layers[idx].weight.data = mlp_model.fc_layers[
idx].weight.data
config['latent_dim'] = config['latent_dim_mf']
gmf_model = GMF(config)
if config['use_cuda'] is True:
gmf_model.cuda()
resume_checkpoint(gmf_model,
model_dir=config['pretrain_mf'],
device_id=config['device_id'])
self.embedding_user_mf.weight.data = gmf_model.embedding_user.weight.data
self.embedding_item_mf.weight.data = gmf_model.embedding_item.weight.data
self.affine_output.weight.data = 0.5 * torch.cat([
mlp_model.affine_output.weight.data,
gmf_model.affine_output.weight.data
],
dim=-1)
self.affine_output.bias.data = 0.5 * (
mlp_model.affine_output.bias.data +
gmf_model.affine_output.bias.data)
def resume_default_model(self, strict=False, resume_key='model'):
model_file_path = os.path.join(self.config['model_dir'],
self.config['model_resume_name'])
resume_checkpoint(self.net,
model_file_path,
strict=strict,
resume_key=resume_key)
def load_pretrain_weights(self):
"""Loading weights from trained MLP model & GMF model"""
config = self.config
mlp_model = MLP(config)
device_id = -1
if config['use_cuda'] is True:
mlp_model.cuda()
device_id = config['device_id']
resume_checkpoint(mlp_model,
model_dir=config['pretrain_mlp'],
device_id=device_id)
self.embedding_account_mlp.weight.data = mlp_model.embedding_account.weight.data
self.embedding_location_mlp.weight.data = mlp_model.embedding_location.weight.data
for idx in range(len(self.fc_layers)):
self.fc_layers[idx].weight.data = mlp_model.fc_layers[
idx].weight.data
config['latent_dim'] = config['latent_dim_mf']
gmf_model = GMF(config)
if config['use_cuda'] is True:
gmf_model.cuda()
resume_checkpoint(gmf_model,
model_dir=config['pretrain_mf'],
device_id=device_id)
self.embedding_account_mf.weight.data = gmf_model.embedding_account.weight.data
self.embedding_location_mf.weight.data = gmf_model.embedding_location.weight.data
self.embedding_account_mlp.require = False
self.embedding_location_mlp.require = False
self.embedding_account_mf.require = False
self.embedding_location_mf.require = False
def load(self, alias, epoch_id, hit_ratio, ndcg):
model_dir = self.config['model_dir'].format(alias, epoch_id, hit_ratio,
ndcg)
device_id = 0
if self.config['use_cuda'] is True:
device_id = self.config['device_id']
resume_checkpoint(self.model, model_dir=model_dir, device_id=device_id)
return self.model
def resume_model_from(self,
model_file_path,
strict=False,
resume_key='model'):
resume_checkpoint(self.net,
model_file_path,
strict=strict,
resume_key=resume_key)
def load_pretrain_weights(self):
"""Loading weights from trained GMF model"""
config = self.config
gmf_model = GMF(config)
if config['use_cuda'] is True:
gmf_model.cuda()
resume_checkpoint(gmf_model, model_dir=config['pretrain_mf'], device_id=config['device_id'])
self.embedding_user.weight.data = gmf_model.embedding_user.weight.data
self.embedding_item.weight.data = gmf_model.embedding_item.weight.data
def __init__(self, config):
self.model = MLP(config)
if config['use_cuda'] is True:
use_cuda(True, config['device_id'])
self.model.cuda()
if config['pretrain']:
#self.model.load_pretrain_weights()
resume_checkpoint(self.model,
model_dir=config['pretrain_mlp'],
device_id=config['device_id'])
super(MLPEngine, self).__init__(config)
print(self.model)
def load_pretrain_weights(self):
"""Loading weights from trained MLP model & GMF model"""
config = self.config
config['latent_dim'] = config['latent_dim_mlp']
mlp_model = MLP(config)
# if config['use_cuda'] is True:
# mlp_model.cuda()
# resume_checkpoint(mlp_model, model_dir = config['pretrain_mlp'], device_id = config['device_id'])
resume_checkpoint(mlp_model, model_dir=config['pretrain_mlp'])
# Get the user and item weights from the trained MLP model
self.embedding_user_mlp.weight.data = mlp_model.embedding_user.weight.data
self.embedding_item_mlp.weight.data = mlp_model.embedding_item.weight.data
for idx in range(len(self.fc_layers)):
self.fc_layers[idx].weight.data = mlp_model.fc_layers[
idx].weight.data
config['latent_dim'] = config['latent_dim_mf']
gmf_model = GMF(config)
# if config['use_cuda'] is True:
# gmf_model.cuda()
# resume_checkpoint(gmf_model, model_dir = config['pretrain_mf'], device_id = config['device_id'])
resume_checkpoint(gmf_model, model_dir=config['pretrain_mf'])
# Get the user and item weights from the trained GMF model
self.embedding_user_mf.weight.data = gmf_model.embedding_user.weight.data
self.embedding_item_mf.weight.data = gmf_model.embedding_item.weight.data
# Perform linear transformation to get the final weight and bias values from both MLP and GMF weights
self.affine_output.weight.data = 0.5 * torch.cat([
mlp_model.affine_output.weight.data,
gmf_model.affine_output.weight.data
],
dim=-1)
self.affine_output.bias.data = 0.5 * (
mlp_model.affine_output.bias.data +
gmf_model.affine_output.bias.data)
def load_pretrain_weights(self):
"""Loading weights from trained GMF model"""
config = self.config
gmf_model = GMF(config)
if config['use_cuda'] is True:
gmf_model.cuda()
resume_checkpoint(gmf_model, model_dir=config['pretrain_mf'], device_id=config['device_id'])
self.embedding_user.weight.data = gmf_model.embedding_user.weight.data
self.embedding_item.weight.data = gmf_model.embedding_item.weight.data
# class MLPEngine(Engine):
# """Engine for training & evaluating GMF model"""
# def __init__(self, config):
# self.model = MLP(config)
# if config['use_cuda'] is True:
# use_cuda(True, config['device_id'])
# self.model.cuda()
# super(MLPEngine, self).__init__(config)
# print(self.model)
# if config['pretrain']:
# self.model.load_pretrain_weights()
def load_pretrain_grouping(self):
"""Loading weights from trained GMF model"""
config = self.config
grouping_module = Grouping(config)
if config['use_cuda'] is True:
grouping_module.cuda()
resume_checkpoint(grouping_module,
model_dir=config['pretrain_grouping_module'],
device_id=config['device_id'])
self.attention_user.weight.data[:grouping_module.
num_users] = grouping_module.embedding_user.weight.data[:
grouping_module
.
num_users]
self.attention_item.weight.data[:grouping_module.
num_items] = grouping_module.embedding_item.weight.data[:
grouping_module
.
num_items]
self.attention_fc.weight = grouping_module.fc.weight
self.attention_fc.bias = grouping_module.fc.bias
logger.info("Selected target: {}".format(target))
logger.info("=" * 100)
## ==========================
# Initialize MDAN model
## ==========================
mdan = load_model('mdan', class_number, len(sources), extractor).to(device)
#optimizer = optim.Adadelta(mdan.parameters(), lr=learning_rate)
optimizer = optim.SGD(mdan.parameters(), lr=learning_rate, momentum=0.9)
scheduler = lr_scheduler.CyclicLR(optimizer,
base_lr=learning_rate,
max_lr=0.009)
# Decay LR by a factor of 0.1 every 7 epochs
#scheduler = lr_scheduler.StepLR(optimizer, step_size=25, gamma=0.1)
resume_epoch = 0
if constant.resume_train is True:
resume_epoch, model_state_dict, optimizer_state_dict = resume_checkpoint(
test_case_place, file_name='best_model.pt')
mdan.load_state_dict(model_state_dict)
optimizer.load_state_dict(optimizer_state_dict)
mdan.eval()
logger.info("Retain training from epoch {}".format(resume_epoch))
else:
mdan.train()
#scheduler_plateau = lr_scheduler.ReduceLROnPlateau(optimizer, patience=3, verbose=True)
#scheduler_warmup = GradualWarmupScheduler(optimizer, multiplier=8, total_epoch=5, after_scheduler=scheduler_plateau)
## ==========================
# MDAN Training
## ==========================
max_iter = int(constant.sampling_size / batch_size) + 1
best_acc = 0
model = model.cuda()
# optimizer
optimizer = optim.Adam(model.parameters(), lr=0.01)
# loss function
criterion = nn.CrossEntropyLoss()
if torch.cuda.is_available():
criterion = criterion.cuda()
# resume model from last epoch
last_epoch = 0
best_acc = 0
RESUME = True
if RESUME:
model, optimizer, last_epoch, best_acc = resume_checkpoint(
model, optimizer)
# Epoch iter
epochs = 50
for epoch in range(last_epoch + 1, epochs + 1):
# train
avg_loss, train_acc = train(model,
optimizer,
criterion,
train_data_loader,
epoch,
epochs,
print_freq=10)
is_best = best_acc < train_acc.avg
if is_best:
def main():
# Data Loader (Input Pipeline)
print('===>Model Type:', args.model_type)
print('loading dataset...')
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
num_workers=args.num_workers,
drop_last=True,
shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=args.test_batch_size,
num_workers=args.num_workers,
drop_last=True,
shuffle=False)
# Define models
print('building model...')
clf = CNN(input_channel=input_channel, n_outputs=num_classes).cuda()
print(clf.parameters)
# Optimizer
if args.optim == 'adam':
optimizer = torch.optim.Adam(clf.parameters(), lr=args.lr, \
betas=(args.beta1, args.momentum), weight_decay=args.weight_decay)
if args.optim == 'sgd_mom':
optimizer = torch.optim.SGD(clf.parameters(), lr=args.lr, \
momentum=args.momentum, weight_decay=args.weight_decay)
# learning rate schedule
if args.lr_scheduler == 'linear':
adjust_lr_linear = True
else:
scheduler = learning_rate_scheduler(optimizer, args)
adjust_lr_linear = False
print('Adjust lr linear [True/False]:', adjust_lr_linear)
best_test_acc=0
mean_pure_ratio=0
mean_pure_ratio1=0
if not args.resume:
epoch=0
train_acc=0
# evaluate models with random weights
test_acc, test_loss = evaluate(test_loader, clf, epoch)
print('Epoch [%d/%d] Test Accuracy on the 10000 test data: %.4f %%, Pure Ratio %.4f %%' % \
(epoch+1, args.n_epoch, test_acc, mean_pure_ratio))
# save results
with open(txtfile, "a") as myfile:
myfile.write(str(int(epoch)) + ': ' + str(train_acc) +' ' + str(test_acc) + ' ' \
+ str(mean_pure_ratio) + "\n")
else:
args.start_epoch, best_test_acc, optimizer, clf = \
resume_checkpoint(optimizer, clf, model_dir, model_str)
# training
for epoch in range(args.start_epoch, args.n_epoch):
# train models
clf.train()
# learning rate scheduler step
if adjust_lr_linear:
if args.model_type=='sigua_sl':
if args.optim == 'adam':
print('adjust learning rate adam sl')
adjust_learning_rate_adam_sl(optimizer, epoch)
else:
adjust_learning_rate_sgd(optimizer, epoch)
if args.model_type=='sigua_bc':
if args.optim == 'adam':
adjust_learning_rate_adam_bc(optimizer, epoch)
else:
adjust_learning_rate_sgd(optimizer, epoch)
else:
scheduler.step()
print('Training %s...' % model_str)
train_acc, pure_ratio_list = train(train_loader, epoch, clf, optimizer, args)
# evaluate models
print('Evaluating %s...' % model_str)
test_acc, test_loss = evaluate(test_loader, clf, epoch)
# save results
if args.model_type=='sigua_sl':
print('Epoch [%d/%d] Test Accuracy on the %s test data: %.4f %%, Pure Ratio %.4f %%' % \
(epoch+1, args.n_epoch, len(test_dataset), test_acc, mean_pure_ratio))
mean_pure_ratio = sum(pure_ratio_list)/len(pure_ratio_list)
with open(txtfile, "a") as myfile:
myfile.write(str(int(epoch)) + ': ' + str(train_acc) + ' ' + str(test_acc) + ' ' \
+ str(mean_pure_ratio) + "\n")
else:
print('Epoch [%d/%d] Test Accuracy on the %s test data: %.4f %%' % \
(epoch+1, args.n_epoch, len(test_dataset), test_acc))
with open(txtfile, "a") as myfile:
myfile.write(str(int(epoch)) + ': ' + str(train_acc) +' ' + str(test_acc) + "\n")
# remember best prec@1 and save checkpoint
is_best=test_acc > best_test_acc
best_test_acc=max(test_acc, best_test_acc)
if args.save_model:
save_checkpoint({
'epoch': epoch+1,
'state_dict': clf.state_dict(),
'best_prec1': best_test_acc,
'optimizer': optimizer.state_dict(),
}, is_best, model_dir, model_str)
print('Predicting %s...' % model_str)
preds, true=predict(test_loader, clf)
for p, t in zip(preds, true):
with open(txtfile.replace('.txt', '_pred.txt'), "a") as myfile:
myfile.write(str(p) +' ' + str(t) + "\n")
