def train(args, config):
# load data
print("Loading data")
train_dataset = data.get_loader(config.train_file, config.batch_size,
config.version)
dev_dataset = data.get_loader(config.dev_file, config.val_batch_size,
config.version)
with open(config.dev_eval_file, "r") as fh:
dev_eval_file = json.load(fh)
print("loading embeddings")
with open(config.word_emb_file, "rb") as fh:
word_mat = np.array(json.load(fh), dtype=np.float32)
with open(config.char_emb_file, "rb") as fh:
char_mat = np.array(json.load(fh), dtype=np.float32)
# create model
print("creating model")
if config.model_type == "model6":
Model = model_utils.get_model_func(config.model_type, config.version)
# get pretrained model from config
# takes a pretrained of QANet
model_dict_ = torch.load(config.pretrained_model,
pickle_module=dill)["model"]
model_dict = {}
for key in model_dict_:
model_dict[key[7:]] = model_dict_[key]
from models import QANet
pretrained_model = QANet(word_mat, char_mat, config)
# load its state
model_data = pretrained_model.state_dict()
model_data.update(model_dict)
pretrained_model.load_state_dict(model_data)
model = Model(pretrained_model, config).to(config.device)
model = torch.nn.DataParallel(model)
else:
Model = model_utils.get_model_func(config.model_type, config.version)
model = Model(word_mat, char_mat, config).to(config.device)
model = torch.nn.DataParallel(model)
print("Training Model")
trainer = Trainer(model, train_dataset, dev_dataset, dev_eval_file, config)
if args.model_file is not None:
trainer.load(args.model_file)
trainer.ema.resume(trainer.model)
trainer.train()
def get_data_loader(config):
if config.dataset.type == 'CIFAR10':
dataset = data.get_cifar10(config.dataset)
elif config.dataset.type == 'ImageNet':
dataset = data.get_image_net(config.dataset)
else:
raise KeyError('invalid dataset type')
train_loader, val_loader = data.get_loader(config.dataset, config.dataset.batch_size,
config.distributed.enable, *dataset)
max_iter = len(train_loader) * config.training.epoch
config.lr_scheduler.max_iter = max_iter
if config.get('arch_scheduler', None) is not None:
config.arch_scheduler.max_iter = max_iter
config.arch.start_train = max_iter // 2
config.arch_scheduler.warmup_step = max_iter // 2
return train_loader, val_loader
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--name', type=str, help='saved and resumed file name')
parser.add_argument('--resume', action='store_true', help='resumed flag')
parser.add_argument('--test',
dest='test_only',
default=False,
action='store_true')
parser.add_argument('--detctor',
default='2019-03-16_10:28:52{}.pth',
help='the name of detector')
parser.add_argument('--gpu', default='3', help='the chosen gpu id')
args = parser.parse_args()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
cudnn.benchmark = True
########################################## ARGUMENT SETTING ########################################
if args.test_only:
args.resume = True
if args.resume and not args.name:
raise ValueError('Resuming requires file name!')
name = args.name if args.name else datetime.now().strftime(
"%Y-%m-%d_%H:%M:%S")
if args.resume:
target_name = name
logs = torch.load(target_name)
# hacky way to tell the VQA classes that they should use the vocab without passing more params around
data.preloaded_vocab = logs['vocab']
else:
target_name = os.path.join('logs', '{}'.format(name))
if not args.test_only:
print('will save to {}'.format(target_name))
######################################### DATASET PREPARATION #######################################
if config.train_set == 'train':
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
elif args.test_only:
val_loader = data.get_loader(test=True)
else:
train_loader = data.get_loader(train=True, val=True)
val_loader = data.get_loader(test=True)
########################################## MODEL PREPARATION ########################################
embedding = bcolz.open(config.glove_path_filtered)[:]
net = model.RelAtt(embedding)
net = nn.DataParallel(net).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad],
lr=config.initial_lr,
weight_decay=1e-8)
# optimizer = optim.RMSprop(
# [p for p in net.parameters() if p.requires_grad],
# lr=config.initial_lr,
# momentum=0.20,
# weight_decay=1e-8
# )
scheduler = lr_scheduler.ExponentialLR(optimizer, 0.5**(1 / 50000))
#########################################
#######################################
acc_val_best = 0.0
start_epoch = 0
if args.resume:
net.load_state_dict(logs['model_state'])
optimizer.load_state_dict(logs['optim_state'])
scheduler.load_state_dict(logs['scheduler_state'])
start_epoch = logs['epoch']
acc_val_best = logs['acc_val_best']
tracker = utils.Tracker()
r = np.zeros(3)
for i in range(start_epoch, config.epochs):
if not args.test_only:
run(net,
train_loader,
optimizer,
scheduler,
tracker,
train=True,
prefix='train',
epoch=i)
if not (config.train_set == 'train+val'
and i in range(config.epochs - 5)):
r = run(net,
val_loader,
optimizer,
scheduler,
tracker,
train=False,
prefix='val',
epoch=i,
has_answers=(config.train_set == 'train'))
if not args.test_only:
results = {
'epoch': i,
'acc_val_best': acc_val_best,
'name': name,
'model_state': net.state_dict(),
'optim_state': optimizer.state_dict(),
'scheduler_state': scheduler.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2]
},
'vocab': val_loader.dataset.vocab,
}
if config.train_set == 'train' and r[1].mean() > acc_val_best:
acc_val_best = r[1].mean()
torch.save(results, target_name + '.pth')
if config.train_set == 'train+val':
torch.save(results, target_name + '{}.pth')
if i in range(config.epochs - 5, config.epochs):
saved_for_test(val_loader, r, i)
else:
saved_for_test(val_loader, r)
break
parser.add_argument('--trainsize',
type=int,
default=352,
help='input size')
parser.add_argument('--trainset',
type=str,
default='DUTS-TRAIN',
help='training dataset')
opt = parser.parse_args()
# data preparing, set your own data path here
data_path = 'C:\\Users\\RAZER\\Desktop\\SCRN-master\\F-360iSOD'
image_root = data_path + '/stimulis/'
gt_root = data_path + '/objects/'
train_loader = get_loader(image_root,
gt_root,
batchsize=opt.batchsize,
trainsize=opt.trainsize)
total_step = len(train_loader)
# build models
model = SCRN()
model.cuda()
params = model.parameters()
optimizer = torch.optim.SGD(params,
opt.lr,
momentum=0.9,
weight_decay=5e-4)
scheduler = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1)
CE = torch.nn.BCEWithLogitsLoss()
size_rates = [0.75, 1, 1.25] # multi-scale training
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--name', type=str, help='saved and resumed file name')
parser.add_argument('--resume', action='store_true', help='resumed flag')
parser.add_argument('--test', dest='test_only', action='store_true')
parser.add_argument(
'--lambd',
default=1,
type=float,
help='trade-off hyperparameters between two types of losses')
parser.add_argument('--gpu', default='0', help='the chosen gpu id')
global args
args = parser.parse_args()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
cudnn.benchmark = True
########################################## ARGUMENT SETTING ###############################
if args.test_only:
args.resume = True
if args.resume and not args.name:
raise ValueError('Resuming requires file name!')
name = args.name if args.name else datetime.now().strftime(
"%Y-%m-%d_%H:%M:%S")
if args.resume:
target_name = name
logs = torch.load(target_name)
else:
target_name = os.path.join('logs', '{}'.format(name))
if not args.test_only:
print('will save to {}'.format(target_name))
######################################### DATASET PREPARATION ###############################
if config.train_set == 'train':
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
elif args.test_only:
val_loader = data.get_loader(test=True)
else:
train_loader = data.get_loader(train=True, val=True)
val_loader = data.get_loader(test=True)
# load pre-trained word embedding (glove) for embedding answers
vocabs = val_loader.dataset.vocab
answer_vocab = vocabs['answer']
embedding, _, _ = word2vec.filter_glove_embedding(answer_vocab)
embedding = nn.Embedding.from_pretrained(embedding)
answer_idx_vocab = vocabs['answer_idx']
answer_idx_vocab = {int(a_idx): a for a_idx, a in answer_idx_vocab.items()}
########################################## MODEL PREPARATION #################################
net = model.Net(val_loader.dataset._num_tokens)
net = nn.DataParallel(net).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad],
lr=config.initial_lr)
scheduler = lr_scheduler.StepLR(optimizer, step_size=50000, gamma=0.4)
acc_val_best = 0.0
start_epoch = 0
if args.resume:
net.load_state_dict(logs['model_state'])
optimizer.load_state_dict(logs['optim_state'])
scheduler.load_state_dict(logs['scheduler_state'])
start_epoch = logs['epoch']
acc_val_best = logs['acc_val_best']
tracker = utils.Tracker()
r = np.zeros(3)
result_dict = {}
for i in range(start_epoch, config.epochs):
if not args.test_only:
run(net,
train_loader,
optimizer,
scheduler,
tracker,
train=True,
prefix='train',
embedding=embedding,
epoch=i)
if not (config.train_set == 'train+val'
and i in range(config.epochs - 5)):
r = run(net,
val_loader,
optimizer,
scheduler,
tracker,
train=False,
prefix='val',
epoch=i,
embedding=embedding,
has_answers=(config.train_set == 'train'),
answer_idx_vocab=answer_idx_vocab)
if not args.test_only:
results = {
'epoch': i,
'name': name,
'model_state': net.state_dict(),
'optim_state': optimizer.state_dict(),
'scheduler_state': scheduler.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
},
}
result_dict[i] = r[2]
if config.train_set == 'train' and r[1].mean() > acc_val_best:
acc_val_best = r[1].mean()
results['acc_val_best'] = acc_val_best
torch.save(results, target_name + '.pth')
if config.train_set == 'train+val':
torch.save(results, target_name + '.pth')
if i in range(config.epochs - 5, config.epochs):
saved_for_test(val_loader, r, i)
torch.save(results, target_name + '{}.pth'.format(i))
else:
saved_for_test(val_loader, r)
break
if config.train_set == 'train':
with open('./results.json', 'w') as fd:
json.dump(result_dict, fd)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--name', type=str, help='saved and resumed file name')
parser.add_argument('--resume', action='store_true', help='resumed flag')
parser.add_argument('--gpu', default='0', help='the chosen gpu id')
args = parser.parse_args()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
cudnn.benchmark = True
########################################## ARGUMENT SETTING #################################
if args.resume and not args.name:
raise ValueError('Resuming requires file name!')
name = args.name if args.name else datetime.now().strftime(
"%Y-%m-%d_%H:%M:%S")
if args.resume:
target_name = name
logs = torch.load(target_name)
else:
target_name = os.path.join('logs', '{}'.format(name))
print('will save to {}'.format(target_name))
######################################### DATASET PREPARATION #################################
with open(config.meta_data_path, 'r') as fd:
meta_data = json.load(fd)
train_loader = data.get_loader('train', meta_data)
if config.train_set == 'train':
val_loader = data.get_loader('val', meta_data)
if config.train_set == 'train+val':
val_loader = data.get_loader('test', meta_data)
########################################## MODEL PREPARATION ##################################
embeddings = bcolz.open(config.glove_path_filtered)[:]
net = model.Net(embeddings).cuda()
loss = nn.CrossEntropyLoss()
optimizer = optim.Adam(
[p for p in net.parameters() if p.requires_grad],
lr=config.initial_lr,
)
start_epoch = 0
recall_10_val_best = 0.0
if args.resume:
net.load_state_dict(logs['model_state'])
optimizer.load_state_dict(logs['optim_state'])
start_epoch = logs['epoch']
recall_10_val_best = logs['recall_10_val_best']
tracker = utils.Tracker()
best_epoch = start_epoch
state = 'Valid' if config.train_set == 'train' else 'Test'
for i in range(start_epoch, config.epochs):
run(net,
train_loader,
tracker,
optimizer,
loss_criterion=loss,
train=True,
prefix='train',
epoch=i)
results = {
'epoch': i,
'name': name,
'model_state': net.state_dict(),
'optim_state': optimizer.state_dict(),
}
if not config.train_set == 'all':
r = run(net,
val_loader,
tracker,
optimizer,
loss_criterion=loss,
train=False,
prefix='val',
epoch=i)
print("{} epoch {}: recall@1 is {:.4f}".format(state, i, r[0]),
end=", ")
print("recall@5 is {:.4f}, recall@10 is {:.4f}".format(r[1], r[2]))
if r[2] > recall_10_val_best:
recall_10_val_best = r[2]
results['recall_10_val_best'] = recall_10_val_best
best_epoch = i
recall_1_val_best = r[0]
recall_5_val_best = r[1]
torch.save(results, target_name + '.pth')
if not config.train_set == 'all':
print("The best performance of {} is on epoch {}".format(
state, best_epoch),
end=": ")
print("recall@1 is {:.4f}, recall@5 is {:.4f}, recall@10 is {:.4f}".
format(recall_1_val_best, recall_5_val_best, recall_10_val_best))
else:
torch.save(results, target_name + '.pth')
depth_root = trainfolder[trainset]["depth_root"]
anno = trainfolder[trainset]["anno"]
image_path = os.path.join(data_root, trainset, image_root)
gt_path = os.path.join(data_root, trainset, gt_root)
depth_path = os.path.join(data_root, trainset, depth_root)
if anno:
anno_path = os.path.join(data_root, trainset, anno)
else:
anno_path = None
image_paths += [image_path]
depth_paths += [depth_path]
gt_paths += [gt_path]
anno_paths += [anno_path]
train_loader = get_loader(image_paths,
gt_paths,
depth_paths,
anno_paths,
batchsize=opt.batchsize,
trainsize=opt.trainsize)
total_step = len(train_loader)
# build models
model = EFNet().cuda()
params = model.parameters()
optimizer = torch.optim.SGD(params, opt.lr, momentum=0.9, weight_decay=5e-4)
scheduler = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1)
CE = torch.nn.BCEWithLogitsLoss()
size_rates = [0.75, 1, 1.25] # multi-scale training
# training
for epoch in range(0, opt.epoch):
scheduler.step()
if opt.load is not None:
model.load_state_dict(torch.load(opt.load))
print('load model from ', opt.load)
optimizer = torch.optim.Adam(model.parameters(), opt.lr)
save_path = opt.save_path
if not os.path.exists(save_path):
os.makedirs(save_path)
# load data
print('load data...')
train_loader = get_loader(image_root=opt.train_root + 'images/',
gt_root=opt.train_root + 'masks/',
batchsize=opt.batchsize,
trainsize=opt.trainsize,
num_workers=8)
val_loader = test_dataset(image_root=opt.val_root + 'images/',
gt_root=opt.val_root + 'masks/',
testsize=opt.trainsize)
total_step = len(train_loader)
# logging
logging.basicConfig(
filename=save_path + 'log.log',
format='[%(asctime)s-%(filename)s-%(levelname)s:%(message)s]',
level=logging.INFO,
filemode='a',
datefmt='%Y-%m-%d %I:%M:%S %p')
logging.info("Network-Train")
