def main():
global args, best_acc1
args = parser.parse_args()
# Check if CUDA is enabled
args.cuda = not args.no_cuda and torch.cuda.is_available()
# Load data
root = args.datasetPath
print('Prepare files')
files = [
f for f in os.listdir(root) if os.path.isfile(os.path.join(root, f))
]
idx = np.random.permutation(len(files))
idx = idx.tolist()
valid_ids = [files[i] for i in idx[0:10000]]
test_ids = [files[i] for i in idx[10000:20000]]
train_ids = [files[i] for i in idx[20000:]]
data_train = datasets.Qm9(root, train_ids)
data_valid = datasets.Qm9(root, valid_ids)
data_test = datasets.Qm9(root, test_ids)
# Define model and optimizer
print('Define model')
# Select one graph
g_tuple, l = data_train[0]
g, h_t, e = g_tuple
print('\tStatistics')
# stat_dict = datasets.utils.get_graph_stats(data_valid, ['degrees', 'target_mean', 'target_std', 'edge_labels'])
stat_dict = {}
stat_dict['degrees'] = [1, 2, 3, 4]
stat_dict['target_mean'] = np.array([
2.71802732e+00, 7.51685080e+01, -2.40259300e-01, 1.09503300e-02,
2.51209430e-01, 1.18997445e+03, 1.48493130e-01, -4.11609491e+02,
-4.11601022e+02, -4.11600078e+02, -4.11642909e+02, 3.15894998e+01
])
stat_dict['target_std'] = np.array([
1.58422291e+00, 8.29443552e+00, 2.23854977e-02, 4.71030547e-02,
4.77156393e-02, 2.80754665e+02, 3.37238236e-02, 3.97717205e+01,
3.97715029e+01, 3.97715029e+01, 3.97722334e+01, 4.09458852e+00
])
stat_dict['edge_labels'] = [1, 2, 3, 4]
data_train.set_target_transform(lambda x: datasets.utils.normalize_data(
x, stat_dict['target_mean'], stat_dict['target_std']))
data_valid.set_target_transform(lambda x: datasets.utils.normalize_data(
x, stat_dict['target_mean'], stat_dict['target_std']))
data_test.set_target_transform(lambda x: datasets.utils.normalize_data(
x, stat_dict['target_mean'], stat_dict['target_std']))
# Data Loader
train_loader = torch.utils.data.DataLoader(
data_train,
batch_size=args.batch_size,
shuffle=True,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
valid_loader = torch.utils.data.DataLoader(
data_valid,
batch_size=args.batch_size,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
test_loader = torch.utils.data.DataLoader(
data_test,
batch_size=args.batch_size,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
print('\tCreate model')
model = MpnnDuvenaud(stat_dict['degrees'],
[len(h_t[0]), len(list(e.values())[0])], [5, 15, 15],
30,
len(l),
type='regression')
print('Optimizer')
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.MSELoss()
evaluation = lambda output, target: torch.mean(
torch.abs(output - target) / torch.abs(target))
print('Logger')
logger = Logger(args.logPath)
lr_step = (args.lr - args.lr * args.lr_decay) / (
args.epochs * args.schedule[1] - args.epochs * args.schedule[0])
# get the best checkpoint if available without training
if args.resume:
checkpoint_dir = args.resume
best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
if not os.path.isdir(checkpoint_dir):
os.makedirs(checkpoint_dir)
if os.path.isfile(best_model_file):
print("=> loading best model '{}'".format(best_model_file))
checkpoint = torch.load(best_model_file)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded best model '{}' (epoch {})".format(
best_model_file, checkpoint['epoch']))
else:
print("=> no best model found at '{}'".format(best_model_file))
print('Check cuda')
if args.cuda:
print('\t* Cuda')
model = model.cuda()
criterion = criterion.cuda()
# Epoch for loop
for epoch in range(0, args.epochs):
if epoch > args.epochs * args.schedule[
0] and epoch < args.epochs * args.schedule[1]:
args.lr -= lr_step
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, evaluation,
logger)
# evaluate on test set
acc1 = validate(valid_loader, model, criterion, evaluation, logger)
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
# Logger step
logger.log_value('learning_rate', args.lr).step()
# get the best checkpoint and test it with test set
if args.resume:
checkpoint_dir = args.resume
best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
if not os.path.isdir(checkpoint_dir):
os.makedirs(checkpoint_dir)
if os.path.isfile(best_model_file):
print("=> loading best model '{}'".format(best_model_file))
checkpoint = torch.load(best_model_file)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded best model '{}' (epoch {})".format(
best_model_file, checkpoint['epoch']))
else:
print("=> no best model found at '{}'".format(best_model_file))
# For testing
validate(test_loader, model, criterion, evaluation)
def main():
global args, best_acc1
args = parser.parse_args()
# Check if CUDA is enabled
args.cuda = not args.no_cuda and torch.cuda.is_available()
# Load data
root = args.datasetPath
subset = args.subSet
print('Prepare files')
train_classes, train_ids = read_cxl(os.path.join(root, subset,
'train.cxl'))
test_classes, test_ids = read_cxl(os.path.join(root, subset, 'test.cxl'))
valid_classes, valid_ids = read_cxl(
os.path.join(root, subset, 'validation.cxl'))
class_list = list(set(train_classes + test_classes))
num_classes = len(class_list)
data_train = datasets.LETTER(root, subset, train_ids, train_classes,
class_list)
data_valid = datasets.LETTER(root, subset, valid_ids, valid_classes,
class_list)
data_test = datasets.LETTER(root, subset, test_ids, test_classes,
class_list)
# Define model and optimizer
print('Define model')
# Select one graph
g_tuple, l = data_train[0]
g, h_t, e = g_tuple
#TODO: Need attention
print('\tStatistics')
stat_dict = {}
# stat_dict = datasets.utils.get_graph_stats(data_train, ['edge_labels'])
stat_dict['edge_labels'] = [1]
# Data Loader
train_loader = torch.utils.data.DataLoader(
data_train,
batch_size=args.batch_size,
shuffle=True,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
valid_loader = torch.utils.data.DataLoader(
data_valid,
batch_size=args.batch_size,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
test_loader = torch.utils.data.DataLoader(
data_test,
batch_size=args.batch_size,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
print('\tCreate model')
model = MpnnIntNet([len(h_t[0]), len(list(e.values())[0])], [5, 15, 15],
[10, 20, 20],
num_classes,
type='classification')
print('Optimizer')
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.NLLLoss()
evaluation = utils.accuracy
print('Logger')
logger = Logger(args.logPath)
lr_step = (args.lr - args.lr * args.lr_decay) / (
args.epochs * args.schedule[1] - args.epochs * args.schedule[0])
# get the best checkpoint if available without training
if args.resume:
checkpoint_dir = args.resume
best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
if not os.path.isdir(best_model_file):
os.makedirs(checkpoint_dir)
if os.path.isfile(best_model_file):
print("=> loading best model '{}'".format(best_model_file))
checkpoint = torch.load(best_model_file)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded best model '{}' (epoch {}; accuracy {})".format(
best_model_file, checkpoint['epoch'], best_acc1))
else:
print("=> no best model found at '{}'".format(best_model_file))
print('Check cuda')
if args.cuda:
print('\t* Cuda')
model = model.cuda()
criterion = criterion.cuda()
# Epoch for loop
for epoch in range(0, args.epochs):
if epoch > args.epochs * args.schedule[
0] and epoch < args.epochs * args.schedule[1]:
args.lr -= lr_step
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, evaluation,
logger)
# evaluate on test set
acc1 = validate(valid_loader, model, criterion, evaluation, logger)
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
# Logger step
logger.log_value('learning_rate', args.lr).step()
# get the best checkpoint and test it with test set
if args.resume:
checkpoint_dir = args.resume
best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
if not os.path.isdir(best_model_file):
os.makedirs(checkpoint_dir)
if os.path.isfile(best_model_file):
print("=> loading best model '{}'".format(best_model_file))
checkpoint = torch.load(best_model_file)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded best model '{}' (epoch {}; accuracy {})".format(
best_model_file, checkpoint['epoch'], best_acc1))
else:
print("=> no best model found at '{}'".format(best_model_file))
# For testing
validate(test_loader, model, criterion, evaluation)
def main(opt):
if not os.path.exists(opt.resume):
os.makedirs(opt.resume)
if not os.path.exists(opt.logroot):
os.makedirs(opt.logroot)
log_dir_name = str(opt.manualSeed) + '/'
log_path = os.path.join(opt.logroot, log_dir_name)
opt.resume = os.path.join(opt.resume, log_dir_name)
if not os.path.exists(log_path):
os.makedirs(log_path)
#log_file_name = log_path + 'ucf_log_st.txt'
#log_file_name = opt.logroot + 'ucf_log_st_'+str(opt.manualSeed)+'.txt'
log_file_name = opt.logroot + 'something_log_v4.1_' + str(
opt.manualSeed) + '.txt'
with open(log_file_name, 'a+') as file:
file.write('manualSeed is %d \n' % opt.manualSeed)
paths = config.Paths()
train_datalist = "/home/mcislab/zhaojw/AAAI/sth_train_list.txt"
val_datalist = "/home/mcislab/zhaojw/AAAI/sth_val_list.txt"
test_datalist = "/home/mcislab/zhaojw/AAAI/sth_test_list.txt"
#test_datalist = '/home/mcislab/wangruiqi/IJCV2019/data/newsomething-check.txt'
#opt.resume = os.path.join(opt.resume,log_dir_name)
train_dataset = dataset(train_datalist, paths.sthv2_final, opt)
train_dataloader = DataLoader(train_dataset,
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.workers,
drop_last=False)
val_dataset = dataset(val_datalist, paths.sthv2_final, opt)
val_dataloader = DataLoader(val_dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.workers,
drop_last=False)
test_dataset = dataset(test_datalist, paths.sthv2_final, opt)
test_dataloader = DataLoader(test_dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.workers,
drop_last=False)
model = sthv2_model.Model(opt)
'''
if opt.show:
show(model)
exit()
'''
optimizer = optim.SGD(model.parameters(), lr=opt.lr, momentum=opt.momentum)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=100,
gamma=0.9)
criterion1 = nn.CrossEntropyLoss()
criterion2 = nn.NLLLoss()
if opt.cuda:
model.cuda()
#criterion.cuda(opt.device_id)
criterion1.cuda()
criterion2.cuda()
'''
if opt.epoch != 0:
if os.path.exists('./models/hmdb_split1/'+checkpoint_model_name):
model.load_state_dict(torch.load('./models/hmdb_split1/' + checkpoint_model_name))
else:
print('model not found')
exit()
'''
#Lin commented on Sept. 2nd
#model.double()
writer = SummaryWriter(log_dir=os.path.join(log_path, 'runs/'))
# For training
sum_test_acc = []
best_acc = 0.
#epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
'''
#haha, output Acc for each class
test_load_dir = opt.resume
#test_load_dir = '/home/mcislab/linhanxi/IJCV19_Experiments/sth_scale/something_scale5_M/ckpnothresh/ours'
model.load_state_dict(torch.load(os.path.join(test_load_dir, 'model_best.pth'))['state_dict'])
if opt.featdir:
model.feat_mode()
test_acc, output = test(0,test_dataloader, model, criterion1, criterion2, opt, writer, test_load_dir, is_test=True)
exit()
'''
print("Test once to get a baseline.")
loaded_checkpoint = utils.load_best_checkpoint(opt, model, optimizer)
if loaded_checkpoint:
opt, model, optimizer = loaded_checkpoint
test_acc, output = test(51,
test_dataloader,
model,
criterion1,
criterion2,
opt,
writer,
log_file_name,
is_test=True)
tmp_test_acc = np.mean(test_acc)
if tmp_test_acc > best_acc:
best_acc = tmp_test_acc
print("Start to train.....")
for epoch_i in range(opt.epoch, opt.niter):
scheduler.step()
train(epoch_i, train_dataloader, model, criterion1, criterion2,
optimizer, opt, writer, log_file_name)
#val_acc, val_out, val_error =test(valid_loader, model, criterion1,criterion2, opt, log_file_name, is_test=False)
# Lin changed according to 'sth_pre_abl1' on Sept. 3rd
test_acc, output = val(epoch_i,
val_dataloader,
model,
criterion1,
criterion2,
opt,
writer,
log_file_name,
is_test=True)
#test_acc,_ = test(test_dataloader, model, criterion1, criterion2, opt, log_file_name, is_test=True)
tmp_test_acc = np.mean(test_acc)
sum_test_acc.append(test_acc)
if tmp_test_acc > best_acc:
is_best = True
best_acc = tmp_test_acc
else:
is_best = False
utils.save_checkpoint(
{
'epoch': epoch_i,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
},
is_best=is_best,
directory=opt.resume)
print("A training epoch finished!")
#epoch_i =33
# For testing
print("Training finished.Start to test.")
loaded_checkpoint = utils.load_best_checkpoint(opt, model, optimizer)
if loaded_checkpoint:
opt, model, optimizer = loaded_checkpoint
# Lin changed according to 'sth_pre_abl1' on Sept. 3rd
test_acc, output = test(epoch_i,
test_dataloader,
model,
criterion1,
criterion2,
opt,
writer,
log_file_name,
is_test=True)
#test_acc,output = test(test_dataloader, model, criterion1,criterion2, opt, log_file_name, is_test=True)
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
print("ratio=0.1, test Accuracy: %.2f " % (100. * test_acc[0][0]))
print("ratio=0.2, test Accuracy: %.2f " % (100. * test_acc[0][1]))
print("ratio=0.3, test Accuracy: %.2f " % (100. * test_acc[0][2]))
print("ratio=0.4, test Accuracy: %.2f " % (100. * test_acc[0][3]))
print("ratio=0.5, test Accuracy: %.2f " % (100. * test_acc[0][4]))
print("ratio=0.6, test Accuracy: %.2f " % (100. * test_acc[0][5]))
print("ratio=0.7, test Accuracy: %.2f " % (100. * test_acc[0][6]))
print("ratio=0.8, test Accuracy: %.2f " % (100. * test_acc[0][7]))
print("ratio=0.9, test Accuracy: %.2f " % (100. * test_acc[0][8]))
print("ratio=1.0, test Accuracy: %.2f " % (100. * test_acc[0][9]))
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
def main(opt):
if not os.path.exists(opt.resume):
os.makedirs(opt.resume)
if not os.path.exists(opt.logroot):
os.makedirs(opt.logroot)
#log_dir_name = 'split'+opt.split + '/'
log_dir_name = 'split'+opt.split + '/'+str(opt.manualSeed)+'/'
opt.resume = os.path.join(opt.resume,log_dir_name)
log_path = os.path.join(opt.logroot,log_dir_name)
if not os.path.exists(log_path):
os.makedirs(log_path)
#log_file_name = log_path + 'ucf_log_st.txt'
log_file_name = log_path + 'ucf_log_v5.0_st_'+str(opt.manualSeed)+'.txt'
with open(log_file_name,'a+') as file:
file.write('manualSeed is %d \n' % opt.manualSeed)
file.write('state_dim is %d \n' % opt.state_dim)
file.write('num_bottleneck is %d \n' % opt.num_bottleneck)
paths = config.Paths()
train_datalist = '/home/mcislab/wangruiqi/IJCV2019/data/ucf101Vid_train_lin_split'+opt.split+'.txt'
test_datalist = '/home/mcislab/wangruiqi/IJCV2019/data/ucf101Vid_val_lin_split'+opt.split+'.txt'
#train_datalist = '/home/mcislab/wangruiqi/IJCV2019/data/test.txt'
#test_datalist = '/home/mcislab/wangruiqi/IJCV2019/data/test.txt'
#train_dataset = dataset(train_datalist, paths.detect_root_ucf_mmdet, paths.img_root_ucf,paths.rgb_res18_ucf,paths.rgb_res18_ucf, opt)
train_dataset = dataset(train_datalist, paths.bninception_ucf,opt)####zhao changed ###paths.resnet50_ucf_rgbflow_same
train_dataloader = DataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.workers, drop_last=False)
#test_dataset = dataset(test_datalist, paths.detect_root_ucf_mmdet, paths.img_root_ucf,paths.rgb_res18_ucf,paths.rgb_res18_ucf, opt)
test_dataset = dataset(test_datalist, paths.bninception_ucf,opt)###paths.resnet50_ucf_rgbflow_same
test_dataloader = DataLoader(test_dataset, batch_size=opt.batch_size, shuffle=False, num_workers=opt.workers, drop_last=False)
model = ucf_main_without_systhesizing_model.Model(opt)
#optimizer = optim.Adam(model.parameters(), lr=opt.lr, weight_decay=opt.weight_decay)
optimizer = optim.SGD(model.parameters(), lr=opt.lr,momentum=opt.momentum)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=200, gamma=0.9)
criterion1 = nn.CrossEntropyLoss()
criterion2 = nn.NLLLoss()
if opt.cuda:
model.cuda()
#criterion.cuda(opt.device_id)
criterion1.cuda()
criterion2.cuda()
'''
if opt.epoch != 0:
if os.path.exists('./models/hmdb_split1/'+checkpoint_model_name):
model.load_state_dict(torch.load('./models/hmdb_split1/' + checkpoint_model_name))
else:
print('model not found')
exit()
'''
#Lin commented on Sept. 2nd
#model.double()
writer = SummaryWriter(log_dir=log_path+'runs/')
# For training
sum_test_acc = []
best_acc = 0.
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
'''
#haha, output Acc for each class
model.load_state_dict(torch.load('/home/mcislab/linhanxi/ucf101_NewFeat_RGBtuned/ckpnothresh/ours/model_best.pth')['state_dict'])
test_acc, output = test(0,test_dataloader, model, criterion1, criterion2, opt, writer, log_file_name, is_test=True)
exit()
#load last experiment best model
print("load last experiment best model")
model.load_state_dict(torch.load('/home/mcislab/zhaojw/AAAI/prediction2020/models/ucf101_res50/split1/1050/model_best.pth')['state_dict'])
test_acc, output = test(0,test_dataloader, model, criterion1, criterion2, opt, writer, log_file_name, is_test=True)
'''
print ("Test once for a baseline.")
loaded_checkpoint =utils.load_best_checkpoint(opt, model, optimizer)
if loaded_checkpoint:
#opt, model, optimizer = loaded_checkpoint
opt, model, __ = loaded_checkpoint
test_acc, output = test(1,test_dataloader, model, criterion1, criterion2, opt, writer, log_file_name, is_test=True)
tmp_test_acc = np.mean(test_acc)
if tmp_test_acc > best_acc:
best_acc = tmp_test_acc
print ("Start to train.....")
#model.load_state_dict(torch.load('/home/mcislab/linhanxi/ucf101_flowOnly/ckpnothresh/ours/checkpoint.pth')['state_dict'])
for epoch_i in range(opt.epoch, opt.niter):
scheduler.step()
train(epoch_i, train_dataloader, model, criterion1, criterion2, optimizer, opt, writer, log_file_name)
#val_acc, val_out, val_error =test(valid_loader, model, criterion1,criterion2, opt, log_file_name, is_test=False)
# Lin changed according to 'sth_pre_abl1' on Sept. 3rd
test_acc, output = test(epoch_i,test_dataloader, model, criterion1, criterion2, opt, writer, log_file_name, is_test=True)
#test_acc,_ = test(test_dataloader, model, criterion1, criterion2, opt, log_file_name, is_test=True)
tmp_test_acc = np.mean(test_acc)
sum_test_acc.append(test_acc)
if tmp_test_acc > best_acc:
is_best = True
best_acc = tmp_test_acc
else:
is_best = False
utils.save_checkpoint({'epoch': epoch_i , 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict()},
is_best=is_best, directory=opt.resume)
print ("A training epoch finished!")
# For testing
print ("Training finished.Start to test.")
loaded_checkpoint = utils.load_best_checkpoint(opt, model, optimizer)
if loaded_checkpoint:
opt, model, __ = loaded_checkpoint
# Lin changed according to 'sth_pre_abl1' on Sept. 3rd
test_acc,output = test(epoch_i,test_dataloader, model, criterion1, criterion2, opt, writer, log_file_name, is_test=True)
#test_acc,output = test(test_dataloader, model, criterion1,criterion2, opt, log_file_name, is_test=True)
print ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
print ("ratio=0.1, test Accuracy: %.2f " % (100. * test_acc[0][0]))
print ("ratio=0.2, test Accuracy: %.2f " % (100. * test_acc[0][1]))
print ("ratio=0.3, test Accuracy: %.2f " % (100. * test_acc[0][2]))
print ("ratio=0.4, test Accuracy: %.2f " % (100. * test_acc[0][3]))
print ("ratio=0.5, test Accuracy: %.2f " % (100. * test_acc[0][4]))
print ("ratio=0.6, test Accuracy: %.2f " % (100. * test_acc[0][5]))
print ("ratio=0.7, test Accuracy: %.2f " % (100. * test_acc[0][6]))
print ("ratio=0.8, test Accuracy: %.2f " % (100. * test_acc[0][7]))
print ("ratio=0.9, test Accuracy: %.2f " % (100. * test_acc[0][8]))
print ("ratio=1.0, test Accuracy: %.2f " % (100. * test_acc[0][9]))
print ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
def main():
global args, best_er1
args = parser.parse_args()
# Check if CUDA is enabled
args.cuda = not args.no_cuda and torch.cuda.is_available()
# Load data
root = args.datasetPath
print('Prepare files')
files = [
f for f in os.listdir(root) if os.path.isfile(os.path.join(root, f))
]
idx = np.random.permutation(len(files))
idx = idx.tolist()
valid_ids = [files[i] for i in idx[0:10000]]
test_ids = [files[i] for i in idx[10000:20000]]
train_ids = [files[i] for i in idx[20000:]]
data_train = datasets.Qm9(root,
train_ids,
edge_transform=utils.qm9_edges,
e_representation='raw_distance')
data_valid = datasets.Qm9(root,
valid_ids,
edge_transform=utils.qm9_edges,
e_representation='raw_distance')
data_test = datasets.Qm9(root,
test_ids,
edge_transform=utils.qm9_edges,
e_representation='raw_distance')
# Define model and optimizer
print('Define model')
# Select one graph
g_tuple, l = data_train[0]
g, h_t, e = g_tuple
print('\tStatistics')
stat_dict = datasets.utils.get_graph_stats(data_valid,
['target_mean', 'target_std'])
data_train.set_target_transform(lambda x: datasets.utils.normalize_data(
x, stat_dict['target_mean'], stat_dict['target_std']))
data_valid.set_target_transform(lambda x: datasets.utils.normalize_data(
x, stat_dict['target_mean'], stat_dict['target_std']))
data_test.set_target_transform(lambda x: datasets.utils.normalize_data(
x, stat_dict['target_mean'], stat_dict['target_std']))
# Data Loader
train_loader = torch.utils.data.DataLoader(
data_train,
batch_size=args.batch_size,
shuffle=True,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
valid_loader = torch.utils.data.DataLoader(
data_valid,
batch_size=args.batch_size,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
test_loader = torch.utils.data.DataLoader(
data_test,
batch_size=args.batch_size,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
print('\tCreate model')
in_n = [len(h_t[0]), len(list(e.values())[0])]
hidden_state_size = 73
message_size = 73
n_layers = 3
l_target = len(l)
type = 'regression'
model = MPNN(in_n,
hidden_state_size,
message_size,
n_layers,
l_target,
type=type)
del in_n, hidden_state_size, message_size, n_layers, l_target, type
print('Optimizer')
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.MSELoss()
def evaluation(output, target):
return torch.mean(torch.abs(output - target) / torch.abs(target))
print('Logger')
logger = Logger(args.logPath)
lr_step = (args.lr - args.lr * args.lr_decay) / (
args.epochs * args.schedule[1] - args.epochs * args.schedule[0])
# get the best checkpoint if available without training
if args.resume:
checkpoint_dir = args.resume
best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
if not os.path.isdir(checkpoint_dir):
os.makedirs(checkpoint_dir)
if os.path.isfile(best_model_file):
print("=> loading best model '{}'".format(best_model_file))
checkpoint = torch.load(best_model_file)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_er1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded best model '{}' (epoch {})".format(
best_model_file, checkpoint['epoch']))
else:
print("=> no best model found at '{}'".format(best_model_file))
print('Check cuda')
if args.cuda:
print('\t* Cuda')
model = model.cuda()
criterion = criterion.cuda()
# Epoch for loop
for epoch in range(0, args.epochs):
if epoch > args.epochs * args.schedule[
0] and epoch < args.epochs * args.schedule[1]:
args.lr -= lr_step
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, evaluation,
logger)
# evaluate on test set
er1 = validate(valid_loader, model, criterion, evaluation, logger)
is_best = er1 > best_er1
best_er1 = min(er1, best_er1)
utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_er1': best_er1,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
# Logger step
logger.log_value('learning_rate', args.lr).step()
# get the best checkpoint and test it with test set
if args.resume:
checkpoint_dir = args.resume
best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
if not os.path.isdir(checkpoint_dir):
os.makedirs(checkpoint_dir)
if os.path.isfile(best_model_file):
print("=> loading best model '{}'".format(best_model_file))
checkpoint = torch.load(best_model_file)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_er1']
model.load_state_dict(checkpoint['state_dict'])
if args.cuda:
model.cuda()
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded best model '{}' (epoch {})".format(
best_model_file, checkpoint['epoch']))
else:
print("=> no best model found at '{}'".format(best_model_file))
# For testing
validate(test_loader, model, criterion, evaluation)
def main(opt):
if not os.path.exists(opt.resume):
os.makedirs(opt.resume)
if not os.path.exists(opt.logroot):
os.makedirs(opt.logroot)
paths = cad120_config.Paths()
#print (paths.tmp_root)
subject_ids = pickle.load(open(os.path.join(paths.tmp_root, 'cad120_data_list.p'), 'rb'))
data_path = os.path.join(paths.tmp_root, 'cad120_data_pred.p')
#data_path = '/media/mcislab/wrq/CAD120/pred-feature/cad120_data_pred.p'
test_acc_final = np.zeros([4, opt.seq_size])
sub_index = 0
resume_root = os.path.join(opt.resume,str(opt.manualSeed))
for sub, seqs in subject_ids.items(): # cross-validation for each subject
#sub='Subject'+str(opt.subject)
log_file_name = opt.logroot+'cad120_log_sub'+sub+'.txt'
with open(log_file_name,'a+') as file:
file.write('manualSeed is %d \n' % opt.manualSeed)
opt.resume = resume_root+ sub + '/'
training_subject = pickle.load(open(os.path.join(paths.tmp_root, 'cad120_data_list.p'), 'rb')) # if not reload it will delete both in subject_ids and training_sub
testing_subject = dict()
testing_subject[sub] = seqs
del training_subject[sub]
#print training_subject
#print testing_subject
training_set = CAD120(data_path, training_subject)
testing_set = CAD120(data_path, testing_subject)
#testing_set = CAD120(data_path, sequence_ids[-test_num:])
train_loader = torch.utils.data.DataLoader(training_set, collate_fn=utils.collate_fn_cad,batch_size=opt.batch_size,
num_workers=opt.workers, shuffle=True, pin_memory=True)
#valid_loader = torch.utils.data.DataLoader(valid_set, collate_fn=utils.collate_fn_cad,
# batch_size=opt.batch_size,
# num_workers=opt.workers, shuffle=False, pin_memory=True)
test_loader = torch.utils.data.DataLoader(testing_set,collate_fn=utils.collate_fn_cad,batch_size=opt.batch_size,
num_workers=opt.workers, shuffle=False, pin_memory=True)
model = models.Model(opt)
optimizer = optim.Adam(model.parameters(), lr=opt.lr, weight_decay=opt.weight_decay)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.9)
criterion1 = nn.CrossEntropyLoss()
criterion2 = nn.NLLLoss()
if opt.cuda:
model.cuda()
#criterion.cuda(opt.device_id)
criterion1.cuda()
criterion2.cuda()
loaded_checkpoint = utils.load_best_checkpoint(opt, model, optimizer)
if loaded_checkpoint:
opt, model, optimizer = loaded_checkpoint
'''
if opt.epoch != 0:
if os.path.exists('./models/hmdb_split1/'+checkpoint_model_name):
model.load_state_dict(torch.load('./models/hmdb_split1/' + checkpoint_model_name))
else:
print('model not found')
exit()
'''
#model.double()
writer = SummaryWriter(log_dir=opt.logroot+'runs/'+sub+'/')
# For training
sum_test_acc = []
best_acc = 0.
epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
for epoch_i in range(opt.epoch, opt.niter):
scheduler.step()
train(epoch_i, train_loader, model, criterion1,criterion2, optimizer, opt, writer, log_file_name)
#val_acc, val_out, val_error =test(valid_loader, model, criterion1,criterion2, opt, log_file_name, is_test=False)
test_acc,output = test(epoch_i,test_loader, model, criterion1, criterion2, opt,writer, log_file_name)
tmp_test_acc = np.mean(test_acc)
sum_test_acc.append(test_acc)
if tmp_test_acc > best_acc:
is_best = True
best_acc = tmp_test_acc
else:
is_best = False
utils.save_checkpoint({'epoch': epoch_i + 1, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict()},
is_best=is_best, directory=opt.resume)
# For testing
loaded_checkpoint = utils.load_best_checkpoint(opt, model, optimizer)
if loaded_checkpoint:
opt, model, optimizer = loaded_checkpoint
test_acc,output = test(epoch_i,test_loader, model, criterion1, criterion2, opt,writer, log_file_name)
print ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
print ("ratio=0.1, test Accuracy: %.2f " % (100. * test_acc[0][0]))
print ("ratio=0.2, test Accuracy: %.2f " % (100. * test_acc[0][1]))
print ("ratio=0.3, test Accuracy: %.2f " % (100. * test_acc[0][2]))
print ("ratio=0.4, test Accuracy: %.2f " % (100. * test_acc[0][3]))
print ("ratio=0.5, test Accuracy: %.2f " % (100. * test_acc[0][4]))
print ("ratio=0.6, test Accuracy: %.2f " % (100. * test_acc[0][5]))
print ("ratio=0.7, test Accuracy: %.2f " % (100. * test_acc[0][6]))
print ("ratio=0.8, test Accuracy: %.2f " % (100. * test_acc[0][7]))
print ("ratio=0.9, test Accuracy: %.2f " % (100. * test_acc[0][8]))
print ("ratio=1.0, test Accuracy: %.2f " % (100. * test_acc[0][9]))
print ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
sum_test_acc = np.array(sum_test_acc)
sum_test_acc=sum_test_acc.reshape(opt.niter, opt.seq_size)
scio.savemat(opt.logroot+sub+'_result.mat',{'test_acc':sum_test_acc})
scio.savemat(opt.logroot+sub+'_output.mat',{'test_out':output})
test_acc_final[sub_index, :] = test_acc
with open(log_file_name, 'a+') as file:
file.write("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n")
file.write("ratio=0.1, test Accuracy: %.2f \n" % (100. * test_acc[0][0]))
file.write("ratio=0.2, test Accuracy: %.2f \n" % (100. * test_acc[0][1]))
file.write("ratio=0.3, test Accuracy: %.2f \n" % (100. * test_acc[0][2]))
file.write("ratio=0.4, test Accuracy: %.2f \n" % (100. * test_acc[0][3]))
file.write("ratio=0.5, test Accuracy: %.2f \n" % (100. * test_acc[0][4]))
file.write("ratio=0.6, test Accuracy: %.2f \n" % (100. * test_acc[0][5]))
file.write("ratio=0.7, test Accuracy: %.2f \n" % (100. * test_acc[0][6]))
file.write("ratio=0.8, test Accuracy: %.2f \n" % (100. * test_acc[0][7]))
file.write("ratio=0.9, test Accuracy: %.2f \n" % (100. * test_acc[0][8]))
file.write("ratio=1.0, test Accuracy: %.2f \n" % (100. * test_acc[0][9]))
sub_index = sub_index + 1
writer.close()
test_final = np.mean(test_acc_final,0)
#print type(test_final)
#print test_final
print ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
print ("ratio=0.1, test Accuracy: %.2f " % (100. * test_final[0]))
print ("ratio=0.2, test Accuracy: %.2f " % (100. * test_final[1]))
print ("ratio=0.3, test Accuracy: %.2f " % (100. * test_final[2]))
print ("ratio=0.4, test Accuracy: %.2f " % (100. * test_final[3]))
print ("ratio=0.5, test Accuracy: %.2f " % (100. * test_final[4]))
print ("ratio=0.6, test Accuracy: %.2f " % (100. * test_final[5]))
print ("ratio=0.7, test Accuracy: %.2f " % (100. * test_final[6]))
print ("ratio=0.8, test Accuracy: %.2f " % (100. * test_final[7]))
print ("ratio=0.9, test Accuracy: %.2f " % (100. * test_final[8]))
print ("ratio=1.0, test Accuracy: %.2f " % (100. * test_final[9]))
print ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
with open(log_file_name, 'a+') as file:
file.write("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n")
file.write("Cross-subject performance is:\n")
file.write("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n")
file.write("ratio=0.1, test Accuracy: %.2f \n" % (100. * test_final[0]))
file.write("ratio=0.2, test Accuracy: %.2f \n" % (100. * test_final[1]))
file.write("ratio=0.3, test Accuracy: %.2f \n" % (100. * test_final[2]))
file.write("ratio=0.4, test Accuracy: %.2f \n" % (100. * test_final[3]))
file.write("ratio=0.5, test Accuracy: %.2f \n" % (100. * test_final[4]))
file.write("ratio=0.6, test Accuracy: %.2f \n" % (100. * test_final[5]))
file.write("ratio=0.7, test Accuracy: %.2f \n" % (100. * test_final[6]))
file.write("ratio=0.8, test Accuracy: %.2f \n" % (100. * test_final[7]))
file.write("ratio=0.9, test Accuracy: %.2f \n" % (100. * test_final[8]))
file.write("ratio=1.0, test Accuracy: %.2f \n" % (100. * test_final[9]))
def main():
global args
args = parser.parse_args()
# Check if CUDA is enabled
args.cuda = not args.no_cuda and torch.cuda.is_available()
# Load data
root = args.datasetPath
print('Prepare files')
label_file = 'labels.txt'
list_file = 'graphs.txt'
with open(os.path.join(root, label_file), 'r') as f:
l = f.read()
classes = [int(float(s) > 0.5)
for s in l.split()] #classes based on 0.5
# just makes them all 1
# print(set(classes))
unique, counts = np.unique(np.array(classes), return_counts=True)
print(dict(zip(unique, counts)))
with open(os.path.join(root, list_file), 'r') as f:
files = [s + '.pkl' for s in f.read().splitlines()]
train_ids, train_classes, valid_ids, valid_classes, test_ids, test_classes = divide_datasets(
files, classes)
#shuffle here
c = list(zip(train_ids, train_classes))
random.shuffle(c)
train_ids, train_classes = zip(*c)
data_train = PrGr(root, train_ids, train_classes)
print(data_train[0])
print(len(data_train))
data_valid = PrGr(root, valid_ids, valid_classes)
data_test = PrGr(root, test_ids, test_classes)
print(len(data_test))
# Define model and optimizer
print('Define model')
# Select one graph
g_tuple, l = data_train[6]
g, h_t, e = g_tuple
print('\tStatistics')
stat_dict = datasets.utils.get_graph_stats(data_train, ['degrees'])
# Data Loader
train_loader = torch.utils.data.DataLoader(
data_train,
batch_size=args.batch_size,
shuffle=False,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
valid_loader = torch.utils.data.DataLoader(
data_valid,
batch_size=args.batch_size,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
test_loader = torch.utils.data.DataLoader(
data_test,
batch_size=args.batch_size,
collate_fn=datasets.utils.collate_g,
num_workers=args.prefetch,
pin_memory=True)
print('\tCreate model')
num_classes = 2
print(stat_dict['degrees'])
model = MpnnDuvenaud(stat_dict['degrees'],
[len(h_t[0]), len(list(e.values())[0])], [7, 3, 5],
11,
num_classes,
type='classification')
print('Check cuda')
print('Optimizer')
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.NLLLoss()
evaluation = utils.accuracy
print('Logger')
logger = Logger(args.logPath)
lr_step = (args.lr - args.lr * args.lr_decay) / (
args.epochs * args.schedule[1] - args.epochs * args.schedule[0])
### get the best checkpoint if available without training
best_acc1 = 0
# if args.resume:
# checkpoint_dir = args.resume
# best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
# if not os.path.isdir(checkpoint_dir):
# os.makedirs(checkpoint_dir)
# if os.path.isfile(best_model_file):
# print("=> loading best model '{}'".format(best_model_file))
# checkpoint = torch.load(best_model_file)
# args.start_epoch = checkpoint['epoch']
# best_acc1 = checkpoint['best_acc1']
# model.load_state_dict(checkpoint['state_dict'])
# optimizer.load_state_dict(checkpoint['optimizer'])
# print("=> loaded best model '{}' (epoch {}; accuracy {})".format(best_model_file, checkpoint['epoch'],
# best_acc1))
# else:
# print("=> no best model found at '{}'".format(best_model_file))
print('Check cuda')
if args.cuda:
print('\t* Cuda')
model = model.cuda()
criterion = criterion.cuda()
# Epoch for loop
for epoch in range(0, args.epochs):
if epoch > args.epochs * args.schedule[
0] and epoch < args.epochs * args.schedule[1]:
args.lr -= lr_step
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, evaluation,
logger)
# evaluate on test set
acc1 = validate(valid_loader, model, criterion, evaluation, logger)
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=args.resume)
# Logger step
logger.log_value('learning_rate', args.lr).step()
# get the best checkpoint and test it with test set
# if args.resume:
# checkpoint_dir = args.resume
# best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
# if not os.path.isdir(checkpoint_dir):
# os.makedirs(checkpoint_dir)
# if os.path.isfile(best_model_file):
# print("=> loading best model '{}'".format(best_model_file))
# checkpoint = torch.load(best_model_file)
# args.start_epoch = checkpoint['epoch']
# best_acc1 = checkpoint['best_acc1']
# model.load_state_dict(checkpoint['state_dict'])
# optimizer.load_state_dict(checkpoint['optimizer'])
# print("=> loaded best model '{}' (epoch {}; accuracy {})".format(best_model_file, checkpoint['epoch'],
# best_acc1))
# else:
# print("=> no best model found at '{}'".format(best_model_file))
# For testing
validate(test_loader, model, criterion, evaluation)
torch.save(model, 'test.pth')
print(train_classes)
print(valid_classes)
print(test_classes)
def main():
global args, best_loss
# create necessary folders
os.makedirs('./checkpoints', exist_ok=True)
os.makedirs('./runs', exist_ok=True)
# create datasets
train_dataset = dsets.CARVANA(root=args.dir,
train=True,
transform=unet_transforms.Compose([
unet_transforms.Scale((256, 256)),
unet_transforms.ToNumpy(),
unet_transforms.RandomShiftScaleRotate(),
unet_transforms.ToTensor(),
]))
val_dataset = dsets.CARVANA(root=args.dir,
train=True,
transform=unet_transforms.Compose([
unet_transforms.Scale((256, 256)),
unet_transforms.ToNumpy(),
unet_transforms.ToTensor()
]))
num_val = int(len(train_dataset) * args.perc_val)
num_train = len(train_dataset) - num_val
# define the dataloader with the previous dataset
train_loader = torch.utils.data.DataLoader(
dataset=train_dataset,
batch_size=args.batch_size,
shuffle=True,
# sampler=data_samplers.ChunkSampler(num_train, start=0),
num_workers=4)
val_loader = torch.utils.data.DataLoader(
dataset=val_dataset,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
sampler=data_samplers.ChunkSampler(num_val, start=num_train),
num_workers=4)
# create model, define the loss function and the optimizer.
# Move everything to cuda
model = models.UNet1024().cuda()
criterion = {
'loss': models.BCEplusDice().cuda(),
'acc': models.diceAcc().cuda()
}
optimizer = optim.SGD(model.parameters(),
weight_decay=args.weight_decay,
lr=args.lr,
momentum=args.momentum,
nesterov=args.nesterov)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_loss = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
if args.evaluate:
validate(val_loader, model, criterion, checkpoint['epoch'])
return
# run the training loop
for epoch in range(args.start_epoch, args.epochs):
# adjust lr according to the current epoch
model_utils.adjust_learning_rate(optimizer, epoch, args.lr,
args.adjust_epoch)
# train for one epoch
curr_loss = train(train_loader, model, criterion, optimizer, epoch)
# evaluate the model
# curr_loss = validate(val_loader, model, criterion, epoch)
# store best loss and save a model checkpoint
is_best = curr_loss < best_loss
best_loss = max(curr_loss, best_loss)
data_utils.save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_loss': best_loss,
'optimizer': optimizer.state_dict(),
},
is_best,
folder='./checkpoints/',
filename=args.arch)
logger.close()
