def test(self):
epoch = self.load()
self.test_logger = get_logger('test.{}.{}'.format(
self.__class__.__name__, self.tag))
acc_meter = AverageMeter('test_accuracy')
for samples, labels in tqdm(self.dataset.test_loader(self.batch_size),
desc='Test'):
with tc.no_grad():
guids, image, bow = samples
preds = self.model(image, bow)
acc = self.metric(preds, labels)
acc_meter.add(acc.item(), labels.size(0))
_, top = preds.topk(self.metric.top_k, dim=1)
match = labels.unsqueeze(dim=1).eq(top).any(dim=1, keepdim=False)
for i, eq in enumerate(match):
if not bool(eq.item()):
guid = guids[i]
label = self.dataset.labels.inverse_transform(
labels[i].item())
preds = self.dataset.labels.inverse_transform(
top[i].cpu().numpy())
self.test_logger.info(
'Prediction failure: {} belongs to {}, but was predicted as {}'
.format(guid, label, preds))
self.test_logger.info(
'After {} epochs of training, {} = {:.4f}'.format(
epoch + 1, acc_meter.tag, acc_meter.read()))
def validate(model, val_loader, device, min_depth, max_depth, cfg):
model.eval()
metric = Metrics(max_depth=max_depth)
score = AverageMeter()
score_1 = AverageMeter()
with torch.no_grad():
for _, inputs in tqdm(enumerate(val_loader)):
rgb = inputs['color'].to(device) * 255.
sdepth = inputs['depth_gt'].to(device)
if cfg.colorize:
depth_color = inputs['depth_color'].to(device) * 255.
depth_in = torch.cat([sdepth, depth_color], 1)
else:
depth_in = sdepth
mask = (sdepth > 0).float()
output, _ = model(depth_in, mask, rgb)
if use_norm_depth:
output = torch.clamp(output, 0, 1.0)
output = min_depth + output * (max_depth - min_depth)
else:
output = torch.clamp(output, min_depth, max_depth)
output = output[:, 0:1].detach().cpu()
gt = inputs['depth_sd_gt']
metric.calculate(output, gt)
score.update(metric.get_metric('mae'), metric.num)
score_1.update(metric.get_metric('rmse'), metric.num)
model.train()
return score.avg, score_1.avg
def train(self, num_epochs, resume=False):
if resume:
start_epoch = self.load()
else:
start_epoch = 0
self.train_logger.info('-' * 100)
timer = TimeMeter()
tm = AverageMeter('train_loss')
for epoch in range(start_epoch, start_epoch + num_epochs):
tm.reset()
for samples, labels in tqdm(
self.dataset.train_loader(self.batch_size,
self.num_training_samples),
desc='Train epoch {}'.format(epoch + 1)):
_, image, bow = samples
preds = self.model(image, bow)
loss = self.loss_func(preds, labels)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
tm.add(loss.item(), labels.size(0))
vm_loss, vm_acc = self.eval()
if self.decayer.is_better(vm_acc.read(), self.decayer.best):
self.dump(epoch)
self.decayer.step(vm_acc.read())
self.train_logger.info(
'Epoch {:02d}, elapsed Time {:.2f}, {} = {:.4f}, {} = {:.4f}, {} = {:.4f}'
.format(epoch + 1, timer.read(), tm.tag,
tm.read(), vm_loss.tag, vm_loss.read(), vm_acc.tag,
vm_acc.read()))
def eval(self):
loss_meter = AverageMeter('valid_loss')
acc_meter = AverageMeter('valid_accuracy')
for samples, labels in tqdm(self.dataset.valid_loader(self.batch_size),
desc='Validation'):
with tc.no_grad():
_, image, bow = samples
preds = self.model(image, bow)
loss = self.loss_func(preds, labels)
loss_meter.add(loss.item(), labels.size(0))
acc = self.metric(preds, labels)
acc_meter.add(acc.item(), labels.size(0))
return loss_meter, acc_meter
def validate(self):
self.model.eval()
valid_loss = AverageMeter()
valid_acc = AccuracyMeter()
for i, (x, y) in enumerate(self.valid_loader):
x = Variable(x, volatile=True)
y = Variable(y).long()
if self.use_cuda:
x = x.cuda()
y = y.cuda()
output = self.model(x)
loss = F.cross_entropy(output, y)
valid_loss.update(float(loss.data), x.size(0))
y_pred = output.data.max(dim=1)[1]
correct = int(y_pred.eq(y.data).cpu().sum())
valid_acc.update(correct, x.size(0))
print('\nTrain Epoch [{}]: Average batch loss: {:.6f}\n'.format(
epoch, valid_acc.accuracy))
return valid_loss.average, valid_acc.accuracy
verbose=1,
min_lr=1e-7,
factor=.1)
earlystop = EarlyStopping(mode='max', patience=EARLY_STOP, percentage=False)
model, optimizer = amp.initialize(model,
optimizer,
opt_level='O1',
verbosity=0)
if TRAIN:
best_score, best_epoch, history = 0, 0, pd.DataFrame()
for epoch in range(MAX_EPOCH):
if LOVASZ_HINGE and epoch + 1 >= LOVASZ_HINGE:
seg_criterion_1 = lovasz_hinge
tt0 = datetime.now()
clf_loss_meter = AverageMeter()
seg_loss_1_meter = AverageMeter()
seg_loss_2_meter = AverageMeter()
seg_metric_meter = SegMeter()
train_clf_labels, train_clf_preds = [], []
optimizer.zero_grad()
for it, (images, classes, masks) in enumerate(train_dl, 1):
t0 = datetime.now()
model = model.train()
images, classes, masks = images.cuda(), classes.cuda().float(
), masks.cuda()
clf_logits, seg_logits = model(images)
clf_loss = clf_criterion(clf_logits, classes)
criterion = ArcFaceLoss(args.arcface_s, args.arcface_m, crit=args.crit)
#optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=0.9, weight_decay=args.wd, nesterov=True)
#optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.wd)
optimizer = radam(model.parameters(),
lr=args.learning_rate,
weight_decay=args.wd)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer,
T_max=len(train_loader) *
args.epochs,
eta_min=1e-6)
# Training
# 매 epoch마다 ./ckpt 파일에 모델이 저장됩니다.
# validation dataset 없이 모든 train data를 train하는 방식입니다.
if not args.test:
batch_time = AverageMeter()
losses = AverageMeter()
acc_score = AverageMeter()
gap_score = AverageMeter()
train_loss, train_acc = [], []
best_acc, best_gap, best_epoch, best_gap_epoch = 0, 0, 0, 0
end = time.time()
start_epoch = 0
if args.resume is not None:
model.load_state_dict(torch.load(args.resume))
start_epoch = int(args.resume[-7:-4])
print(f'Loaded {start_epoch} epoch..')
start_epoch += 1
def run(self):
self.net.eval()
for loader in [self.test_loader]:
for batch_idx, inputs in tqdm(enumerate(loader)):
depth_gt = inputs['depth_gt'].float()
depth_sd_gt = inputs['depth_sd_gt'].float()
# reduce scan lines
depth_map = depth_gt[0][0].numpy()
pc, coord = project_depth_to_points(depth_map)
reorg_pc, reorg_coord = restore_scan_line(pc, coord, verbose=not self.opt.dump)
reduced_pc, reduced_coord = reduce_scan_line(reorg_pc, reorg_coord, step=4)
# reduced_pc, reduced_coord = sample_scan_line(reorg_pc, reorg_coord, ratio=0.1)
print('pc:', pc.shape[0], '->', reduced_pc.shape[0])
reduced_depth = restore_depth_map(reduced_pc, reduced_coord, [self.opt.crop_h, self.opt.crop_w])
reduced_depth = torch.from_numpy(reduced_depth).float()
reduced_depth = reduced_depth.unsqueeze(0).unsqueeze(0)
raw = reduced_depth.to(self.device)
rgb = inputs['color'].float().to(self.device)
rgb = rgb*255.0
# crop
assert raw.size()[2:] == rgb.size()[2:]
h, w = raw.size()[2:]
assert h >= self.crop_h
assert w == self.crop_w # 1216 don't need crop w
h_cropped = h - self.crop_h
depth_gt = depth_gt[:,:, h_cropped:h, 0:self.crop_w]
depth_sd_gt = depth_sd_gt[:,:, h_cropped:h, 0:self.crop_w]
raw = raw[:,:, h_cropped:h, 0:self.crop_w]
rgb = rgb[:,:, h_cropped:h, 0:self.crop_w]
mask = (raw > 0).float()
output, _ = self.net(raw, mask, rgb)
if use_norm_depth == False:
output = torch.clamp(output, min=self.opt.min_depth, max=self.opt.max_depth)
else:
output = torch.clamp(output, min=0, max=1.0)
output = restore_depth(output, self.opt.min_depth, self.opt.max_depth)
output = output[:,0:1].detach().cpu()
metric = Metrics(max_depth=self.opt.max_depth)
mae = AverageMeter()
rmse = AverageMeter()
metric.calculate(output, depth_sd_gt)
mae.update(metric.get_metric('mae'), metric.num)
rmse.update(metric.get_metric('rmse'), metric.num)
print("model: mae {} rmse {}".
format(int(1000*mae.avg), int(1000*rmse.avg)))
if not self.opt.dump:
plot3d(reduced_pc)
fig = plt.figure(num=batch_idx, figsize=(8, 10))
plt_img(fig, 4, 1, 1, plt, inputs['color'][0], 'color')
plt_img(fig, 4, 1, 2, plt, depth_gt[0], 'depth')
plt_img(fig, 4, 1, 3, plt, raw.cpu()[0], 'depth')
plt_img(fig, 4, 1, 4, plt, output[0], 'depth')
plt.tight_layout()
plt.show()