def main(project_name):
logger = Logger('_02_valid_model_{}'.format(project_name))
logger.info('=' * 50)
model_path = '_model/embedding_model_{}.pt'.format(project_name)
logger.info('load model from {}'.format(model_path))
model = torch.load(model_path)
evaluator = Evaluator()
evaluator.evaluate(model)
def main():
args = parse_args()
update_config(args.cfg_file)
if args.gpus:
config.GPUS = args.gpus
else:
config.CUDA = False
if args.workers:
config.WORKERS = args.workers
print('Using config:')
pprint.pprint(config)
torch.backends.cudnn.benchmark = config.CUDNN.BENCHMARK
torch.backends.cudnn.deterministic = config.CUDNN.DETERMINISTIC
torch.backends.cudnn.enabled = config.CUDNN.ENABLED
if config.CUDA:
os.environ["CUDA_VISIBLE_DEVICES"] = config.GPUS
device = torch.device('cuda' if config.CUDA else 'cpu')
# Redirect print to both console and log file
sys.stdout = Logger(osp.join(config.OUTPUT_DIR, 'log-eval.txt'))
# Create data loaders
dataset = DataSet(config.DATASET.ROOT, config.DATASET.DATASET)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transformer = T.Compose([
T.Resize(config.MODEL.IMAGE_SIZE, interpolation=3),
T.ToTensor(),
normalizer,
])
query_loader = DataLoader(
Preprocessor(dataset.query,
root=osp.join(dataset.images_dir, dataset.query_path), transform=transformer),
batch_size=config.TEST.BATCH_SIZE, num_workers=config.WORKERS,
shuffle=False, pin_memory=True)
gallery_loader = DataLoader(
Preprocessor(dataset.gallery,
root=osp.join(dataset.images_dir, dataset.gallery_path), transform=transformer),
batch_size=config.TEST.BATCH_SIZE, num_workers=config.WORKERS,
shuffle=False, pin_memory=True)
# Create model
model = models.create(config.MODEL.NAME)
# Load from checkpoint
checkpoint = load_checkpoint(config.TEST.MODEL_FILE)
print('best model at epoch: {}'.format(checkpoint['epoch']))
model.load_state_dict(checkpoint['state_dict'], strict=False)
# Set model
model = nn.DataParallel(model).to(device)
print('Test with best model:')
evaluator = Evaluator(model)
evaluator.evaluate(query_loader, gallery_loader, dataset.query,
dataset.gallery, config.TEST.OUTPUT_FEATURES)
def train(model, project_name):
sampler = Sampler()
loader = ImgLoader('../../input_large_delf/train')
evaluator = Evaluator()
dir_model = '_model'
os.makedirs(dir_model, exist_ok=True)
# for training
batch_size = 240
group_size = 12
iter_outside = 10
iter_inside = 500
optimizer = optim.Adam(filter(lambda p: p.requires_grad,
model.parameters()),
lr=1e-4)
for param_group in optimizer.param_groups:
logger.info('start lerning rate with: {:.6f}'.format(
param_group['lr']))
for ep in range(1, iter_outside + 1):
logger.info('-' * 30)
logger.info('epoch: {:d}'.format(ep))
model.train()
if ep > 1:
set_batch_norm_eval(model)
train_loss1 = 0
train_loss3 = 0
count_sample = 0
ave_good_index = 0
for _ in tqdm(range(iter_inside)):
batch = torch.FloatTensor(batch_size * group_size, 40,
1000).zero_()
ids = sampler.get_sample(batch_size, group_size)
for i in range(batch_size * group_size):
batch[i] = loader.load_image('{}.delf'.format(ids[i]))
batch_cuda = batch.cuda()
# forward with requires_grad=False
v_batch_no_bp = Variable(batch_cuda, volatile=True)
optimizer.zero_grad()
out = model.forward(v_batch_no_bp)
batch_indeces, num_good_index = get_apn_index(
out, batch_size, group_size)
# forward with requires_grad=True
v_batch = Variable(batch_cuda[batch_indeces, :, :])
optimizer.zero_grad()
out = model.forward(v_batch)
out_anchor = out[:batch_size]
hard_positive = out[batch_size:batch_size * 2]
hard_negative = out[batch_size * 2:batch_size * 3]
# calc loss
loss1 = smooth_pairwise_loss(out_anchor, hard_positive) * 0.1
loss3 = hard_negative_triplet_loss(out_anchor, hard_positive,
hard_negative)
loss = loss3
loss.backward()
optimizer.step()
train_loss1 += float(loss1.data.cpu().numpy()) * batch_size
train_loss3 += float(loss3.data.cpu().numpy()) * batch_size
ave_good_index += num_good_index * batch_size
count_sample += batch_size
logger.info('train loss (pair-pos): {:.6f}'.format(train_loss1 /
count_sample))
logger.info('train loss (triplet) : {:.6f}'.format(train_loss3 /
count_sample))
logger.info('average number of far negative: {:.2f} / {:d}'.format(
ave_good_index / count_sample, batch_size))
evaluator.evaluate(model)
if ep % 4 == 0 and ep != iter_outside:
model_name = 'embedding_model_{}_ep{}.pt'.format(project_name, ep)
logger.info('save model: {}'.format(model_name))
torch.save(model, os.path.join(dir_model, model_name))
if ep % 8 == 0:
for param_group in optimizer.param_groups:
param_group['lr'] *= 0.1
logger.info('change learning rate into: {:.6f}'.format(
param_group['lr']))
model_name = 'embedding_model_{}.pt'.format(project_name)
logger.info('save model: {}'.format(model_name))
torch.save(model, os.path.join(dir_model, model_name))
def train(model, project_name):
sampler = SubSampler()
list_train_imgs = sampler.get_train_imgs()
dataset = LandmarkDataset('../../input_large_delf/train', list_train_imgs)
evaluator = Evaluator()
dir_model = '_model'
os.makedirs(dir_model, exist_ok=True)
# for training
batch_size = 240
group_size = 12
iter_outside = 10
iter_inside = 600
optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=iter_outside * iter_inside)
for param_group in optimizer.param_groups:
logger.info('start lerning rate with: {:.6f}'.format(param_group['lr']))
for ep in range(1, iter_outside + 1):
logger.info('-' * 30)
logger.info('epoch: {:d}'.format(ep))
for param_group in optimizer.param_groups:
logger.info('current lerning rate with: {:.8f}'.format(param_group['lr']))
model.train()
if ep > 1:
set_batch_norm_eval(model)
train_loss1 = 0
train_loss3 = 0
count_sample = 0
ave_good_index = 0
pt_sampler = PyTorchSampler(sampler, batch_size, group_size, iter_inside)
dataloader = DataLoader(dataset, batch_sampler=pt_sampler, num_workers=8)
for batch in tqdm(dataloader):
batch_cuda = batch.cuda()
# forward with requires_grad=False
with torch.no_grad():
v_batch_no_bp = batch_cuda
optimizer.zero_grad()
out = model.forward(v_batch_no_bp)
batch_indeses, num_good_index = get_apn_index(out, batch_size, group_size)
# forward with requires_grad=True
v_batch = batch_cuda[batch_indeses, ...]
optimizer.zero_grad()
out = model.forward(v_batch)
out_anchor = out[:batch_size]
hard_positive = out[batch_size:batch_size*2]
hard_negative = out[batch_size*2:batch_size*3]
# calc loss
loss1 = smooth_pairwise_loss(out_anchor, hard_positive) * 0.1
loss3 = hard_negative_triplet_loss(out_anchor, hard_positive, hard_negative)
loss = loss3
loss.backward()
optimizer.step()
scheduler.step()
train_loss1 += float(loss1.data.cpu().numpy()) * batch_size
train_loss3 += float(loss3.data.cpu().numpy()) * batch_size
ave_good_index += num_good_index * batch_size
count_sample += batch_size
logger.info('train loss (pair-pos): {:.6f}'.format(train_loss1 / count_sample))
logger.info('train loss (triplet) : {:.6f}'.format(train_loss3 / count_sample))
logger.info('average number of far negative: {:.2f} / {:d}'.format(ave_good_index / count_sample, batch_size))
evaluator.evaluate(model)
if ep % 4 == 0 and ep != iter_outside:
model_name = 'embedding_model_{}_ep{}.pt'.format(project_name, ep)
logger.info('save model: {}'.format(model_name))
torch.save(model, os.path.join(dir_model, model_name))
model_name = 'embedding_model_{}.pt'.format(project_name)
logger.info('save model: {}'.format(model_name))
torch.save(model, os.path.join(dir_model, model_name))
def main():
args = parse_args()
update_config(args.cfg_file)
if args.gpus:
config.GPUS = args.gpus
else:
config.CUDA = False
if args.workers:
config.WORKERS = args.workers
print('Using config:')
pprint.pprint(config)
if args.manualSeed is None:
args.manualSeed = random.randint(1, 10000)
random.seed(args.manualSeed)
np.random.seed(args.manualSeed)
torch.manual_seed(args.manualSeed)
if config.CUDA:
torch.cuda.manual_seed_all(args.manualSeed)
torch.backends.cudnn.benchmark = config.CUDNN.BENCHMARK
torch.backends.cudnn.deterministic = config.CUDNN.DETERMINISTIC
torch.backends.cudnn.enabled = config.CUDNN.ENABLED
if config.CUDA:
os.environ["CUDA_VISIBLE_DEVICES"] = config.GPUS
device = torch.device('cuda' if config.CUDA else 'cpu')
# Redirect print to both console and log file
sys.stdout = Logger(osp.join(config.OUTPUT_DIR, 'log.txt'))
# Create data loaders
dataset = DataSet(config.DATASET.ROOT, config.DATASET.DATASET)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transformer = T.Compose([
T.RandomSizedRectCrop(*config.MODEL.IMAGE_SIZE),
T.RandomHorizontalFlip(),
T.RandomRotation(10),
T.ColorJitter(0.2, 0.2, 0.2),
T.ToTensor(),
normalizer,
T.RandomErasing(EPSILON=config.DATASET.RE),
])
test_transformer = T.Compose([
T.Resize(config.MODEL.IMAGE_SIZE, interpolation=3),
T.ToTensor(),
normalizer,
])
train_loader = DataLoader(UnsupervisedCamStylePreprocessor(
dataset.train,
root=osp.join(dataset.images_dir, dataset.train_path),
camstyle_root=osp.join(dataset.images_dir,
dataset.train_camstyle_path),
num_cam=dataset.num_cam,
use_gan=True,
transform=train_transformer),
batch_size=config.TRAIN.BATCH_SIZE,
num_workers=config.WORKERS,
shuffle=config.TRAIN.SHUFFLE,
pin_memory=True,
drop_last=False)
query_loader = DataLoader(Preprocessor(dataset.query,
root=osp.join(
dataset.images_dir,
dataset.query_path),
transform=test_transformer),
batch_size=config.TEST.BATCH_SIZE,
num_workers=config.WORKERS,
shuffle=False,
pin_memory=True)
gallery_loader = DataLoader(Preprocessor(dataset.gallery,
root=osp.join(
dataset.images_dir,
dataset.gallery_path),
transform=test_transformer),
batch_size=config.TEST.BATCH_SIZE,
num_workers=config.WORKERS,
shuffle=False,
pin_memory=True)
# Create model
model = models.create(config.MODEL.NAME,
pretrained=config.MODEL.PRETRAINED,
num_classes=dataset.num_train_ids)
# Memory Network
num_tgt = len(dataset.train)
memory = models.create('memory', config.MODEL.FEATURES, num_tgt)
# Load from checkpoint
if config.TRAIN.RESUME:
checkpoint = load_checkpoint(config.TRAIN.CHECKPOINT)
model.load_state_dict(checkpoint['state_dict'], strict=False)
memory.load_state_dict(checkpoint['state_dict_memory'], strict=False)
print("=> Start epoch {} ".format(checkpoint['epoch']))
# Set model
model = nn.DataParallel(model).to(device)
memory = memory.to(device)
# Optimizer
base_param_ids = set(map(id, model.module.base.parameters()))
base_params_need_for_grad = filter(lambda p: p.requires_grad,
model.module.base.parameters())
new_params = [p for p in model.parameters() if id(p) not in base_param_ids]
param_groups = [{
'params': base_params_need_for_grad,
'lr_mult': 0.1
}, {
'params': new_params,
'lr_mult': 1.0
}]
optimizer = get_optimizer(config, param_groups)
# Trainer
trainer = Trainer(config, model, memory)
def adjust_lr(epoch):
step_size = config.TRAIN.LR_STEP
lr = config.TRAIN.LR * (config.TRAIN.LR_FACTOR**(epoch // step_size))
for g in optimizer.param_groups:
g['lr'] = lr * g.get('lr_mult', 1)
best_r1 = 0.0
# Start training
for epoch in range(config.TRAIN.BEGIN_EPOCH, config.TRAIN.END_EPOCH):
# lr_scheduler.step()
adjust_lr(epoch)
trainer.train(epoch, train_loader, optimizer)
print('Test with latest model:')
evaluator = Evaluator(model)
r1 = evaluator.evaluate(query_loader, gallery_loader, dataset.query,
dataset.gallery, config.TEST.OUTPUT_FEATURES)
if r1 > best_r1:
best_r1 = r1
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'state_dict_memory': memory.state_dict(),
'epoch': epoch + 1,
},
fpath=osp.join(config.OUTPUT_DIR, 'checkpoint.pth.tar'))
print('\n * Finished epoch {:3d} \n'.format(epoch))
# Final test
print('Test with best model:')
evaluator = Evaluator(model)
checkpoint = load_checkpoint(
osp.join(config.OUTPUT_DIR, 'checkpoint.pth.tar'))
print('best model at epoch: {}'.format(checkpoint['epoch']))
model.module.load_state_dict(checkpoint['state_dict'])
evaluator.evaluate(query_loader, gallery_loader, dataset.query,
dataset.gallery, config.TEST.OUTPUT_FEATURES)
