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_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()
return ytrue_cat, ytrue_pose, ypred_cat, ypred_pose
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 = np.concatenate(ytrue)
# model.train()
return ytrue, ypred
def save_checkpoint(filename):
torch.save(model.state_dict(), filename)
for epoch in range(num_epochs):
tic = time.time()
scheduler.step()
# training step
training()
# save model at end of epoch
save_checkpoint(model_file)
# evaluate
ygt, ypred = testing()
print('Acc: {0}'.format(get_accuracy(ygt, ypred, num_classes)))
spio.savemat(results_file, {'ygt': ygt, 'ypred': ypred})
# time and output
toc = time.time() - tic
print('Epoch: {0} in time {1}s'.format(epoch, toc))
# cleanup
gc.collect()
# evaluate the model
ygt, ypred = testing()
print('Acc: {0}'.format(get_accuracy(ygt, ypred, num_classes)))
spio.savemat(results_file, {'ygt': ygt, 'ypred': ypred})
