def main(args):
np.random.seed(0)
torch.manual_seed(0)
start_time = time.time()
args.cuda = not args.no_cuda and torch.cuda.is_available()
timestamp = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
logger = logutil.Logger(os.path.join(args.log_root, timestamp))
# Load data
training_set, valid_set, testing_set, train_loader, valid_loader, test_loader = utils.get_cad_data(
args, prediction=True)
# Get data size and define model
edge_features, node_features, adj_mat, node_labels, sequence_id = training_set[
0]
edge_feature_size, node_feature_size = edge_features.shape[
0], node_features.shape[0]
model_args = {
'model_path': args.resume,
'edge_feature_size': edge_feature_size,
'node_feature_size': node_feature_size,
'message_size': edge_feature_size,
'link_hidden_size': 1024,
'link_hidden_layers': 2,
'propagate_layers': 3,
'subactivity_classes': 10,
'affordance_classes': 12
}
model = models.GPNN_CAD(model_args)
del edge_features, node_features, adj_mat, node_labels
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
criterion = torch.nn.MSELoss()
if args.cuda:
model = model.cuda()
criterion = criterion.cuda()
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
for epoch in range(args.start_epoch, args.epochs):
logger.log_value('learning_rate', args.lr).step()
# train for one epoch
train(train_loader,
model,
criterion,
optimizer,
epoch,
logger,
args=args)
# test on validation set
epoch_error = validate(valid_loader,
model,
criterion,
logger,
args=args)
epoch_errors.append(epoch_error)
if len(epoch_errors) == 10:
new_avg_epoch_error = np.mean(np.array(epoch_errors))
if avg_epoch_error - new_avg_epoch_error < 0.01:
pass
avg_epoch_error = new_avg_epoch_error
epoch_errors = list()
if epoch > 0 and epoch % 5 == 0:
args.lr *= args.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
is_best = epoch_error < best_epoch_error
best_epoch_error = min(epoch_error, best_epoch_error)
datasets.utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_epoch_error': best_epoch_error,
'avg_epoch_error': avg_epoch_error,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
print('best_epoch_error: {}, avg_epoch_error: {}'.format(
best_epoch_error, avg_epoch_error))
# For testing
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
validate(test_loader, model, criterion, logger, args=args, test=True)
print('Time elapsed: {:.2f}s'.format(time.time() - start_time))
def main(args):
np.random.seed(0)
torch.manual_seed(0)
start_time = time.time()
args.cuda = not args.no_cuda and torch.cuda.is_available()
timestamp = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
logger = logutil.Logger(os.path.join(args.log_root, timestamp))
# Load data
training_set, testing_set, train_loader, test_loader = utils.get_cad_data(
args)
features, labels, seg_lengths, total_length, activity, sequence_id = training_set[
0]
feature_size = features[0].shape[1]
label_num = len(datasets.cad_metadata.subactivities)
hidden_size = 256
hidden_layers = 2
model = models.BLSTM(feature_size, hidden_size, hidden_layers, label_num)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
criterion = loss_func
if args.cuda:
model = model.cuda()
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
for epoch in range(args.start_epoch, args.epochs):
logger.log_value('learning_rate', args.lr).step()
# train for one epoch
train(train_loader,
model,
criterion,
optimizer,
epoch,
logger,
args=args)
# test on validation set
epoch_error = validate(test_loader, model, args=args)
epoch_errors.append(epoch_error)
if len(epoch_errors) == 10:
new_avg_epoch_error = np.mean(np.array(epoch_errors))
if avg_epoch_error - new_avg_epoch_error < 0.01:
args.lr *= args.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
avg_epoch_error = new_avg_epoch_error
epoch_errors = list()
is_best = epoch_error < best_epoch_error
best_epoch_error = min(epoch_error, best_epoch_error)
datasets.utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_epoch_error': best_epoch_error,
'avg_epoch_error': avg_epoch_error,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
print('best_epoch_error: {}, avg_epoch_error: {}'.format(
best_epoch_error, avg_epoch_error))
# For testing
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
validate(test_loader, model, args=args, test=True)
print('Time elapsed: {:.2f}s'.format(time.time() - start_time))
def main(args):
np.random.seed(0)
torch.manual_seed(0)
start_time = time.time()
args.cuda = not args.no_cuda and torch.cuda.is_available()
timestamp = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
logger = logutil.Logger(os.path.join(args.log_root, timestamp))
# Load data
training_set, valid_set, testing_set, train_loader, valid_loader, test_loader = utils.get_vcoco_data(
args)
# get training hard-negatives
if os.path.exists('obj_action_pairs_cont.pkl'):
obj_action_pairs = pickle.load(open('obj_action_pairs_cont.pkl', 'rb'))
else:
obj_action_pairs = np.ones([81, 27])
for edge_features, node_features, part_human_id, adj_mat, node_labels, node_roles, obj_boxes, part_boxes, human_boxes, img_id, img_name, human_num, part_num, obj_num, obj_classes, part_classes, part_adj_mat, _ in train_loader:
for i in range(len(adj_mat)):
for obj_id in range(obj_num[i]):
for action_id in range(
len(node_labels[i][human_num[i] + obj_id])):
obj_action_pairs[obj_classes[i][obj_id],
action_id] += 1
obj_action_pairs = obj_action_pairs / np.sum(
obj_action_pairs, axis=-1, keepdims=True)
pickle.dump(obj_action_pairs, open('obj_action_pairs_cont.pkl', 'wb'))
# Evaluation setup
if not os.path.exists(args.eval_root):
os.makedirs(args.eval_root)
train_vcocoeval = get_vcocoeval(args, 'train')
val_vcocoeval = get_vcocoeval(args, 'val')
test_vcocoeval = get_vcocoeval(args, 'test')
# Get data size and define model
edge_features, node_features, part_human_id, adj_mat, node_labels, node_roles, obj_boxes, part_boxes, human_boxes, img_id, img_name, human_num, part_num, obj_num, obj_classes, part_classes, part_adj_mat, _ = training_set[
0]
edge_feature_size, node_feature_size = edge_features.shape[
2], node_features.shape[1]
# message_size = int(edge_feature_size/2)*2
# message_size = edge_feature_size*2
# message_size = 1024
message_size = edge_feature_size
model_args = {
'model_path': args.resume,
'edge_feature_size': edge_feature_size,
'node_feature_size': node_feature_size,
'message_size': message_size,
'link_hidden_size': 256,
'link_hidden_layers': args.link_layer,
'link_relu': False,
'update_hidden_layers': args.update_layer,
'update_dropout': 0.0,
'update_bias': True,
'propagate_layers': args.prop_layer,
'hoi_classes': action_class_num,
'roles_num': roles_num,
'resize_feature_to_message_size': False,
'feature_type': args.feature_type,
'po_type': args.po_type,
'suppress_hh': args.suppress_hh
}
if args.model_type == 'V1':
model = models.GPNN_VCOCO(model_args)
elif args.model_type == 'V2':
model = models.GPNN_VCOCO_v2(model_args)
elif args.model_type == 'PG':
model = models.GPNN_VCOCO_PG(model_args)
del edge_features, node_features, adj_mat
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
mse_loss = torch.nn.MSELoss(size_average=True)
multi_label_loss = torch.nn.MultiLabelSoftMarginLoss(size_average=True)
if args.cuda:
model = model.cuda()
mse_loss = mse_loss.cuda()
multi_label_loss = multi_label_loss.cuda()
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
for epoch in range(args.start_epoch, args.epochs):
logger.log_value('learning_rate', args.lr).step()
# train for one epoch
part_obj_prior = train(args, train_loader, model, mse_loss,
multi_label_loss, optimizer, epoch,
train_vcocoeval, logger, obj_action_pairs)
if args.debug:
break
# test on validation set
epoch_error = validate(args,
valid_loader,
model,
mse_loss,
multi_label_loss,
val_vcocoeval,
logger,
obj_action_pairs=obj_action_pairs)
epoch_errors.append(epoch_error)
if len(epoch_errors) == 2:
new_avg_epoch_error = np.mean(np.array(epoch_errors))
if avg_epoch_error - new_avg_epoch_error < 0.005:
pass
avg_epoch_error = new_avg_epoch_error
epoch_errors = list()
if epoch % 2 == 1:
print('Learning rate decrease')
args.lr *= args.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
is_best = epoch_error < best_epoch_error
best_epoch_error = min(epoch_error, best_epoch_error)
datasets.utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_epoch_error': best_epoch_error,
'avg_epoch_error': avg_epoch_error,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
print('best_epoch_error: {}, avg_epoch_error: {}'.format(
best_epoch_error, avg_epoch_error))
# For testing
# loaded_checkpoint = datasets.utils.load_best_checkpoint(args, model, optimizer)
# if loaded_checkpoint:
# args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
# validate(args, test_loader, model, mse_loss, multi_label_loss, test_vcocoeval, test=True)
print('Time elapsed: {:.2f}s'.format(time.time() - start_time))
print(args.resume)
def main(args):
np.random.seed(0)
torch.manual_seed(0)
start_time = time.time()
args.cuda = not args.no_cuda and torch.cuda.is_available()
timestamp = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
logger = logutil.Logger(os.path.join(args.log_root, timestamp))
# Load data
training_set, valid_set, testing_set, train_loader, valid_loader, test_loader, img_index = utils.get_hico_data(
args)
# Get data size and define model
edge_features, node_features, adj_mat, node_labels, sequence_id, det_classes, det_boxes, human_num, obj_num = training_set[
0]
edge_feature_size, node_feature_size = edge_features.shape[
2], node_features.shape[1]
model = units.LinkFunction(
'GraphConv', {
'edge_feature_size': edge_feature_size,
'link_hidden_size': 512,
'link_hidden_layers': 2,
'link_relu': False
})
del edge_features, node_features, adj_mat, node_labels
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
# criterion = torch.nn.MultiLabelSoftMarginLoss(size_average=True)
if args.cuda:
model = model.cuda()
# criterion = criterion.cuda()
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
for epoch in range(args.start_epoch, args.epochs):
logger.log_value('learning_rate', args.lr).step()
# train for one epoch
train(train_loader,
model,
criterion,
optimizer,
epoch,
evaluation,
logger,
args=args)
# test on validation set
epoch_error = validate(test_loader,
model,
criterion,
evaluation,
logger,
args=args)
epoch_errors.append(epoch_error)
if len(epoch_errors) == 2:
new_avg_epoch_error = np.mean(np.array(epoch_errors))
if avg_epoch_error - new_avg_epoch_error < 0.01:
args.lr *= args.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
avg_epoch_error = new_avg_epoch_error
epoch_errors = list()
is_best = epoch_error < best_epoch_error
best_epoch_error = min(epoch_error, best_epoch_error)
datasets.utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_epoch_error': best_epoch_error,
'avg_epoch_error': avg_epoch_error,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
print('best_epoch_error: {}, avg_epoch_error: {}'.format(
best_epoch_error, avg_epoch_error))
# For testing
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
validate(test_loader,
model,
criterion,
evaluation,
logger,
args=args,
test=True)
print('Time elapsed: {:.2f}s'.format(time.time() - start_time))
def main(args):
np.random.seed(0)
torch.manual_seed(0)
start_time = time.time()
args.cuda = not args.no_cuda and torch.cuda.is_available()
timestamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
logger = logutil.Logger(os.path.join(args.log_root, timestamp))
# Load data
training_set, valid_set, testing_set, train_loader, valid_loader, test_loader = utils.get_vcoco_data(args)
# Evaluation setup
if not os.path.exists(args.eval_root):
os.makedirs(args.eval_root)
train_vcocoeval = get_vcocoeval(args, 'train')
val_vcocoeval = get_vcocoeval(args, 'val')
test_vcocoeval = get_vcocoeval(args, 'test')
# Get data size and define model
edge_features, node_features, adj_mat, node_labels, node_roles, boxes, img_id, img_name, human_num, obj_num, classes = training_set[0]
edge_feature_size, node_feature_size = edge_features.shape[2], node_features.shape[1]
# message_size = int(edge_feature_size/2)*2
# message_size = edge_feature_size*2
# message_size = 1024
message_size = edge_feature_size
model_args = {'model_path': args.resume, 'edge_feature_size': edge_feature_size, 'node_feature_size': node_feature_size, 'message_size': message_size, 'link_hidden_size': 256, 'link_hidden_layers': 3, 'link_relu': False, 'update_hidden_layers': 1, 'update_dropout': False, 'update_bias': True, 'propagate_layers': 3, 'hoi_classes': action_class_num, 'roles_num': roles_num, 'resize_feature_to_message_size': False, 'feature_type': args.feature_type}
model = models.GPNN_VCOCO(model_args)
del edge_features, node_features, adj_mat, node_labels
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
mse_loss = torch.nn.MSELoss(size_average=True)
multi_label_loss = torch.nn.MultiLabelSoftMarginLoss(size_average=True)
if args.cuda:
model = model.cuda()
mse_loss = mse_loss.cuda()
multi_label_loss = multi_label_loss.cuda()
loaded_checkpoint = datasets.utils.load_best_checkpoint(args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
for epoch in range(args.start_epoch, args.epochs):
logger.log_value('learning_rate', args.lr).step()
# train for one epoch
train(args, train_loader, model, mse_loss, multi_label_loss, optimizer, epoch, train_vcocoeval, logger)
# test on validation set
epoch_error = validate(args, valid_loader, model, mse_loss, multi_label_loss, val_vcocoeval, logger)
epoch_errors.append(epoch_error)
if len(epoch_errors) == 2:
new_avg_epoch_error = np.mean(np.array(epoch_errors))
if avg_epoch_error - new_avg_epoch_error < 0.005:
pass
avg_epoch_error = new_avg_epoch_error
epoch_errors = list()
if epoch % 2 == 1:
print('Learning rate decrease')
args.lr *= args.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
is_best = epoch_error < best_epoch_error
best_epoch_error = min(epoch_error, best_epoch_error)
datasets.utils.save_checkpoint({'epoch': epoch + 1, 'state_dict': model.state_dict(),
'best_epoch_error': best_epoch_error, 'avg_epoch_error': avg_epoch_error,
'optimizer': optimizer.state_dict(), },
is_best=is_best, directory=args.resume)
print('best_epoch_error: {}, avg_epoch_error: {}'.format(best_epoch_error, avg_epoch_error))
# For testing
loaded_checkpoint = datasets.utils.load_best_checkpoint(args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
validate(args, test_loader, model, mse_loss, multi_label_loss, test_vcocoeval, test=True)
print('Time elapsed: {:.2f}s'.format(time.time() - start_time))
def main(args):
np.random.seed(0)
torch.manual_seed(0)
start_time = time.time()
args.cuda = not args.no_cuda and torch.cuda.is_available()
timestamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
logger = logutil.Logger(os.path.join(args.log_root, timestamp))
# Load data
training_set, valid_set, testing_set, train_loader, valid_loader, test_loader, img_index = utils.get_hico_data(args) #load the data with given batch size
# Get data size and define model
edge_features, node_features, adj_mat, node_labels, sequence_id, det_classes, det_boxes, human_num, obj_num = training_set[0]
edge_feature_size, node_feature_size = edge_features.shape[2], node_features.shape[1]
message_size = int(edge_feature_size/2)*2
model_args = {'model_path': args.resume, 'edge_feature_size': edge_feature_size, 'node_feature_size': node_feature_size, 'message_size': message_size, 'link_hidden_size': 512, 'link_hidden_layers': 2, 'link_relu': False, 'update_hidden_layers': 1, 'update_dropout': False, 'update_bias': True, 'propagate_layers': 3, 'hoi_classes': action_class_num, 'resize_feature_to_message_size': False}
model = models.GPNN_HICO(model_args) # construct GPNN structure for hico dataset
del edge_features, node_features, adj_mat, node_labels
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
mse_loss = torch.nn.MSELoss(size_average=True)
multi_label_loss = torch.nn.MultiLabelSoftMarginLoss(size_average=True)
if args.cuda:
model = model.cuda()
mse_loss = mse_loss.cuda()
multi_label_loss = multi_label_loss.cuda()
loaded_checkpoint = datasets.utils.load_best_checkpoint(args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
for epoch in range(args.start_epoch, args.epochs):
logger.log_value('learning_rate', args.lr).step()
# train for one epoch
train(train_loader, model, mse_loss, multi_label_loss, optimizer, epoch, logger)
# test on validation set
epoch_error = validate(valid_loader, model, mse_loss, multi_label_loss, logger)
epoch_errors.append(epoch_error)
if len(epoch_errors) == 2:
new_avg_epoch_error = np.mean(np.array(epoch_errors))
if avg_epoch_error - new_avg_epoch_error < 0.005:
print('Learning rate decrease')
avg_epoch_error = new_avg_epoch_error
epoch_errors = list()
if epoch % 5 == 0 and epoch > 0:
args.lr *= args.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
is_best = True
best_epoch_error = min(epoch_error, best_epoch_error)
datasets.utils.save_checkpoint({'epoch': epoch + 1, 'state_dict': model.state_dict(),
'best_epoch_error': best_epoch_error, 'avg_epoch_error': avg_epoch_error,
'optimizer': optimizer.state_dict(), },
is_best=is_best, directory=args.resume)
print('best_epoch_error: {}, avg_epoch_error: {}'.format(best_epoch_error, avg_epoch_error))
# For testing
loaded_checkpoint = datasets.utils.load_best_checkpoint(args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
# validate(test_loader, model, mse_loss, multi_label_loss, test=True)
gen_test_result(args, test_loader, model, mse_loss, multi_label_loss, img_index)
print('Time elapsed: {:.2f}s'.format(time.time() - start_time))
def main(args):
np.random.seed(0)
torch.manual_seed(0)
start_time = time.time()
# args.resume = None
args.cuda = not args.no_cuda and torch.cuda.is_available()
timestamp = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
logger = logutil.Logger(os.path.join(args.log_root, timestamp))
# Load data
training_set, valid_set, testing_set, train_loader, valid_loader, test_loader = utils.get_cad_data(
args)
# Get data size and define model
edge_features, node_features, adj_mat, node_labels, sequence_id = training_set[
0]
model = units.LinkFunction(
'GraphConvLSTM', {
'edge_feature_size': edge_features.shape[0],
'link_hidden_size': 1024,
'link_hidden_layers': 2
})
# model = units.LinkFunction('GraphConv', {'edge_feature_size': edge_features.shape[0], 'link_hidden_size': 1024, 'link_hidden_layers': 3})
del edge_features, node_features, adj_mat, node_labels
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
criterion = torch.nn.MSELoss()
evaluation = lambda output, target: torch.mean(torch.abs(output - target))
if args.cuda:
model = model.cuda()
criterion = criterion.cuda()
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
for epoch in range(args.start_epoch, args.epochs):
logger.log_value('learning_rate', args.lr).step()
# train for one epoch
train(train_loader,
model,
criterion,
optimizer,
epoch,
evaluation,
logger,
args=args)
# test on validation set
epoch_error = validate(valid_loader,
model,
criterion,
evaluation,
logger,
args=args)
epoch_errors.append(epoch_error)
if len(epoch_errors) == 15:
new_avg_epoch_error = np.mean(np.array(epoch_errors))
if avg_epoch_error - new_avg_epoch_error < 0.03:
args.lr *= args.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
avg_epoch_error = new_avg_epoch_error
epoch_errors = list()
is_best = epoch_error < best_epoch_error
best_epoch_error = min(epoch_error, best_epoch_error)
datasets.utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_epoch_error': best_epoch_error,
'avg_epoch_error': avg_epoch_error,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
print('best_epoch_error: {}, avg_epoch_error: {}'.format(
best_epoch_error, avg_epoch_error))
# For testing
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
validate(test_loader, model, criterion, evaluation, args=args)
print('Time elapsed: {:.2f}s'.format(time.time() - start_time))
def main(args):
# np.random.seed(0)
# torch.manual_seed(0)
start_time = time.time()
args.cuda = not args.no_cuda and torch.cuda.is_available()
timestamp = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
logger = logutil.Logger(os.path.join(args.log_root, timestamp))
# Load data
training_set, valid_set, testing_set, train_loader, valid_loader, test_loader = utils.get_vcoco_data(
args)
# Evaluation setup
if not os.path.exists(args.eval_root):
os.makedirs(args.eval_root)
train_vcocoeval = get_vcocoeval(args, 'train')
val_vcocoeval = get_vcocoeval(args, 'val')
test_vcocoeval = get_vcocoeval(args, 'test')
# Get data size and define model
edge_features, node_features, part_human_id, adj_mat, node_labels, node_roles, obj_boxes, part_boxes, human_boxes, img_id, img_name, human_num, part_num, obj_num, obj_classes, part_classes, part_adj_mat, _ = training_set[
0]
edge_feature_size, node_feature_size = edge_features.shape[
2], node_features.shape[1]
# message_size = int(edge_feature_size/2)*2
# message_size = edge_feature_size*2
# message_size = 1024
message_size = edge_feature_size
model_args = {
'model_path': args.resume,
'edge_feature_size': edge_feature_size,
'node_feature_size': node_feature_size,
'message_size': message_size,
'link_hidden_size': 256,
'link_hidden_layers': args.link_layer,
'link_relu': False,
'update_hidden_layers': args.update_layer,
'update_dropout': 0.0,
'update_bias': True,
'propagate_layers': args.prop_layer,
'hoi_classes': action_class_num,
'roles_num': roles_num,
'resize_feature_to_message_size': False,
'feature_type': args.feature_type
}
model = models.GPNN_VCOCO(model_args)
del edge_features, node_features, adj_mat
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
mse_loss = torch.nn.MSELoss(size_average=True)
multi_label_loss = torch.nn.MultiLabelSoftMarginLoss(size_average=True)
if args.cuda:
model = model.cuda()
mse_loss = mse_loss.cuda()
multi_label_loss = multi_label_loss.cuda()
loaded_checkpoint = datasets.utils.load_best_checkpoint(
args, model, optimizer)
if loaded_checkpoint:
args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
visualize(args, train_loader, model, mse_loss, multi_label_loss,
val_vcocoeval, logger)
visualize(args, valid_loader, model, mse_loss, multi_label_loss,
val_vcocoeval, logger)
visualize(args, test_loader, model, mse_loss, multi_label_loss,
val_vcocoeval, logger)
# For testing
# loaded_checkpoint = datasets.utils.load_best_checkpoint(args, model, optimizer)
# if loaded_checkpoint:
# args, best_epoch_error, avg_epoch_error, model, optimizer = loaded_checkpoint
# validate(args, test_loader, model, mse_loss, multi_label_loss, test_vcocoeval, test=True)
print('Time elapsed: {:.2f}s'.format(time.time() - start_time))
