lrD = opt.lrD*opt.lrDdecay**(i//opt.lrDstep)
# make training batch
batch = data.makeBatch(opt,trainData,PH)
batch[lrD_PH] = lrD
# update discriminator
runList = [optimD,loss_D,grad_D_norm_mean]
for u in range(opt.updateD):
_,ld,gdn = sess.run(runList,feed_dict=batch)
if (i+1)%10==0:
print("it.{0}/{1} lr={3}(GP),{4}(D) loss={5}(GP),{6}(D) norm={7} time={2}"
.format(util.toCyan("{0}".format(i+1)),
opt.toIt,
util.toGreen("{0:.2f}".format(time.time()-timeStart)),
util.toYellow("X"),
util.toYellow("{0:.0e}".format(lrD)),
util.toRed("X"),
util.toRed("{0:.4f}".format(ld)),
util.toBlue("{0:.4f}".format(gdn))))
# if (i+1)%20==0:
# runList = [summaryLossTrain,summaryGradTrain]
# sl,sg = sess.run(runList,feed_dict=batch)
# summaryWriter.add_summary(sl,i+1)
# summaryWriter.add_summary(sg,i+1)
# if (i+1)%200==0:
# si = sess.run(summaryImageTrain,feed_dict=batch)
# summaryWriter.add_summary(si,i+1)
# if (i+1)%500==0:
# # run on test set
# batch = data.makeBatch(opt,testData,PH)
# si = sess.run(summaryImageTest,feed_dict=batch)
# summaryWriter.add_summary(si,i+1)
for i in range(c * opt.itPerChunk, (c + 1) * opt.itPerChunk):
lr = opt.lr * opt.lrDecay**(i // opt.lrStep)
# make training batch
batch = data.makeBatch(opt, dataloader, PH)
batch[lr_PH] = lr
# run one step
runList = [optim, loss, loss_depth, loss_mask, maskLogit]
_, l, ld, lm, ml = sess.run(runList, feed_dict=batch)
if (i + 1) % 20 == 0:
print(
"it. {0}/{1}, lr={2}, loss={4} ({5},{6}), time={3}".format(
util.toCyan("{0}".format(i + 1)), opt.toIt,
util.toYellow("{0:.0e}".format(lr)),
util.toGreen("{0:.2f}".format(time.time() -
timeStart)),
util.toRed("{0:.2f}".format(l)),
util.toRed("{0:.2f}".format(ld)),
util.toRed("{0:.2f}".format(lm))))
if (i + 1) % 100 == 0:
summaryWriter.add_summary(
sess.run(summaryLoss, feed_dict=batch), i + 1)
if (i + 1) % 500 == 0:
summaryWriter.add_summary(
sess.run(summaryImage, feed_dict=batch), i + 1)
if (i + 1) % 2000 == 0:
util.saveModel(opt, sess, saver, i + 1)
print(
util.toGreen("model saved: {0}/{1}, it.{2}".format(
opt.group, opt.model, i + 1)))
dataloader.thread.join()
# training loop
for i in range(opt.fromIt, opt.toIt):
lrGP = opt.lrGP * opt.lrGPdecay**(i // opt.lrGPstep)
# make training batch
batch = data.makeBatch_homo(opt, trainData, PH)
batch[lrGP_PH] = lrGP
# update geometric predictor
runList = [optimGP, loss_GP, summaryLossTrain]
_, lg, sl = sess.run(runList, feed_dict=batch)
if (i + 1) % 20 == 0:
print("it.{0}/{1} lr={3} loss={4} time={2}".format(
util.toCyan("{0}".format(i + 1)), opt.toIt,
util.toGreen("{0:.2f}".format(time.time() - timeStart)),
util.toYellow("{0:.0e}".format(lrGP)),
util.toRed("{0:.4f}".format(lg))))
if (i + 1) % 50 == 0:
summaryWriter.add_summary(sl, i + 1)
if (i + 1) % 1000 == 0:
si = sess.run(summaryImageTrain, feed_dict=batch)
summaryWriter.add_summary(si, i + 1)
if (i + 1) % 2000 == 0:
# run on test set
batch = data.makeBatch_homo(opt, testData, PH)
runList = [summaryLossTest, summaryImageTest]
sl, si = sess.run(runList, feed_dict=batch)
summaryWriter.add_summary(sl, i + 1)
summaryWriter.add_summary(si, i + 1)
if (i + 1) % 5000 == 0:
# save model
util.saveModel(opt, sess, saver_GP, "GP", i + 1)
imageWarpAll = geometric(
opt, image, pInit) if opt.netType == "IC-STN" else geometric(
opt, imagePert)
imageWarp = imageWarpAll[-1]
output = classifier(opt, imageWarp)
train_loss = loss(output, label)
train_loss.backward()
# run one step
optim.step()
if (i + 1) % 100 == 0:
print("it. {0}/{1} lr={3}(GP),{4}(C), loss={5}, time={2}".format(
util.toCyan("{0}".format(i + 1)), opt.toIt,
util.toGreen("{0:.2f}".format(time.time() - timeStart)),
util.toYellow("{0:.0e}".format(lrGP)),
util.toYellow("{0:.0e}".format(lrC)),
util.toRed("{0:.4f}".format(train_loss))))
if (i + 1) % 200 == 0: vis.trainLoss(opt, i + 1, train_loss)
if (i + 1) % 1000 == 0:
# evaluate on test set
testAcc, testMean, testVar = data.evalTest(opt, testData,
geometric, classifier)
testError = (1 - testAcc) * 100
vis.testLoss(opt, i + 1, testError)
if opt.netType == "STN" or opt.netType == "IC-STN":
vis.meanVar(opt, testMean, testVar)
if (i + 1) % 10000 == 0:
util.saveModel(opt, geometric, classifier, i + 1)
print(
util.toGreen("model saved: {0}/{1}, it.{2}".format(
opt.group, opt.model, i + 1)))
opt.category, CAD))
Vgt = np.concatenate([obj["V"], obj["Vd"]], axis=0)
VgtN = len(Vgt)
# load prediction
Vpred24 = scipy.io.loadmat("results_{0}/{1}/{2}.mat".format(
opt.group, opt.load, CAD))["pointcloud"][:, 0]
assert (len(Vpred24) == opt.inputViewN)
for a in range(opt.inputViewN):
Vpred = Vpred24[a]
VpredN = len(Vpred)
# rotate CAD model to be in consistent coordinates
Vpred[:, 1], Vpred[:, 2] = Vpred[:, 2], -Vpred[:, 1]
# compute test error in both directions
pred2GT_all[m, a] = computeTestError(Vpred, Vgt, type="pred->GT")
GT2pred_all[m, a] = computeTestError(Vgt, Vpred, type="GT->pred")
print("{0}/{1} {2}: {3}(pred->GT),{4}(GT->pred), time={5}".format(
util.toCyan("{0}".format(m + 1)), util.toCyan("{0}".format(CADN)),
CAD, util.toRed("{0:.4f}".format(pred2GT_all[m].mean() * 100)),
util.toRed("{0:.4f}".format(GT2pred_all[m].mean() * 100)),
util.toGreen("{0:.2f}".format(time.time() - timeStart))))
scipy.io.savemat(
"results_{0}/{1}/testerror.mat".format(opt.group, opt.load), {
"pred2GT": pred2GT_all,
"GT2pred": GT2pred_all
})
print(util.toYellow("======= EVALUATION DONE ======="))
imageWarpAll = geometric(
opt, image, pInit) if opt.netType == "IC-STN" else geometric(
opt, imagePert)
imageWarp = imageWarpAll[-1]
output = classifier(opt, imageWarp)
train_loss = loss(output, label)
train_loss.backward()
# run one step
optim.step()
if (i + 1) % 100 == 0:
print("it. {0}/{1} lr={3}(GP),{4}(C), loss={5}, time={2}".format(
util.toCyan("{0}".format(i + 1)), opt.toIt,
util.toGreen("{0:.2f}".format(time.time() - timeStart)),
util.toYellow("{0:.0e}".format(lrGP)),
util.toYellow("{0:.0e}".format(lrC)),
util.toRed("{0:.4f}".format(train_loss.data[0]))))
if (i + 1) % 200 == 0: vis.trainLoss(opt, i + 1, train_loss)
if (i + 1) % 1000 == 0:
# evaluate on test set
testAcc, testMean, testVar = data.evalTest(opt, testData,
geometric, classifier)
testError = (1 - testAcc) * 100
vis.testLoss(opt, i + 1, testError)
if opt.netType == "STN" or opt.netType == "IC-STN":
vis.meanVar(opt, testMean, testVar)
if (i + 1) % 10000 == 0:
util.saveModel(opt, geometric, classifier, i + 1)
print(
util.toGreen("model saved: {0}/{1}, it.{2}".format(
opt.group, opt.model, i + 1)))