def training_init(): global count, val_loss, s model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps # outputs xdata_real = Variable(sample_real['xdata'].cuda()) label_real = Variable(sample_real['label'].cuda()) ydata_real = [ Variable(sample_real['ydata_bin'].cuda()), Variable(sample_real['ydata_res'].cuda()) ] output_real = model(xdata_real, label_real) xdata_render = Variable(sample_render['xdata'].cuda()) label_render = Variable(sample_render['label'].cuda()) ydata_render = [ Variable(sample_render['ydata_bin'].cuda()), Variable(sample_render['ydata_res'].cuda()) ] output_render = model(xdata_render, label_render) # loss ydata_bin = torch.cat((ydata_real[0], ydata_render[0])) ydata_res = torch.cat((ydata_real[1], ydata_render[1])) output_bin = torch.cat((output_real[0], output_render[0])) output_res = torch.cat((output_real[1], output_render[1])) Lc = ce_loss(output_bin, ydata_bin) Lr = mse_loss(output_res, ydata_res) loss = Lc + 0.5 * math.exp(-2 * s) * Lr + s # parameter updates optimizer.zero_grad() loss.backward() optimizer.step() s = 0.5 * math.log(Lr) # store count += 1 writer.add_scalar('train_loss', loss.item(), count) writer.add_scalar('alpha', 0.5 * math.exp(-2 * s), count) if i % 1000 == 0: ytest, yhat_test, test_labels = testing() spio.savemat(results_file, { 'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels }) tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) writer.add_scalar('val_loss', tmp_val_loss, count) val_loss.append(tmp_val_loss) # cleanup del xdata_real, xdata_render, label_real, label_render, ydata_real, ydata_render del ydata_bin, ydata_res, output_bin, output_res del output_real, output_render, loss, sample_real, sample_render bar.update(i) # stop if i == max_iterations: break render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
def training(): global count, val_acc, val_err model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps # output label_real = Variable(sample_real['label'].squeeze().cuda()) ydata_bin_real = Variable(sample_real['ydata_bin'].cuda()) ydata_real = Variable(sample_real['ydata'].cuda()) xdata_real = Variable(sample_real['xdata'].cuda()) output_real = model(xdata_real) output_cat_real = output_real[0] output_bin_real = output_real[1] output_res_real = output_real[2] label_render = Variable(sample_render['label'].squeeze().cuda()) ydata_bin_render = Variable(sample_render['ydata_bin'].cuda()) ydata_render = Variable(sample_render['ydata'].cuda()) xdata_render = Variable(sample_render['xdata'].cuda()) output_render = model(xdata_render) output_cat_render = output_render[0] output_bin_render = output_render[1] output_res_render = output_render[2] output_bin = torch.cat((output_bin_real, output_bin_render)) output_res = torch.cat((output_res_real, output_res_render)) ydata_bin = torch.cat((ydata_bin_real, ydata_bin_render)) ydata = torch.cat((ydata_real, ydata_render)) # loss Lc_cat = ce_loss(output_cat_real, label_real) # use only real images for category loss Lc_pose = ce_loss(output_bin, ydata_bin) # use all images for pose loss - bin part ind = torch.argmax(output_bin, dim=1) y = torch.index_select(cluster_centers_, 0, ind) + output_res Lr = gve_loss(y, ydata) # gve loss on final pose loss = 0.1*Lc_cat + Lc_pose + args.alpha*Lr # parameter updates optimizer.zero_grad() loss.backward() optimizer.step() # store count += 1 writer.add_scalar('train_loss', loss.item(), count) if i % 1000 == 0: ytrue_cat, ytrue_pose, ypred_cat, ypred_pose = testing() spio.savemat(results_file, {'ytrue_cat': ytrue_cat, 'ytrue_pose': ytrue_pose, 'ypred_cat': ypred_cat, 'ypred_pose': ypred_pose}) tmp_acc = get_accuracy(ytrue_cat, ypred_cat, num_classes) tmp_err = get_error2(ytrue_pose, ypred_pose, ytrue_cat, num_classes) writer.add_scalar('val_acc', tmp_acc, count) writer.add_scalar('val_err', tmp_err, count) val_acc.append(tmp_acc) val_err.append(tmp_err) # cleanup del label_real, ydata_bin_real, ydata_real, xdata_real, output_real, output_res_real, output_bin_real, output_cat_real del label_render, ydata_bin_render, ydata_render, xdata_render, output_render, output_res_render, output_bin_render, output_cat_render del output_bin, output_res, ydata_bin, ydata, Lc_cat, Lc_pose, Lr, loss bar.update(i+1) real_loader.dataset.shuffle_images() render_loader.dataset.shuffle_images()
def training(): global count, val_err, val_acc model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps # output xdata_real = Variable(sample_real['xdata'].cuda()) label_real = Variable(sample_real['label'].cuda()) ydata_bin_real = Variable(sample_real['ydata_bin'].cuda()) ydata_real = Variable(sample_real['ydata'].cuda()) output_real = model(xdata_real) xdata_render = Variable(sample_render['xdata'].cuda()) label_render = Variable(sample_render['label'].cuda()) ydata_bin_render = Variable(sample_render['ydata_bin'].cuda()) ydata_render = Variable(sample_render['ydata'].cuda()) output_render = model(xdata_render) # loss ydata_bin = torch.cat((ydata_bin_real, ydata_bin_render)) ydata = torch.cat((ydata_real, ydata_render)) output_bin = torch.cat((output_real[1], output_render[1])) ind = torch.argmax(output_bin, dim=1) y = torch.index_select(cluster_centers_, 0, ind) output = y + torch.cat((output_real[2], output_render[2])) Lc_cat = ce_loss(output_real[0], label_real.squeeze()) Lc = ce_loss(output_bin, ydata_bin) Lr = gve_loss(output, ydata) loss = 0.1*Lc_cat + Lc + 10*Lr # parameter updates optimizer.zero_grad() loss.backward() optimizer.step() # store count += 1 writer.add_scalar('train_loss', loss.item(), count) if i % 1000 == 0: ytrue_cat, ytrue_pose, ypred_cat, ypred_pose = testing() spio.savemat(results_file, {'ytrue_cat': ytrue_cat, 'ytrue_pose': ytrue_pose, 'ypred_cat': ypred_cat, 'ypred_pose': ypred_pose}) tmp_acc = get_accuracy(ytrue_cat, ypred_cat, num_classes) tmp_err = get_error2(ytrue_pose, ypred_pose, ytrue_cat, num_classes) writer.add_scalar('val_acc', tmp_acc, count) writer.add_scalar('val_err', tmp_err, count) val_acc.append(tmp_acc) val_err.append(tmp_err) # cleanup del xdata_real, xdata_render, label_real, label_render, ydata_bin_real, ydata_bin_render del ydata_bin, ydata, output_bin, output, ydata_real, ydata_render del output_real, output_render, loss, sample_real, sample_render, Lr, Lc, Lc_cat bar.update(i) # stop if i == max_iterations: break render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
def training(): global count, val_loss, s, num_ensemble model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps # output xdata_real = Variable(sample_real['xdata'].cuda()) label_real = Variable(sample_real['label'].cuda()) ydata_real = [Variable(sample_real['ydata_bin'].cuda()), Variable(sample_real['ydata'].cuda())] output_real = model(xdata_real, label_real) xdata_render = Variable(sample_render['xdata'].cuda()) label_render = Variable(sample_render['label'].cuda()) ydata_render = [Variable(sample_render['ydata_bin'].cuda()), Variable(sample_render['ydata'].cuda())] output_render = model(xdata_render, label_render) # loss ydata_bin = torch.cat((ydata_real[0], ydata_render[0])) ydata = torch.cat((ydata_real[1], ydata_render[1])) output_bin = torch.cat((output_real[0], output_render[0])) _, ind = torch.max(output_bin, dim=1) y = torch.index_select(cluster_centers_, 0, ind) output = y + torch.cat((output_real[1], output_render[1])) Lc = ce_loss(output_bin, ydata_bin) Lr = l1_loss(output, ydata) loss = Lc + math.exp(-s)*Lr + s # parameter updates optimizer.zero_grad() loss.backward() optimizer.step() s = math.log(Lr) # store writer.add_scalar('train_loss', loss.item(), count) writer.add_scalar('alpha', math.exp(-s), count) if i % 500 == 0: ytest, yhat_test, test_labels = testing() tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) writer.add_scalar('val_loss', tmp_val_loss, count) val_loss.append(tmp_val_loss) count += 1 if count % optimizer.c == optimizer.c / 2: ytest, yhat_test, test_labels = testing() num_ensemble += 1 results_file = os.path.join(results_dir, 'num' + str(num_ensemble)) spio.savemat(results_file, {'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels}) # cleanup del xdata_real, xdata_render, label_real, label_render, ydata_real, ydata_render del ydata_bin, ydata, output_bin, output del output_real, output_render, sample_real, sample_render, loss bar.update(i) # stop if i == max_iterations: break render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
def training(): global count, val_loss model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps # output xdata_real = Variable(sample_real['xdata'].cuda()) ydata_bin_real = Variable(sample_real['ydata_bin'].cuda()) ydata_real = Variable(sample_real['ydata'].cuda()) output_real = model(xdata_real) xdata_render = Variable(sample_render['xdata'].cuda()) ydata_bin_render = Variable(sample_render['ydata_bin'].cuda()) ydata_render = Variable(sample_render['ydata'].cuda()) output_render = model(xdata_render) # loss ydata_bin = torch.cat((ydata_bin_real, ydata_bin_render)) ydata = torch.cat((ydata_real, ydata_render)) output_bin = torch.cat((output_real[0], output_render[0])) ind = torch.argmax(output_bin, dim=1) y = torch.index_select(cluster_centers_, 0, ind) output = y + torch.cat((output_real[1], output_render[1])) Lc = ce_loss(output_bin, ydata_bin) Lr = gve_loss(output, ydata) loss = Lc + 10 * Lr # parameter updates optimizer.zero_grad() loss.backward() optimizer.step() # store count += 1 writer.add_scalar('train_loss', loss.item(), count) if i % 1000 == 0: ytest, yhat_test, test_labels = testing() spio.savemat(results_file, { 'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels }) tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) writer.add_scalar('val_loss', tmp_val_loss, count) val_loss.append(tmp_val_loss) # cleanup del xdata_real, xdata_render, ydata_bin_real, ydata_bin_render del ydata_bin, ydata, output_bin, output, ydata_real, ydata_render del output_real, output_render, loss, sample_real, sample_render, Lr, Lc bar.update(i) # stop if i == max_iterations: break render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
def training(): global count, val_acc, val_err #, s model.train() bar = progressbar.ProgressBar(max_value=len(train_loader)) for i, sample in enumerate(train_loader): # forward steps # output label = Variable(sample['label'].squeeze().cuda()) ydata_bin = Variable(sample['ydata_bin'].cuda()) ydata = Variable(sample['ydata'].cuda()) xdata = Variable(sample['xdata'].cuda()) output = model(xdata) output_cat = output[0] output_bin = output[1] output_res = output[2] # loss Lc_cat = ce_loss(output_cat, label) Lc_pose = ce_loss(output_bin, ydata_bin) ind = torch.argmax(output_bin, dim=1) y = torch.index_select(cluster_centers_, 0, ind) + output_res Lr = gve_loss(y, ydata) # loss = 0.1*Lc_cat + Lc_pose + math.exp(-s)*Lr + s loss = 0.1 * Lc_cat + Lc_pose + Lr # parameter updates optimizer.zero_grad() loss.backward() optimizer.step() # s = math.log(Lr) # store count += 1 writer.add_scalar('train_loss', loss.item(), count) # writer.add_scalar('alpha', math.exp(-s), count) if i % 1000 == 0: ytrue_cat, ytrue_pose, ypred_cat, ypred_pose = testing() spio.savemat( results_file, { 'ytrue_cat': ytrue_cat, 'ytrue_pose': ytrue_pose, 'ypred_cat': ypred_cat, 'ypred_pose': ypred_pose }) tmp_acc = get_accuracy(ytrue_cat, ypred_cat, num_classes) tmp_err = get_error2(ytrue_pose, ypred_pose, ytrue_cat, num_classes) writer.add_scalar('val_acc', tmp_acc, count) writer.add_scalar('val_err', tmp_err, count) val_acc.append(tmp_acc) val_err.append(tmp_err) # cleanup del xdata, label, output, loss, output_cat, output_bin, output_res bar.update(i + 1) train_loader.dataset.shuffle_images()
def training(): global count, val_err, val_acc model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps xdata_real = Variable(sample_real['xdata'].cuda()) label_real = Variable(sample_real['label'].cuda()) ydata_real = Variable(sample_real['ydata'].cuda()) output_real = model(xdata_real) xdata_render = Variable(sample_render['xdata'].cuda()) label_render = Variable(sample_render['label'].cuda()) ydata_render = Variable(sample_render['ydata'].cuda()) output_render = model(xdata_render) output_pose = torch.cat((output_real[1], output_render[1])) gt_pose = torch.cat((ydata_real, ydata_render)) Lr = gve_loss(output_pose, gt_pose) Lc = ce_loss(output_real[0], label_real.squeeze()) loss = 0.1 * Lc + Lr optimizer.zero_grad() loss.backward() optimizer.step() # store count += 1 writer.add_scalar('train_loss', loss.item(), count) if i % 1000 == 0: ytrue_cat, ytrue_pose, ypred_cat, ypred_pose = testing() spio.savemat( results_file, { 'ytrue_cat': ytrue_cat, 'ytrue_pose': ytrue_pose, 'ypred_cat': ypred_cat, 'ypred_pose': ypred_pose }) tmp_acc = get_accuracy(ytrue_cat, ypred_cat, num_classes) tmp_err = get_error2(ytrue_pose, ypred_pose, ytrue_cat, num_classes) writer.add_scalar('val_acc', tmp_acc, count) writer.add_scalar('val_err', tmp_err, count) val_acc.append(tmp_acc) val_err.append(tmp_err) # cleanup del xdata_real, xdata_render, label_real, label_render, ydata_real, ydata_render, Lr, Lc del output_real, output_render, sample_real, sample_render, loss, output_pose, gt_pose bar.update(i) # stop if i == max_iterations: break render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
def training(): global count, val_loss model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps xdata_real = Variable(sample_real['xdata'].cuda()) label_real = Variable(sample_real['label'].cuda()) ydata_real = [ Variable(sample_real['ydata_bin'].cuda()), Variable(sample_real['ydata'].cuda()) ] output_real = model(xdata_real, label_real) loss_real = criterion2(output_real, ydata_real) xdata_render = Variable(sample_render['xdata'].cuda()) label_render = Variable(sample_render['label'].cuda()) ydata_render = [ Variable(sample_render['ydata_bin'].cuda()), Variable(sample_render['ydata'].cuda()) ] output_render = model(xdata_render, label_render) loss_render = criterion2(output_render, ydata_render) loss = loss_real + loss_render optimizer.zero_grad() loss.backward() optimizer.step() # store writer.add_scalar('train_loss', loss.item(), count) if i % 1000 == 0: ytest, yhat_test, test_labels = testing() spio.savemat(results_file, { 'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels }) tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) writer.add_scalar('val_loss', tmp_val_loss, count) val_loss.append(tmp_val_loss) count += 1 # cleanup del xdata_real, xdata_render, label_real, label_render, ydata_real, ydata_render del output_real, output_render, loss_real, loss_render, sample_real, sample_render, loss bar.update(i) # stop if i == max_iterations: break render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
def training(): global count, val_loss, num_ensemble model.train() bar = progressbar.ProgressBar(max_value=len(real_loader)) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps xdata_real = Variable(sample_real['xdata'].cuda()) label_real = Variable(sample_real['label'].cuda()) ydata = sample_real['ydata'].numpy() ydata_real = Variable( torch.from_numpy(kmeans.predict(ydata)).long().cuda()) output_real = model(xdata_real, label_real) loss_real = criterion(output_real, ydata_real) xdata_render = Variable(sample_render['xdata'].cuda()) label_render = Variable(sample_render['label'].cuda()) ydata = sample_render['ydata'].numpy() ydata_render = Variable( torch.from_numpy(kmeans.predict(ydata)).long().cuda()) output_render = model(xdata_render, label_render) loss_render = criterion(output_render, ydata_render) loss = loss_real + loss_render optimizer.zero_grad() loss.backward() optimizer.step() # store writer.add_scalar('train_loss', loss.item(), count) if i % 500 == 0: ytest, yhat_test, test_labels = testing() tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) writer.add_scalar('val_loss', tmp_val_loss, count) val_loss.append(tmp_val_loss) count += 1 if count % optimizer.c == optimizer.c / 2: ytest, yhat_test, test_labels = testing() num_ensemble += 1 results_file = os.path.join(results_dir, 'num' + str(num_ensemble)) spio.savemat(results_file, { 'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels }) # cleanup del xdata_real, xdata_render, label_real, label_render, ydata_real, ydata_render del output_real, output_render, loss_real, loss_render, sample_real, sample_render, loss bar.update(i) render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
def training_init(): global count, val_loss model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, sample in enumerate(train_loader): # forward steps # outputs xdata = Variable(sample['xdata'].cuda()) ydata_bin = Variable(sample['ydata_bin'].cuda()) ydata_res = Variable(sample['ydata_res'].cuda()) output = model(xdata) # loss Lc = ce_loss(output[0], ydata_bin) Lr = mse_loss(output[1], ydata_res) loss = Lc + Lr # parameter updates optimizer.zero_grad() loss.backward() optimizer.step() # store count += 1 writer.add_scalar('train_loss', loss.item(), count) if i % 1000 == 0: ytest, yhat_test, test_labels = testing() spio.savemat(results_file, { 'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels }) tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) writer.add_scalar('val_loss', tmp_val_loss, count) val_loss.append(tmp_val_loss) # cleanup del xdata, ydata_bin, ydata_res, output, loss, sample, Lr, Lc bar.update(i) # stop if i == max_iterations: break train_loader.dataset.shuffle_images()
def save_checkpoint(filename): torch.save(model.state_dict(), filename) ytrue_cat, ytrue_pose, ypred_cat, ypred_pose = testing() spio.savemat( results_file, { 'ytrue_cat': ytrue_cat, 'ytrue_pose': ytrue_pose, 'ypred_cat': ypred_cat, 'ypred_pose': ypred_pose }) tmp_acc = get_accuracy(ytrue_cat, ypred_cat, num_classes) tmp_err = get_error2(ytrue_pose, ypred_pose, ytrue_cat, num_classes) print('Acc: {0} \t Err: {1}'.format(tmp_acc, tmp_err)) for epoch in range(args.num_epochs): tic = time.time() scheduler.step() # training step training() # save model at end of epoch save_checkpoint(model_file) # validation ytrue_cat, ytrue_pose, ypred_cat, ypred_pose = testing() spio.savemat( results_file, { 'ytrue_cat': ytrue_cat, 'ytrue_pose': ytrue_pose,
ypred = np.concatenate(ypred) ytrue = np.concatenate(ytrue) labels = np.concatenate(labels) model.train() return ytrue, ypred, labels def save_checkpoint(filename): torch.save(model.state_dict(), filename) # initialization training_init() ytest, yhat_test, test_labels = testing() print('\nMedErr: {0}'.format( get_error2(ytest, yhat_test, test_labels, num_classes))) s = 0 # reset for epoch in range(args.num_epochs): tic = time.time() # scheduler.step() # training step training() # save model at end of epoch save_checkpoint(model_file) # validation ytest, yhat_test, test_labels = testing() print('\nMedErr: {0}'.format( get_error2(ytest, yhat_test, test_labels, num_classes))) # time and output toc = time.time() - tic
gc.collect() ypred = np.concatenate(ypred) ytrue = np.concatenate(ytrue) labels = np.concatenate(labels) model.train() return ytrue, ypred, labels def save_checkpoint(filename): torch.save(model.state_dict(), filename) # initialization training_init() ytest, yhat_test, test_labels = testing() print('\nMedErr: {0}'.format(get_error2(ytest, yhat_test, test_labels, num_classes))) for epoch in range(args.num_epochs): tic = time.time() scheduler.step() # training step training() # save model at end of epoch save_checkpoint(model_file) # validation ytest, yhat_test, test_labels = testing() print('\nMedErr: {0}'.format(get_error2(ytest, yhat_test, test_labels, num_classes))) # time and output toc = time.time() - tic print('Epoch: {0} done in time {1}s'.format(epoch, toc)) # cleanup
def training(): global count, val_loss, s model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps xdata_real = Variable(sample_real['xdata'].cuda()) label_real = Variable(sample_real['label'].cuda()) output_real = model(xdata_real, label_real) xdata_render = Variable(sample_render['xdata'].cuda()) label_render = Variable(sample_render['label'].cuda()) output_render = model(xdata_render, label_render) # loss ydata_bin = torch.cat((Variable(sample_real['ydata_bin'].cuda()), Variable(sample_render['ydata_bin'].cuda()))) output_bin = torch.cat((output_real[0], output_render[0])) Lc = ce_loss(output_bin, ydata_bin) labels = torch.argmax(output_bin, dim=1) labels_numpy = labels.data.cpu().numpy() labels = torch.zeros(labels.size(0), num_clusters).scatter_( 1, labels.unsqueeze(1).data.cpu(), 1.0) labels = Variable(labels.unsqueeze(2).float().cuda()) ydata_numpy = np.concatenate( (sample_real['ydata'].data.cpu().numpy(), sample_render['ydata'].data.cpu().numpy())) ydata_res = Variable( torch.from_numpy(get_residuals(ydata_numpy, labels_numpy)).float().cuda()) output_res = torch.cat((output_real[1], output_render[1])) Lr = mse_loss(output_res, ydata_res) loss = Lc + 0.5 * math.exp(-2 * s) * Lr + s # parameter updates optimizer.zero_grad() loss.backward() optimizer.step() s = 0.5 * math.log(Lr) # store count += 1 writer.add_scalar('train_loss', loss.item(), count) writer.add_scalar('alpha', 0.5 * math.exp(-2 * s), count) if i % 1000 == 0: ytest, yhat_test, test_labels = testing() spio.savemat(results_file, { 'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels }) tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) writer.add_scalar('val_loss', tmp_val_loss, count) val_loss.append(tmp_val_loss) # cleanup del xdata_real, xdata_render, label_real, label_render del output_bin, output_res, ydata_bin, ydata_res, labels del output_real, output_render, sample_real, sample_render, loss bar.update(i) # stop if i == max_iterations: break render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
def training(): global count, val_loss, s, num_ensemble model.train() bar = progressbar.ProgressBar(max_value=max_iterations) for i, (sample_real, sample_render) in enumerate(zip(real_loader, render_loader)): # forward steps xdata_real = Variable(sample_real['xdata'].cuda()) label_real = Variable(sample_real['label'].cuda()) output_real = model(xdata_real, label_real) xdata_render = Variable(sample_render['xdata'].cuda()) label_render = Variable(sample_render['label'].cuda()) output_render = model(xdata_render, label_render) # loss ydata_bin = torch.cat((Variable(sample_real['ydata_bin'].cuda()), Variable(sample_render['ydata_bin'].cuda()))) output_bin = torch.cat((output_real[0], output_render[0])) Lc = kl_div(F.log_softmax(output_bin, dim=1), ydata_bin) ydata = torch.cat((Variable(sample_real['ydata'].cuda()), Variable(sample_render['ydata'].cuda()))) output_res = torch.cat((output_real[1], output_render[1])) if not args.multires: Lr = torch.stack([ gve_loss( ydata, torch.add( output_res, 1.0, cluster_centers.index_select( 0, Variable(j * torch.ones(1).long().cuda())))) for j in range(num_clusters) ]) else: y = cluster_centers + output_res Lr = torch.stack([ gve_loss( ydata, torch.squeeze( y.index_select( 1, Variable(j * torch.ones(1).long().cuda())))) for j in range(num_clusters) ]) Lr = torch.mean( torch.sum(torch.mul(F.softmax(output_bin, dim=1), torch.t(Lr)), dim=1)) loss = Lc + math.exp(-s) * Lr + s # updates optimizer.zero_grad() loss.backward() optimizer.step() s = math.log(Lr) # store writer.add_scalar('train_loss', loss.item(), count) writer.add_scalar('alpha', math.exp(-s), count) if i % 500 == 0: ytest, yhat_test, test_labels = testing() tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) writer.add_scalar('val_loss', tmp_val_loss, count) val_loss.append(tmp_val_loss) count += 1 if count % optimizer.c == optimizer.c / 2: ytest, yhat_test, test_labels = testing() num_ensemble += 1 results_file = os.path.join(results_dir, 'num' + str(num_ensemble)) spio.savemat(results_file, { 'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels }) # cleanup del xdata_real, xdata_render, label_real, label_render del ydata_bin, output_bin, ydata, output_res del output_real, output_render, sample_real, sample_render, loss bar.update(i) # stop if i == max_iterations: break render_loader.dataset.shuffle_images() real_loader.dataset.shuffle_images()
]) ypred.append(tmp_ypred) ytrue.append(sample['ydata'].numpy()) labels.append(sample['label'].numpy()) del xdata, label, output, sample gc.collect() ypred = np.concatenate(ypred) ytrue = np.concatenate(ytrue) labels = np.concatenate(labels) model.train() return ytrue, ypred, labels ytest, yhat_test, test_labels = testing() print('\nMedErr: {0}'.format( get_error2(ytest, yhat_test, test_labels, num_classes))) results_file = os.path.join(results_dir, 'num' + str(num_ensemble)) spio.savemat(results_file, { 'ytest': ytest, 'yhat_test': yhat_test, 'test_labels': test_labels }) for epoch in range(args.num_epochs): tic = time.time() # training step training() # validation ytest, yhat_test, test_labels = testing() tmp_val_loss = get_error2(ytest, yhat_test, test_labels, num_classes) print('\nMedErr: {0}'.format(tmp_val_loss))