def main():
global args
set_random_seed(1)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_devices
log_name = 'test.log' if args.evaluate else 'train.log'
log_name += time.strftime('-%Y-%m-%d-%H-%M-%S')
sys.stdout = Logger(osp.join(args.save_dir, log_name))
print('** Arguments **')
arg_keys = list(args.__dict__.keys())
arg_keys.sort()
for key in arg_keys:
print('{}: {}'.format(key, args.__dict__[key]))
torch.backends.cudnn.benchmark = True
datamanager = ImageDataManager(batch_size=args.batch_size)
trainloader, queryloader, galleryloader = datamanager.return_dataloaders()
print('Building model: {}'.format(args.arch))
model = build_model(args.arch,
4000,
args.bias,
args.bnneck,
pretrained=(not args.no_pretrained))
if args.load_weights and check_isfile(args.load_weights):
load_pretrained_weights(model, args.load_weights)
model.cuda()
if args.evaluate:
evaluate(model, queryloader, galleryloader, args.dist_metric,
args.normalize_feature)
return
criterion = CrossEntropyLoss(4000)
optimizer = torch.optim.Adam(model.parameters(),
lr=0.0003,
weight_decay=5e-04,
betas=(0.9, 0.999))
scheduler = build_lr_scheduler(optimizer, args.lr_scheduler, args.stepsize)
time_start = time.time()
print('=> Start training')
for epoch in range(args.start_epoch, args.max_epoch):
train(epoch, model, criterion, optimizer, trainloader)
scheduler.step()
if (epoch + 1) % 20 == 0:
save_checkpoint(
{
'state_dict': model.state_dict(),
'epoch': epoch + 1,
'optimizer': optimizer.state_dict(),
}, args.save_dir)
evaluate(model, queryloader, galleryloader, args.dist_metric,
args.normalize_feature)
elapsed = round(time.time() - time_start)
elapsed = str(datetime.timedelta(seconds=elapsed))
print('Elapsed {}'.format(elapsed))
def restore_model(self):
print("restoring model and seeds to initial state...")
model_device = next(
self.models[self.main_model_name].parameters()).device
get_model_attr(self.models[self.main_model_name],
'load_state_dict')(self.state_cacher.retrieve("model"))
self.optims[self.main_model_name].load_state_dict(
self.state_cacher.retrieve("optimizer"))
get_model_attr(self.models[self.main_model_name], 'to')(model_device)
set_random_seed(self.seed)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--config-file',
type=str,
default='',
help='path to config file')
parser.add_argument(
'--gpu-devices',
type=str,
default='',
)
parser.add_argument('opts',
default=None,
nargs=argparse.REMAINDER,
help='Modify config options using the command-line')
args = parser.parse_args()
cfg = get_default_config()
if args.config_file:
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
set_random_seed(cfg.train.seed)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_devices
log_name = 'test.log' if cfg.test.evaluate else 'train.log'
log_name += time.strftime('-%Y-%m-%d-%H-%M-%S')
sys.stdout = Logger(osp.join(cfg.data.save_dir, log_name))
print('Show configuration\n{}\n'.format(cfg))
torch.backends.cudnn.benchmark = True
datamanager = ImageDataManager(**imagedata_kwargs(cfg))
trainloader, queryloader, galleryloader = datamanager.return_dataloaders()
print('Building model: {}'.format(cfg.model.name))
model = build_model(cfg.model.name,
datamanager.num_train_pids,
'softmax',
pretrained=cfg.model.pretrained)
if cfg.model.load_weights and check_isfile(cfg.model.load_weights):
load_pretrained_weights(model, cfg.model.load_weights)
model = nn.DataParallel(model).cuda()
criterion = CrossEntropyLoss(datamanager.num_train_pids,
label_smooth=cfg.loss.softmax.label_smooth)
optimizer = build_optimizer(model, **optimizer_kwargs(cfg))
scheduler = build_lr_scheduler(optimizer, **lr_scheduler_kwargs(cfg))
if cfg.model.resume and check_isfile(cfg.model.resume):
cfg.train.start_epoch = resume_from_checkpoint(cfg.model.resume,
model,
optimizer=optimizer)
if cfg.test.evaluate:
distmat = evaluate(model,
queryloader,
galleryloader,
dist_metric=cfg.test.dist_metric,
normalize_feature=cfg.test.normalize_feature,
rerank=cfg.test.rerank,
return_distmat=True)
if cfg.test.visrank:
visualize_ranked_results(distmat,
datamanager.return_testdataset(),
'image',
width=cfg.data.width,
height=cfg.data.height,
save_dir=osp.join(cfg.data.save_dir,
'visrank'))
return
time_start = time.time()
print('=> Start training')
for epoch in range(cfg.train.start_epoch, cfg.train.max_epoch):
train(epoch,
cfg.train.max_epoch,
model,
criterion,
optimizer,
trainloader,
fixbase_epoch=cfg.train.fixbase_epoch,
open_layers=cfg.train.open_layers)
scheduler.step()
if (epoch + 1) % cfg.test.eval_freq == 0 or (epoch +
1) == cfg.train.max_epoch:
rank1 = evaluate(model,
queryloader,
galleryloader,
dist_metric=cfg.test.dist_metric,
normalize_feature=cfg.test.normalize_feature,
rerank=cfg.test.rerank)
save_checkpoint(
{
'state_dict': model.state_dict(),
'epoch': epoch + 1,
'rank1': rank1,
'optimizer': optimizer.state_dict(),
}, cfg.data.save_dir)
elapsed = round(time.time() - time_start)
elapsed = str(datetime.timedelta(seconds=elapsed))
print('Elapsed {}'.format(elapsed))