def test(cfg):
logger = setup_logger(name="Test", level=cfg.LOGGER.LEVEL)
logger.info(cfg)
model = torch.load('ms_loss_net_car_5000.pkl')
model.eval()
logger.info("Validation")
val_loader = build_data(cfg, is_train=False)
labels = val_loader.dataset.label_list
labels = np.array([int(k) for k in labels])
feats = feat_extractor(model, val_loader, logger=logger)
ret_metric = RetMetric(feats=feats, labels=labels)
recall_curr = ret_metric.recall_k(1)
logger.info(f'Recall@1 : {recall_curr:.3f}')
def test(cfg):
logger = setup_logger(name="Train", level=cfg.LOGGER.LEVEL)
logger.info(cfg)
model = torch.load('net.pkl')
model.eval()
logger.info("Validation")
val_loader = build_data(cfg, is_train=False)
labels = val_loader[0].dataset.label_list
labels = np.array([int(k) for k in labels])
feats = feat_extractor(model, val_loader[0], logger=logger)
ret_metric = AccuracyCalculator(include=("precision_at_1", "mean_average_precision_at_r", "r_precision"), exclude=())
ret_metric = ret_metric.get_accuracy(feats, feats, labels, labels, True)
mapr_curr = ret_metric['mean_average_precision_at_r']
logger.info(f"ret_metric: {ret_metric}")
def extract(cfg, img_source, model_path=None):
logger = setup_logger(name="Feat", level=cfg.LOGGER.LEVEL)
model = build_model(cfg)
device = torch.device(cfg.MODEL.DEVICE)
model.to(device)
if model_path is not None:
print(f"load model {model_path} .......")
model_dict = torch.load(model_path)["model"]
model.load_state_dict(model_dict, strict=True)
print("model successfully loaded")
num_gpus = len(os.environ["CUDA_VISIBLE_DEVICES"].split(","))
if num_gpus > 1:
model = torch.nn.DataParallel(model)
transforms = build_transforms(cfg, is_train=False)
dataset = BaseDataSet(img_source,
False,
transforms=transforms,
mode=cfg.INPUT.MODE)
data_loader = DataLoader(
dataset,
collate_fn=collate_fn,
shuffle=False,
batch_size=cfg.DATA.TEST_BATCHSIZE * num_gpus,
num_workers=cfg.DATA.NUM_WORKERS,
pin_memory=False,
)
labels = dataset.label_list
feats = feat_extractor(model, data_loader, logger)
day_time = time.strftime("%Y-%m-%d", time.localtime())
npz_path = f"output/{day_time}_feat.npz"
np.savez(npz_path, feat=feats, upc=labels)
print(f"FEATS : \t {npz_path}")
def do_train(cfg, model, train_loader, val_loader, optimizer, scheduler,
criterion, checkpointer, device, checkpoint_period, arguments,
logger):
logger.info("Start training")
meters = MetricLogger(delimiter=" ")
max_iter = len(train_loader)
start_iter = arguments["iteration"]
best_iteration = -1
best_recall = 0
start_training_time = time.time()
end = time.time()
for iteration, (images, targets) in enumerate(train_loader, start_iter):
if iteration % cfg.VALIDATION.VERBOSE == 0 or iteration == max_iter:
model.eval()
logger.info('Validation')
labels = val_loader.dataset.label_list
labels = np.array([int(k) for k in labels])
feats = feat_extractor(model, val_loader, logger=logger)
ret_metric = RetMetric(feats=feats, labels=labels)
recall_curr = ret_metric.recall_k(1)
if recall_curr > best_recall:
best_recall = recall_curr
best_iteration = iteration
logger.info(
f'Best iteration {iteration}: recall@1: {best_recall:.3f}')
checkpointer.save(f"best_model")
else:
logger.info(
f'Recall@1 at iteration {iteration:06d}: {recall_curr:.3f}'
)
model.train()
model.apply(set_bn_eval)
data_time = time.time() - end
iteration = iteration + 1
arguments["iteration"] = iteration
scheduler.step()
images = images.to(device)
targets = torch.stack([target.to(device) for target in targets])
feats = model(images)
loss = criterion(feats, targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
batch_time = time.time() - end
end = time.time()
meters.update(time=batch_time, data=data_time, loss=loss.item())
eta_seconds = meters.time.global_avg * (max_iter - iteration)
eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
if iteration % 20 == 0 or iteration == max_iter:
logger.info(
meters.delimiter.join([
"eta: {eta}",
"iter: {iter}",
"{meters}",
"lr: {lr:.6f}",
"max mem: {memory:.1f} GB",
]).format(
eta=eta_string,
iter=iteration,
meters=str(meters),
lr=optimizer.param_groups[0]["lr"],
memory=torch.cuda.max_memory_allocated() / 1024.0 /
1024.0 / 1024.0,
))
if iteration % checkpoint_period == 0:
checkpointer.save("model_{:06d}".format(iteration))
total_training_time = time.time() - start_training_time
total_time_str = str(datetime.timedelta(seconds=total_training_time))
logger.info("Total training time: {} ({:.4f} s / it)".format(
total_time_str, total_training_time / (max_iter)))
logger.info(
f"Best iteration: {best_iteration :06d} | best recall {best_recall} ")
def do_train(
cfg,
model,
train_loader,
val_loader,
optimizer,
scheduler,
criterion,
checkpointer,
writer,
device,
checkpoint_period,
arguments,
logger,
):
logger.info("Start training")
meters = MetricLogger(delimiter=" ")
max_iter = cfg.SOLVER.MAX_ITERS
best_iteration = -1
best_mapr = 0
start_training_time = time.time()
end = time.time()
if cfg.XBM.ENABLE:
logger.info(">>> use XBM")
xbm = XBM(cfg)
iteration = 0
_train_loader = iter(train_loader)
while iteration <= max_iter:
try:
images, targets, indices = _train_loader.next()
except StopIteration:
_train_loader = iter(train_loader)
images, targets, indices = _train_loader.next()
if (iteration % cfg.VALIDATION.VERBOSE == 0
or iteration == max_iter) and iteration > 0:
model.eval()
logger.info("Validation")
labels = val_loader[0].dataset.label_list
labels = np.array([int(k) for k in labels])
feats = feat_extractor(model, val_loader[0], logger=logger)
ret_metric = AccuracyCalculator(
include=("precision_at_1", "mean_average_precision_at_r",
"r_precision"),
exclude=())
ret_metric = ret_metric.get_accuracy(feats, feats, labels, labels,
True)
mapr_curr = ret_metric['mean_average_precision_at_r']
for k, v in ret_metric.items():
log_info[f"e_{k}"] = v
scheduler.step(log_info[f"e_precision_at_1"])
# scheduler.step(log_info[f"R@1"])
log_info["lr"] = optimizer.param_groups[0]["lr"]
if mapr_curr > best_mapr:
best_mapr = mapr_curr
best_iteration = iteration
logger.info(f"Best iteration {iteration}: {ret_metric}")
else:
logger.info(
f"Performance at iteration {iteration:06d}: {ret_metric}")
flush_log(writer, iteration)
np.save(f"xbm_pos_freqs_{iteration:06d}.npy",
criterion.total_pos_freqs,
allow_pickle=True)
np.save(f"xbm_neg_freqs_{iteration:06d}.npy",
criterion.total_neg_freqs,
allow_pickle=True)
model.train()
data_time = time.time() - end
iteration = iteration + 1
arguments["iteration"] = iteration
images = images.to(device)
targets = targets.to(device)
feats = model(images)
if cfg.XBM.ENABLE and iteration > cfg.XBM.START_ITERATION:
xbm.enqueue_dequeue(feats.detach(), targets.detach())
loss = criterion(feats, targets, feats, targets)
log_info["batch_loss"] = loss.item()
if cfg.XBM.ENABLE and iteration > cfg.XBM.START_ITERATION:
xbm_feats, xbm_targets = xbm.get()
xbm_loss = criterion(feats, targets, xbm_feats, xbm_targets)
log_info["xbm_loss"] = xbm_loss.item()
loss = loss + cfg.XBM.WEIGHT * xbm_loss
optimizer.zero_grad()
loss.backward()
optimizer.step()
batch_time = time.time() - end
end = time.time()
meters.update(time=batch_time, data=data_time, loss=loss.item())
eta_seconds = meters.time.global_avg * (max_iter - iteration)
eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
if iteration % 20 == 0 or iteration == max_iter:
logger.info(
meters.delimiter.join([
"eta: {eta}",
"iter: {iter}",
"{meters}",
"lr: {lr:.6f}",
"max mem: {memory:.1f} GB",
]).format(
eta=eta_string,
iter=iteration,
meters=str(meters),
lr=optimizer.param_groups[0]["lr"],
memory=torch.cuda.max_memory_allocated() / 1024.0 /
1024.0 / 1024.0,
))
log_info["loss"] = loss.item()
flush_log(writer, iteration)
if iteration % checkpoint_period == 0 and cfg.SAVE:
checkpointer.save("model_{:06d}".format(iteration))
pass
del feats
del loss
total_training_time = time.time() - start_training_time
total_time_str = str(datetime.timedelta(seconds=total_training_time))
logger.info("Total training time: {} ({:.4f} s / it)".format(
total_time_str, total_training_time / (max_iter)))
logger.info(
f"Best iteration: {best_iteration :06d} | best MAP@R {best_mapr} ")
writer.close()
def do_train(
cfg,
model,
train_loader,
trainVal_loader,
val_loader,
optimizer,
optimizer_center,
scheduler,
scheduler_center,
criterion,
criterion_xbm,
checkpointer,
writer,
device,
arguments,
logger,
):
logger.info("Start training")
meters = MetricLogger(delimiter=" ")
max_iter = cfg.SOLVER.MAX_ITERS
best_iteration = -1
best_mapr = 0
start_training_time = time.time()
end = time.time()
USE_PRISM='PRISM' in cfg.LOSSES.NAME or 'PRISM' in cfg.LOSSES.NAME_XBM_LOSS
CHECK_NOISE=cfg.NOISE.CHECK_NOISE
if cfg.XBM.ENABLE:
logger.info(">>> use XBM")
xbm = XBM(cfg)
iteration = arguments["iteration"]+1
_train_loader = iter(train_loader)
while iteration <= max_iter:
try:
images, targets, indices = _train_loader.next()
except StopIteration:
_train_loader = iter(train_loader)
images, targets, indices = _train_loader.next()
if (iteration % cfg.VALIDATION.VERBOSE == 0 or iteration == max_iter) and iteration > 0:
model.eval()
logger.info("Validation")
if len(val_loader)==1:
labels = val_loader[0].dataset.label_list
labels = np.array([int(k) for k in labels])
feats = feat_extractor(model, val_loader[0], logger=logger)
feats_gallery=feats
feats_query=feats
labels_gallery=labels
labels_query=labels
else:
labels = val_loader[0].dataset.label_list
labels_gallery = np.array([int(k) for k in labels])
labels = val_loader[1].dataset.label_list
labels_query = np.array([int(k) for k in labels])
feats_gallery = feat_extractor(model, val_loader[0], logger=logger)
feats_query = feat_extractor(model, val_loader[1], logger=logger)
ret_metric = AccuracyCalculator(include=("precision_at_1", "mean_average_precision_at_r", "r_precision",'mean_average_precision_at_100'), exclude=())
ret_metric = ret_metric.get_accuracy(feats_query, feats_gallery, labels_query, labels_gallery, len(val_loader)==1)
mapr_curr = ret_metric['precision_at_1']
for k, v in ret_metric.items():
log_info[f"e_{k}"] = v
if cfg.SOLVER.LR_SCHEDULAR=='val':
scheduler.step(log_info['e_precision_at_1'])
log_info["lr"] = optimizer.param_groups[0]["lr"]
if mapr_curr > best_mapr:
best_mapr = mapr_curr
best_iteration = iteration
logger.info(f"Best iteration {iteration}: {ret_metric}")
checkpointer.save("model_best")
else:
logger.info(f"Performance at iteration {iteration:06d}: {ret_metric}")
flush_log(writer, iteration)
#======training set precision====
if iteration % cfg.VALIDATION.VERBOSE == 0 and iteration > 0:
logger.info("Validation on Training set")
labels = trainVal_loader.dataset.label_list
labels = np.array([int(k) for k in labels])
feats = feat_extractor(model, trainVal_loader, logger=logger)
feats_gallery=feats
feats_query=feats
labels_gallery=labels
labels_query=labels
ret_metric = AccuracyCalculator(include=("precision_at_1", "mean_average_precision_at_r", "r_precision",'mean_average_precision_at_100'), exclude=())
ret_metric = ret_metric.get_accuracy(feats_query, feats_gallery, labels_query, labels_gallery, len(trainVal_loader)==1)
mapr_curr = ret_metric['precision_at_1']
for k, v in ret_metric.items():
log_info[f"t_{k}"] = v
logger.info(f"Performance on Training set at iteration {iteration:06d}: {ret_metric}")
flush_log(writer, iteration)
#========
model.train()
data_time = time.time() - end
iteration = iteration + 1
arguments["iteration"] = iteration
images = images.to(device)
targets = targets.to(device)
feats = model(images)
if CHECK_NOISE:
is_noise=train_loader.dataset.is_noise[indices]
else:
is_noise=None
if cfg.XBM.ENABLE and iteration > cfg.XBM.START_ITERATION and (not USE_PRISM):
xbm.enqueue_dequeue(feats.detach(), targets.detach())
if (not USE_PRISM) or (iteration <= cfg.XBM.START_ITERATION):
loss = criterion(feats, targets, feats, targets)
log_info["batch_loss"] = loss.item()
if criterion_xbm is not None:
criterion_=criterion_xbm
else:
criterion_=criterion
if cfg.XBM.ENABLE and iteration > cfg.XBM.START_ITERATION:
xbm_feats, xbm_targets = xbm.get()
if USE_PRISM:
xbm_loss,p_in = criterion_(feats, targets, xbm_feats, xbm_targets,is_noise=is_noise)
if p_in is not None:
if p_in.dtype is torch.bool:
enqueue_feats=feats[p_in]
enqueue_targets=targets[p_in]
else:
enqueue_feats=feats
enqueue_targets=targets
if (p_in is not None) and (p_in.dtype is torch.bool):
selected_feats=feats[p_in]
selected_tar=targets[p_in]
loss = criterion(selected_feats, selected_tar, selected_feats, selected_tar)
else:
loss = criterion(feats, targets, feats, targets)
if not isinstance(loss,tuple):
log_info["batch_loss"] = loss.item()
else:
loss = 0
else:
xbm_loss = criterion(feats, targets, xbm_feats, xbm_targets)
loss = loss + cfg.XBM.WEIGHT * xbm_loss
optimizer.zero_grad()
if optimizer_center is not None:
optimizer_center.zero_grad()
if not isinstance(loss,(float,int)):
loss.backward()
optimizer.step()
if optimizer_center is not None:
optimizer_center.step()
if cfg.XBM.ENABLE and iteration > cfg.XBM.START_ITERATION and USE_PRISM:
xbm.enqueue_dequeue(enqueue_feats.detach(), enqueue_targets.detach())
if cfg.SOLVER.LR_SCHEDULAR!='val':
scheduler.step()
if scheduler_center is not None:
scheduler_center.step()
batch_time = time.time() - end
end = time.time()
meters.update(time=batch_time, data=data_time, loss=loss.item())
eta_seconds = meters.time.global_avg * (max_iter - iteration)
eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
if iteration % 20 == 0 or iteration == max_iter:
logger.info(
meters.delimiter.join(
[
"eta: {eta}",
"iter: {iter}",
"{meters}",
"lr: {lr:.6f}",
"max mem: {memory:.1f} GB",
]
).format(
eta=eta_string,
iter=iteration,
meters=str(meters),
lr=optimizer.param_groups[0]["lr"],
memory=torch.cuda.max_memory_allocated() / 1024.0 / 1024.0 / 1024.0,
)
)
log_info["loss"] = loss.item()
flush_log(writer, iteration)
del feats
del loss
total_training_time = time.time() - start_training_time
total_time_str = str(datetime.timedelta(seconds=total_training_time))
logger.info(
"Total training time: {} ({:.4f} s / it)".format(
total_time_str, total_training_time / (max_iter)
)
)
logger.info(f"Best iteration: {best_iteration :06d} | best MAP@R {best_mapr} ")
writer.close()