def test(args, split, loader, model, log, epoch, recorder):
model.eval()
log.printWrite('---- Start %s Epoch %d: %d batches ----' % (split, epoch, len(loader)))
timer = time_utils.Timer(args.time_sync);
disp_intv, save_intv, stop_iters = get_itervals(args, split)
res = []
with torch.no_grad():
for i, sample in enumerate(loader):
data = model_utils.parseData(args, sample, timer, split)
input = model_utils.getInput(args, data)
pred = model(input); timer.updateTime('Forward')
recoder, iter_res, error = prepareRes(args, data, pred, recorder, log, split)
res.append(iter_res)
iters = i + 1
if iters % disp_intv == 0:
opt = {'split':split, 'epoch':epoch, 'iters':iters, 'batch':len(loader),
'timer':timer, 'recorder': recorder}
log.printItersSummary(opt)
if iters % save_intv == 0:
results, nrow = prepareSave(args, data, pred)
log.saveImgResults(results, split, epoch, iters, nrow=nrow, error=error)
log.plotCurves(recorder, split, epoch=epoch, intv=disp_intv)
if stop_iters > 0 and iters >= stop_iters: break
res = np.vstack([np.array(res), np.array(res).mean(0)])
save_name = '%s_res.txt' % (args.suffix)
np.savetxt(os.path.join(args.log_dir, split, save_name), res, fmt='%.2f')
opt = {'split': split, 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def testOnBm(args, split, loader, model, log, epoch, recorder):
model.eval()
log.printWrite('---- Start %s Epoch %d: %d batches ----' % (split, epoch, len(loader)))
timer = time_utils.Timer(args.time_sync);
disp_intv, save_intv, stop_iters = get_itervals(args, split)
res = []
with torch.no_grad():
for i, sample in enumerate(loader):
#print("\nIn for:", sample['mask'].shape)
#print("sample :", sample.keys())
input = model_utils.parseData(args, sample, timer, split)
#input is a list
pred = model(input); timer.updateTime('Forward')
#recoder, iter_res, error = prepareRes(args, input, pred, recorder, log, split)
#print("data['img'].shape:", data['img'].shape)
#res.append(iter_res)
iters = i + 1
# if iters % disp_intv == 0:
# opt = {'split':split, 'epoch':epoch, 'iters':iters, 'batch':len(loader),
# 'timer':timer, 'recorder': recorder}
# log.printItersSummary(opt)
if iters % save_intv == 0:
results, nrow = prepareSave(args, input, pred, recorder, log)
log.saveImgResults(results, split, epoch, iters, nrow=nrow, error='')
#log.saveMatResults(pred['normal'], data['normal'], pred_c['dirs'], data['dirs'], split, epoch, iters, nrow=nrow, error='')
#log.plotCurves(recorder, split, epoch=epoch, intv=disp_intv)
if stop_iters > 0 and iters >= stop_iters: break
def train(args, loader, model, criterion, optimizer, log, epoch, recorder):
model.train()
log.printWrite('---- Start Training Epoch %d: %d batches ----' % (epoch, len(loader)))
timer = time_utils.Timer(args.time_sync);
for i, sample in enumerate(loader):
input = model_utils.parseshadowData(args, sample, timer, 'train')
optimizer.zero_grad()
pred = model(input); timer.updateTime('Forward')
loss = criterion.forward(255*pred['shadow'], 255*input['shadow']);
timer.updateTime('Crit');
criterion.backward(); timer.updateTime('Backward')
recorder.updateIter('train', loss.keys(), loss.values())
optimizer.step(); timer.updateTime('Solver')
iters = i + 1
if iters % args.train_disp == 0:
opt = {'split':'train', 'epoch':epoch, 'iters':iters, 'batch':len(loader),
'timer':timer, 'recorder': recorder}
log.printItersSummary(opt)
if iters % args.train_save == 0:
results, recorder, nrow = prepareSave(args, input, pred, recorder, log)
log.saveShadowResults(results, 'train', epoch, iters, nrow=nrow)
log.plotCurves(recorder, 'train', epoch=epoch, intv=args.train_disp)
if args.max_train_iter > 0 and iters >= args.max_train_iter: break
opt = {'split': 'train', 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def train(args, loader, models, criterion, optimizers, log, epoch, recorder):
models[1].train()
models[0].eval()
optimizer, optimizer_c = optimizers
log.printWrite('---- Start Training Epoch %d: %d batches ----' %
(epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
for i, sample in enumerate(loader):
data = model_utils.parseData(args, sample, timer, 'train')
input = model_utils.getInput(args, data)
with torch.no_grad():
pred_c = models[0](input)
input.append(pred_c)
s2_est_obMp = True
if s2_est_obMp:
start_loc, end_loc = 32, 96
random_loc = torch.randint(start_loc, end_loc, [2, 1])
input.append(random_loc)
data['ob_map_real'] = model_utils.parseData_stage2(
args, sample, random_loc, 'train')
pred = models[1](input)
timer.updateTime('Forward')
input.pop()
optimizer.zero_grad()
loss = criterion.forward(pred, data, random_loc, s2_est_obMp)
timer.updateTime('Crit')
criterion.backward()
timer.updateTime('Backward')
recorder.updateIter('train', loss.keys(), loss.values())
optimizer.step()
timer.updateTime('Solver')
iters = i + 1
if iters % args.train_disp == 0:
opt = {
'split': 'train',
'epoch': epoch,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.printItersSummary(opt)
if iters % args.train_save == 0:
results, recorder, nrow = prepareSave(args, data, pred_c, pred,
random_loc, recorder, log)
log.saveImgResults(results, 'train', epoch, iters, nrow=nrow)
log.plotCurves(recorder,
'train',
epoch=epoch,
intv=args.train_disp)
if args.max_train_iter > 0 and iters >= args.max_train_iter: break
opt = {'split': 'train', 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def train(args, loader, model, criterion, optimizers, log, epoch, recorder):
model.train()
optimizer, optimizer_c = optimizers
log.printWrite('---- Start Training Epoch %d: %d batches ----' %
(epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
for i, sample in enumerate(loader):
data = model_utils.parseReflectanceData(args, sample, timer, 'train')
input = model_utils.getReflectanceInput(args, data)
pred_r = model(input)
timer.updateTime('Forward')
optimizer.zero_grad()
# print('pred_r[reflectance].shape', pred_r['reflectance'].shape)
# print('input[reflectance].shape', input['reflectance'].shape)
loss = criterion.forward(255 * pred_r['reflectance'],
255 * data['reflectance'])
timer.updateTime('Crit')
criterion.backward()
timer.updateTime('Backward')
recorder.updateIter('train', loss.keys(), loss.values())
optimizer.step()
timer.updateTime('Solver')
# print('-----------------models parameters:----------\n')
# for name, parms in model.named_parameters():
# if name =='conv4.0.weight':
# try:
# print('-->name:', name, '-->grad_requirs:',parms.requires_grad, ' -->grad_value:',parms.grad[0][0][0][0])
# except IndexError:
# continue
iters = i + 1
if iters % args.train_disp == 0:
opt = {
'split': 'train',
'epoch': epoch,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.printItersSummary(opt)
if iters % args.train_save == 0:
results, recorder, nrow = prepareReflectanceSave(
args, data, pred_r, recorder, log)
log.saveImgResults(results, 'train', epoch, iters, nrow=nrow)
log.plotCurves(recorder,
'train',
epoch=epoch,
intv=args.train_disp)
if args.max_train_iter > 0 and iters >= args.max_train_iter: break
opt = {'split': 'train', 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def test(args, log, split, loader, model, epoch, recorder):
model.eval()
log.print_write('---- Start %s Epoch %d: %d batches ----' %
(split, epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
disp_intv, save_intv, stop_iters = get_itervals(args, split)
with torch.no_grad():
for i, sample in enumerate(loader):
data = model.parse_data(sample)
pred = model.forward()
timer.update_time('Forward')
loss = model.get_loss_terms()
if loss != None:
recorder.udpate_iter(split, loss.keys(), loss.values())
records, iter_res = model.prepare_records()
recorder.udpate_iter(split, records.keys(), records.values())
iters = i + 1
if iters % disp_intv == 0:
opt = {
'split': split,
'epoch': epoch,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.print_iters_summary(opt)
if iters % save_intv == 0:
visuals = model.prepare_visual()
nrow = min(data['img'].shape[0], 32)
log.save_img_results(visuals, split, epoch, iters, nrow=nrow)
log.plot_curves(recorder, split, epoch=epoch, intv=disp_intv)
if hasattr(args, 'save_detail') and args.save_detail or (
split == 'test'):
model.save_visual_detail(log, split, epoch, sample['path'],
sample['obj'])
if stop_iters > 0 and iters >= stop_iters: break
opt = {'split': split, 'epoch': epoch, 'recorder': recorder}
log.print_epoch_summary(opt)
def train(args, loader, model, criterion, optimizer, log, epoch, recorder,
tf_writer):
model.train()
print('---- Start Training Epoch %d: %d batches ----' %
(epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
for i, sample in enumerate(loader):
# hack to reduce training time
if args.iterations != 0 and i >= args.iterations: break
data = model_utils.parseData(args, sample, timer, 'train')
input = model_utils.getInput(args, data)
out_var = model(input)
timer.updateTime('Forward')
optimizer.zero_grad()
loss = criterion.forward(out_var, data['tar'])
timer.updateTime('Crit')
criterion.backward()
timer.updateTime('Backward')
recorder.updateIter('train', loss.keys(), loss.values())
optimizer.step()
timer.updateTime('Solver')
iters = i + 1
if iters % args.train_disp == 0:
opt = {
'split': 'train',
'epoch': epoch,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.printItersSummary(opt)
for tag, value in loss.items():
tfboard.tensorboard_scalar(tf_writer, tag, value, iters)
opt = {'split': 'train', 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def train(args, log, loader, model, epoch, recorder):
model.train()
log.print_write('---- Start Training Epoch %d: %d batches ----' %
(epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
for i, sample in enumerate(loader):
model.parse_data(sample)
pred = model.forward()
timer.update_time('Forward')
model.optimize_weights()
timer.update_time('Backward')
loss = model.get_loss_terms()
recorder.udpate_iter('train', loss.keys(), loss.values())
iters = i + 1
if iters % args.train_disp == 0:
opt = {
'split': 'train',
'epoch': epoch,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.print_iters_summary(opt)
if iters % args.train_save == 0:
records, _ = model.prepare_records()
visuals = model.prepare_visual()
recorder.udpate_iter('train', records.keys(), records.values())
nrow = min(args.batch, 32)
log.save_img_results(visuals, 'train', epoch, iters, nrow=nrow)
log.plot_curves(recorder,
'train',
epoch=epoch,
intv=args.train_disp)
if args.max_train_iter > 0 and iters >= args.max_train_iter: break
opt = {'split': 'train', 'epoch': epoch, 'recorder': recorder}
log.print_epoch_summary(opt)
def test(args, split, loader, model, log, epoch, recorder):
model.eval()
log.printWrite('---- Start %s Epoch %d: %d batches ----' % (split, epoch, len(loader)))
timer = time_utils.Timer(args.time_sync);
disp_intv, save_intv, stop_iters = get_itervals(args, split)
res = []
with torch.no_grad():
for i, sample in enumerate(loader):
#print("\nIn for:", sample['mask'].shape)
#print("sample :", sample.keys())
input = model_utils.parseData(args, sample, timer, split)
#input is a list
pred = model(input); timer.updateTime('Forward')
recoder, iter_res, error = prepareRes(args, input, pred, recorder, log, split)
#print("data['img'].shape:", data['img'].shape)
res.append(iter_res)
iters = i + 1
if iters % disp_intv == 0:
opt = {'split':split, 'epoch':epoch, 'iters':iters, 'batch':len(loader),
'timer':timer, 'recorder': recorder}
log.printItersSummary(opt)
if iters % save_intv == 0:
results, nrow = prepareSave(args, input, pred, recorder, log)
log.saveImgResults(results, split, epoch, iters, nrow=nrow, error='')
#log.saveMatResults(pred['normal'], data['normal'], pred_c['dirs'], data['dirs'], split, epoch, iters, nrow=nrow, error='')
log.plotCurves(recorder, split, epoch=epoch, intv=disp_intv)
if stop_iters > 0 and iters >= stop_iters: break
res = np.vstack([np.array(res), np.array(res).mean(0)])
save_name = '%s_res.txt' % (args.suffix)
np.savetxt(os.path.join(args.log_dir, split, save_name), res, fmt='%.2f')
if res.ndim > 1:
for i in range(res.shape[1]):
save_name = '%s_%d_res.txt' % (args.suffix, i)
np.savetxt(os.path.join(args.log_dir, split, save_name), res[:,i], fmt='%.3f')
opt = {'split': split, 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def test(args, split, loader, models, log, recorder):
models[0].eval()
models[1].eval()
log.printWrite('---- Start %s: %d batches ----' % (split, len(loader)))
timer = time_utils.Timer(args.time_sync)
disp_intv, save_intv, stop_iters = get_itervals(args, split)
with torch.no_grad():
for i, sample in enumerate(loader):
input_est, gt = model_utils.parseRefData(args, sample, timer,
'train')
pred_est = models[0](input_est)
timer.updateTime('Forward')
input_ref = model_utils.getRefInput(args, pred_est, input_est)
pred = models[1](input_ref)
timer.updateTime('Forward')
_, error = eval_utils.calSep(args, pred_est, input_est, input_ref,
gt, pred)
timer.updateTime('Crit')
recorder.updateIter(split, error.keys(), error.values())
iters = i + 1
if iters % disp_intv == 0:
opt = {
'split': split,
'epoch': 0,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.printItersSummary(opt)
if iters % save_intv == 0:
img_list, nrow = prepareSave(args, pred_est, input_est,
input_ref, gt, pred)
log.saveImgResults(img_list, 'test', 0, iters, nrow=nrow)
timer.updateTime('Record')
if stop_iters > 0 and iters >= stop_iters: break
opt = {'split': split, 'epoch': 0, 'recorder': recorder}
log.printEpochSummary(opt)
def test(args, split, loader, model, log, epoch, recorder, tf_writer):
model.eval()
print('---- Start %s Epoch %d: %d batches ----' %
(split, epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
disp_intv, save_intv = get_itervals(args, split)
with torch.no_grad():
for i, sample in enumerate(loader):
data = model_utils.parseData(args, sample, timer, split)
input = model_utils.getInput(args, data)
out_var = model(input)
timer.updateTime('Forward')
acc = eval_utils.calNormalAcc(data['tar'].data, out_var.data,
data['m'].data)
recorder.updateIter(split, acc.keys(), acc.values())
iters = i + 1
if iters % disp_intv == 0:
opt = {
'split': split,
'epoch': epoch,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.printItersSummary(opt)
for tag, value in acc.items():
tfboard.tensorboard_scalar(tf_writer, tag, value, iters)
if iters % save_intv == 0:
pred = (out_var.data + 1) / 2
masked_pred = pred * data['m'].data.expand_as(out_var.data)
log.saveNormalResults(masked_pred, split, epoch, iters)
opt = {'split': split, 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def train(args, loader, models, criterion, optimizers, log, epoch, recorder):
models[0].eval()
models[1].train()
models[2].train()
models[3].eval()
optimizer, optimizer_c = optimizers
log.printWrite('---- Start Training Epoch %d: %d batches ----' %
(epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
for i, sample in enumerate(loader):
data = model_utils.parsePokeData(args, sample, timer, 'train')
#data = {'img': img(n, 3*in_img_num, h, w),
# 'normal': normal(n, 3, h, w),
# 'mask': mask(n, 1, h, w),
# 'dirs': dirs(in_img_num*n, 3, h, w)
input = model_utils.getInput(args, data)
#input: list [data['img'], data['mask']]
pred_c = models[0](input)
# pred_c: {'dirs_x', 'dirs_y', 'dirs', 'ints', 'intens'}
input.append(pred_c)
pred_n = models[1](input)
timer.updateTime('Forward')
#dirs_n = torch.split(input[2]['dirs'], input[0].shape[0], 0)#长为in img num的n*3的list
input_r = {}
input_r['img'] = input[0]
input_r['mask'] = input[1]
pred_r = models[2](input_r)
input.append(pred_n)
input.append(pred_r)
shadow_input = prepareShadowInputs(input)
shadowlist = []
for s in shadow_input:
shadow = models[3](s)['shadow']
shadowlist.append(shadow)
pred_s = torch.cat(shadowlist, 1)
input.append(pred_s)
#input: list [data['img'], data['mask'],
# pred_c{'dirs_x', 'dirs_y', 'dirs', 'ints', 'intens'},
# pred_n{'normal'}, pred_r{'reflectance'},
# pred_s[batch, in_img_num*1, h, w]]
optimizer.zero_grad()
recon_inputs = reconInputs(args, input)
lights = recon_inputs['lights']
normal = pred_n['normal']
shadow = pred_s
reflectance = pred_r['reflectance']
recon = reconstruct(normal, reflectance, lights, shadow, data['mask'])
loss = criterion.forward(255 * recon, 255 * data['img'])
timer.updateTime('Crit')
criterion.backward()
timer.updateTime('Backward')
recorder.updateIter('train', loss.keys(), loss.values())
optimizer.step()
timer.updateTime('Solver')
# print('-----------------models parameters:----------\n')
# for name, parms in models[2].named_parameters():
# print('-->name:', name, '-->grad_requirs:',parms.requires_grad, ' -->grad_value:',parms.grad)
iters = i + 1
if iters % args.train_disp == 0:
opt = {
'split': 'train',
'epoch': epoch,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.printItersSummary(opt)
if iters % args.train_save == 0:
results, recorder, nrow = prepareSave(args, data, pred_c, pred_n,
recon, pred_r, pred_s,
recorder, log)
log.saveImgResults(results, 'train', epoch, iters, nrow=nrow)
#log.saveShadowResults(pred_s, 'train', epoch, iters, nrow=nrow)
log.plotCurves(recorder,
'train',
epoch=epoch,
intv=args.train_disp)
if args.max_train_iter > 0 and iters >= args.max_train_iter: break
opt = {'split': 'train', 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def test(args, split, loader, models, log, epoch, recorder):
models[0].eval()
models[1].eval()
models[2].eval()
models[3].eval()
log.printWrite('---- Start %s Epoch %d: %d batches ----' % (split, epoch, len(loader)))
timer = time_utils.Timer(args.time_sync);
disp_intv, save_intv, stop_iters = get_itervals(args, split)
res = []
with torch.no_grad():
for i, sample in enumerate(loader):
data = model_utils.parsestage4Data(args, sample, timer, 'train')
#data = {'img': img(n, 3*in_img_num, h, w),
# 'normal': normal(n, 3, h, w),
# 'mask': mask(n, 1, h, w),
# 'dirs': dirs(in_img_num*n, 3, h, w)
input = model_utils.getInput(args, data)
#input: list [data['img'], data['mask']]
pred_c = models[0](input);
# pred_c: {'dirs_x', 'dirs_y', 'dirs', 'ints', 'intens'}
input.append(pred_c)
pred_n = models[1](input); timer.updateTime('Forward')
#dirs_n = torch.split(input[2]['dirs'], input[0].shape[0], 0)#长为in img num的n*3的list
input_r = {}
input_r['img'] = input[0]
input_r['mask'] = input[1]
pred_r = models[2](input_r)
input.append(pred_n)
input.append(pred_r)
shadow_input = prepareShadowInputs(input)
shadowlist = []
for s in shadow_input:
shadow = models[3](s)['shadow']
shadowlist.append(shadow)
pred_s = torch.cat(shadowlist, 1)
input.append(pred_s)
#input: list [data['img'], data['mask'],
# pred_c{'dirs_x', 'dirs_y', 'dirs', 'ints', 'intens'},
# pred_n{'normal'}, pred_r{'reflectance'},
# pred_s[batch, in_img_num*1, h, w]]
recon_inputs = reconInputs(args, input)
lights = recon_inputs['lights']
normal = pred_n['normal']
shadow = pred_s
reflectance = pred_r['reflectance']
recon = reconstruct(normal, reflectance, lights, shadow)
recoder, iter_res, error = prepareNormalRes(args, data, pred_n, recorder, log, split)
#print("data['img'].shape:", data['img'].shape)
res.append(iter_res)
iters = i + 1
if iters % disp_intv == 0:
opt = {'split':split, 'epoch':epoch, 'iters':iters, 'batch':len(loader),
'timer':timer, 'recorder': recorder}
log.printItersSummary(opt)
if iters % save_intv == 0:
results, recorder, nrow = prepareSave(args, data, pred_n, pred_r, recon, recorder, log)
log.saveImgResults(results, split, epoch, iters, nrow=nrow, error='')
#log.saveMatResults(pred['normal'], data['normal'], pred_c['dirs'], data['dirs'], split, epoch, iters, nrow=nrow, error='')
log.plotCurves(recorder, split, epoch=epoch, intv=disp_intv)
if stop_iters > 0 and iters >= stop_iters: break
res = np.vstack([np.array(res), np.array(res).mean(0)])
save_name = '%s_res.txt' % (args.suffix)
np.savetxt(os.path.join(args.log_dir, split, save_name), res, fmt='%.2f')
if res.ndim > 1:
for i in range(res.shape[1]):
save_name = '%s_%d_res.txt' % (args.suffix, i)
np.savetxt(os.path.join(args.log_dir, split, save_name), res[:,i], fmt='%.3f')
opt = {'split': split, 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def test(args, split, loader, models, log, epoch, recorder):
models[0].eval()
models[1].eval()
log.printWrite('---- Start %s Epoch %d: %d batches ----' %
(split, epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
disp_intv, save_intv, stop_iters = get_itervals(args, split)
res = []
with torch.no_grad():
for i, sample in enumerate(loader):
data = model_utils.parseData(args, sample, timer, split)
input = model_utils.getInput(args, data)
pred_c = models[0](input)
timer.updateTime('Forward')
input.append(pred_c)
s2_est_obMp = True
if s2_est_obMp:
start_loc, end_loc = 32, 96
random_loc = torch.randint(start_loc, end_loc, [2, 1])
input.append(random_loc)
data['ob_map_real'] = model_utils.parseData_stage2(
args, sample, random_loc, 'train')
pred = models[1](input)
timer.updateTime('Forward')
input.pop()
recoder, iter_res, error = prepareRes(args, data, pred_c, pred,
random_loc, recorder, log,
split)
res.append(iter_res)
iters = i + 1
if iters % disp_intv == 0:
opt = {
'split': split,
'epoch': epoch,
'iters': iters,
'batch': len(loader),
'timer': timer,
'recorder': recorder
}
log.printItersSummary(opt)
if iters % save_intv == 0:
results, nrow = prepareSave(args, data, pred_c, pred,
random_loc)
log.saveImgResults(results,
split,
epoch,
iters,
nrow=nrow,
error='')
log.plotCurves(recorder, split, epoch=epoch, intv=disp_intv)
if stop_iters > 0 and iters >= stop_iters: break
res = np.vstack([np.array(res), np.array(res).mean(0)])
save_name = '%s_res.txt' % (args.suffix)
np.savetxt(os.path.join(args.log_dir, split, save_name), res, fmt='%.2f')
if res.ndim > 1:
for i in range(res.shape[1]):
save_name = '%s_%d_res.txt' % (args.suffix, i)
np.savetxt(os.path.join(args.log_dir, split, save_name),
res[:, i],
fmt='%.3f')
opt = {'split': split, 'epoch': epoch, 'recorder': recorder}
log.printEpochSummary(opt)
def test(args, split, loader, models, log, epoch, recorder):
models[0].eval()
models[1].eval()
log.printWrite('---- Start %s Epoch %d: %d batches ----' %
(split, epoch, len(loader)))
timer = time_utils.Timer(args.time_sync)
disp_intv, save_intv, stop_iters = get_itervals(args, split)
res = []
with torch.no_grad():
for i, sample in enumerate(loader):
data = model_utils.parseData(args, sample, timer, split)
input = model_utils.getInput(args, data)
pred_c = models[0](input)
timer.updateTime('Forward')
input.append(pred_c)
normals_gt = data['n']
normals_fake = torch.zeros(1, 3, 128, 128)
ob_map_sparse = torch.zeros(1, 1, 4096, 4096)
ob_map_dense = torch.zeros(1, 1, 4096, 4096)
ob_map_gt = torch.zeros(1, 1, 4096, 4096)
if args.cuda:
normals_fake = normals_fake.cuda()
ob_map_sparse = ob_map_sparse.cuda()
ob_map_dense = ob_map_dense.cuda()
ob_map_gt = ob_map_gt.cuda()
visited_times = torch.zeros(128, 128)
stride = 6
# mask_ind_set = set(mask_ind)
print('Object: ' + sample['obj'][0])
# print(data['n'].shape)
# print(data['img'].shape)
with torch.no_grad():
for x in range(0, 128 - 15, stride):
for y in range(0, 128 - 15, stride):
print((x, y))
random_loc = torch.tensor([x + 8, y + 8])
input.append(random_loc)
pred = models[1](input)
input.pop()
normals_fake[0, :, x + 2:x + 14,
y + 2:y + 14] += pred['n'][0, :, 2:14,
2:14]
visited_times[x + 2:x + 14, y + 2:y + 14] += 1
timer.updateTime('Forward')
normals_fake = normals_fake / 4
# stride = 16
# with torch.no_grad():
# for x in range(0, 128 - 15, stride):
# for y in range(0, 128 - 15, stride):
# print ((x,y))
# random_loc = torch.tensor([x + 8, y + 8])
# input.append(random_loc)
# # pred = models[1](input);
# pred = models[1](input);
# # ob_map_gt[:,:,x * 32: (x+16)*32,y*32:(y+16)*32] = model_utils.parseData_stage2(args, sample, random_loc, split)
# input.pop();
# ob_map_sparse[:,:,x * 32: (x+16)*32,y*32:(y+16)*32] += pred['ob_map_sparse']
# ob_map_dense[:,:,x * 32: (x+16)*32,y*32:(y+16)*32] += pred['ob_map_dense']
# width = 32;
# dirs = data['dirs']
# x= 0.5*(dirs[:,0]+1)*(width-1);
# x=torch.round(x).clamp(0, width - 1).long();
# y= 0.5*(dirs[:,1]+1)*(width-1);
# y=torch.round(y).clamp(0, width - 1).long();
# idx_x = torch.split(x, 1, 0)
# idx_y = torch.split(y, 1, 0)
# stride = 16
# print (x)
# print (y)
# if not os.path.exists(os.path.join(args.log_dir, 'test') + '/' + str(args.test_set) + '/' + sample['obj'][0]):
# os.mkdir(os.path.join(args.log_dir, 'test') + '/' + str(args.test_set) + '/' + sample['obj'][0])
# d = os.path.join(args.log_dir, 'test') + '/' + str(args.test_set) + '/{}/mapind2.txt'
# f = open(d.format(sample['obj'][0]), 'w')
# dirs_x = torch.split(pred_c['dirs_x'], 1, 0)
# dirs_y = torch.split(pred_c['dirs_y'], 1, 0)
# for i in range(len(dirs_x)):
# _, x_idx = dirs_x[i].data.max(1)
# _, y_idx = dirs_y[i].data.max(1)
# f.write(str(x_idx.item() + 32 * y_idx.item() + 1) + '\n')
# f.close()
# with torch.no_grad():
# for x in range(0, 128 - 15, stride):
# for y in range(0, 128 - 15, stride):
# print ((x,y))
# random_loc = torch.tensor([x + 8, y + 8])
# input.append(random_loc)
# # pred = models[1](input);
# pred = models[1](input, idx_x, idx_y);
# input.pop();
# normals_fake[:,:,x:x + 16, y:y + 16] += pred['n']
# # # visited_times[x + 2:x + 14, y + 2:y + 14] += 1
# timer.updateTime('Forward')
# normals_fake = normals_fake / 4
delta = angular_deviation(normals_fake, normals_gt)
# normalfilepath = os.path.join(args.log_dir, 'test') + '/' + str(args.test_set) + '/Images/' + sample['obj'][0] + '.mat'
# normal_output = np.zeros([128, 128, 3])
# normal_output[:, :, 0] = normals_fake[0, 0, :, :].cpu().numpy()
# normal_output[:, :, 1] = normals_fake[0, 1, :, :].cpu().numpy()
# normal_output[:, :, 2] = normals_fake[0, 2, :, :].cpu().numpy()
# normal_gt = np.zeros([128, 128, 3])
# normal_gt[:, :, 0] = normals_gt[0, 0, :, :].cpu().numpy()
# normal_gt[:, :, 1] = normals_gt[0, 1, :, :].cpu().numpy()
# normal_gt[:, :, 2] = normals_gt[0, 2, :, :].cpu().numpy()
# ob_map_sparse_output = np.zeros([4096,4096])
# ob_map_dense_output = np.zeros([4096,4096])
# ob_map_sparse_output = ob_map_sparse[0,0,:,:].cpu().numpy()
# ob_map_dense_output = ob_map_dense[0,0,:,:].cpu().numpy()
# io.savemat(normalfilepath, {'normal_fake': normal_output, 'normal_gt': normal_gt, 'ob_map_sparse':ob_map_sparse_output[2048:2048+512,2048:2048+512],'ob_map_dense':ob_map_dense_output[2048:2048+512,2048:2048+512]})
Dall = []
for j in range(len(delta)):
Dall.append(delta[j].unsqueeze(0))
D_final = torch.cat(Dall, dim=0)
d = os.path.join(args.log_dir, 'test') + '/' + str(
args.test_set) + '/{}.txt'
f = open(d.format(sample['obj'][0]), 'w')
f.write(str(torch.mean(D_final)) + '\n')
f.close()
