Doing pretty well now with resnet50 and adam with low learning rate. Also f...

natanielruiz

2017-08-10 54818d253649ff588ed0054d10dabb2a3a170309

Doing pretty well now with resnet50 and adam with low learning rate. Also fixed test script to use large batches.

 code/test_on_video.py

@@ -48,9 +48,9 @@
    # ResNet101 with 3 outputs.
    # model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 23, 3], 66)
    # ResNet50
    # model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 6, 3], 66)
    model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 6, 3], 66)
    # ResNet18
    model = hopenet.Hopenet(torchvision.models.resnet.BasicBlock, [2, 2, 2, 2], 66)
    # model = hopenet.Hopenet(torchvision.models.resnet.BasicBlock, [2, 2, 2, 2], 66)

    print 'Loading snapshot.'
    # Load snapshot

 code/test_resnet_bins.py

@@ -42,16 +42,15 @@
    args = parse_args()

    cudnn.enabled = True
    batch_size = 1
    gpu = args.gpu_id
    snapshot_path = os.path.join('output/snapshots', args.snapshot + '.pkl')

    # ResNet101 with 3 outputs.
    # model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 23, 3], 66)
    # ResNet50
    # model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 6, 3], 66)
    model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 6, 3], 66)
    # ResNet18
    model = hopenet.Hopenet(torchvision.models.resnet.BasicBlock, [2, 2, 2, 2], 66)
    # model = hopenet.Hopenet(torchvision.models.resnet.BasicBlock, [2, 2, 2, 2], 66)

    print 'Loading snapshot.'
    # Load snapshot
@@ -66,7 +65,7 @@
    pose_dataset = datasets.AFLW2000_binned(args.data_dir, args.filename_list,
                                transformations)
    test_loader = torch.utils.data.DataLoader(dataset=pose_dataset,
                                               batch_size=batch_size,
                                               batch_size=args.batch_size,
                                               num_workers=2)

    model.cuda(gpu)
@@ -88,12 +87,14 @@
    pitch_error = .0
    roll_error = .0

    l1loss = torch.nn.L1Loss(size_average=False)

    for i, (images, labels, name) in enumerate(test_loader):
        images = Variable(images).cuda(gpu)
        total += labels.size(0)
        label_yaw = labels[:,0]
        label_pitch = labels[:,1]
        label_roll = labels[:,2]
        label_yaw = labels[:,0].float()
        label_pitch = labels[:,1].float()
        label_roll = labels[:,2].float()

        yaw, pitch, roll = model(images)

@@ -107,14 +108,18 @@
        roll_predicted = F.softmax(roll)

        # Continuous predictions
        yaw_predicted = torch.sum(yaw_predicted.data[0] * idx_tensor)
        pitch_predicted = torch.sum(pitch_predicted.data[0] * idx_tensor)
        roll_predicted = torch.sum(roll_predicted.data[0] * idx_tensor)
        yaw_predicted = torch.sum(yaw_predicted.data * idx_tensor, 1)
        pitch_predicted = torch.sum(pitch_predicted.data * idx_tensor, 1)
        roll_predicted = torch.sum(roll_predicted.data * idx_tensor, 1)

        yaw_predicted = yaw_predicted.cpu()
        pitch_predicted = pitch_predicted.cpu()
        roll_predicted = roll_predicted.cpu()

        # Mean absolute error
        yaw_error += abs(yaw_predicted - label_yaw[0]) * 3
        pitch_error += abs(pitch_predicted - label_pitch[0]) * 3
        roll_error += abs(roll_predicted - label_roll[0]) * 3
        yaw_error += torch.sum(torch.abs(yaw_predicted - label_yaw) * 3)
        pitch_error += torch.sum(torch.abs(pitch_predicted - label_pitch) * 3)
        roll_error += torch.sum(torch.abs(roll_predicted - label_roll) * 3)

        # Binned Accuracy
        # for er in xrange(n_margins):
@@ -125,13 +130,14 @@
        # print label_yaw[0], yaw_bpred[0,0]

        # Save images with pose cube.
        # TODO: fix for larger batch size
        if args.save_viz:
            name = name[0]
            cv2_img = cv2.imread(os.path.join(args.data_dir, name + '.jpg'))
            #print os.path.join('output/images', name + '.jpg')
            #print label_yaw[0] * 3 - 99, label_pitch[0] * 3 - 99, label_roll[0] * 3 - 99
            #print yaw_predicted * 3 - 99, pitch_predicted * 3 - 99, roll_predicted * 3 - 99
            utils.plot_pose_cube(cv2_img, yaw_predicted * 3 - 99, pitch_predicted * 3 - 99, roll_predicted * 3 - 99)
            utils.plot_pose_cube(cv2_img, yaw_predicted[0] * 3 - 99, pitch_predicted[0] * 3 - 99, roll_predicted[0] * 3 - 99)
            cv2.imwrite(os.path.join('output/images', name + '.jpg'), cv2_img)

    print('Test error in degrees of the model on the ' + str(total) +

 code/train_resnet_bins.py

@@ -6,6 +6,7 @@
from torchvision import transforms
import torchvision
import torch.backends.cudnn as cudnn
import torch.nn.functional as F

import cv2
import matplotlib.pyplot as plt
@@ -113,11 +114,19 @@

    model.cuda(gpu)
    criterion = nn.CrossEntropyLoss()
    reg_criterion = nn.MSELoss()
    # Regression loss coefficient
    alpha = 0.01
    lsm = nn.Softmax()

    idx_tensor = [idx for idx in xrange(66)]
    idx_tensor = torch.FloatTensor(idx_tensor).cuda(gpu)

    optimizer = torch.optim.Adam([{'params': get_ignored_params(model), 'lr': args.lr},
                                  {'params': get_non_ignored_params(model), 'lr': args.lr * 10}],
                                  lr = args.lr)
    # optimizer = torch.optim.SGD([{'params': get_ignored_params(model), 'lr': args.lr},
    #                               {'params': get_non_ignored_params(model), 'lr': args.lr}],
    #                              {'params': get_non_ignored_params(model), 'lr': args.lr}],
    #                               lr = args.lr, momentum=0.9)
    # optimizer = torch.optim.RMSprop([{'params': get_ignored_params(model), 'lr': args.lr},
    #                               {'params': get_non_ignored_params(model), 'lr': args.lr * 10}],
@@ -134,24 +143,56 @@

            optimizer.zero_grad()
            yaw, pitch, roll = model(images)

            loss_yaw = criterion(yaw, label_yaw)
            loss_pitch = criterion(pitch, label_pitch)
            loss_roll = criterion(roll, label_roll)

            # loss_seq = [loss_yaw, loss_pitch, loss_roll]
            # grad_seq = [torch.Tensor(1).cuda(gpu) for _ in range(len(loss_seq))]
            # torch.autograd.backward(loss_seq, grad_seq)
            # optimizer.step()

            # MSE loss
            yaw_predicted = F.softmax(yaw)
            pitch_predicted = F.softmax(pitch)
            roll_predicted = F.softmax(roll)

            yaw_predicted = torch.sum(yaw_predicted.data * idx_tensor, 1)
            pitch_predicted = torch.sum(pitch_predicted.data * idx_tensor, 1)
            roll_predicted = torch.sum(roll_predicted.data * idx_tensor, 1)

            loss_reg_yaw = reg_criterion(yaw_predicted, label_yaw.float())
            loss_reg_pitch = reg_criterion(pitch_predicted, label_pitch.float())
            loss_reg_roll = reg_criterion(roll_predicted, label_roll.float())

            # print yaw_predicted[0], label_yaw.data[0]

            loss_yaw += alpha * loss_reg_yaw
            loss_pitch += alpha * loss_reg_pitch
            loss_roll += alpha * loss_reg_roll

            loss_seq = [loss_yaw, loss_pitch, loss_roll]
            grad_seq = [torch.Tensor(1).cuda(gpu) for _ in range(len(loss_seq))]
            model.zero_grad()
            torch.autograd.backward(loss_seq, grad_seq)
            optimizer.step()

            # print ('Epoch [%d/%d], Iter [%d/%d] Losses: Yaw %.4f, Pitch %.4f, Roll %.4f'
            #        %(epoch+1, num_epochs, i+1, len(pose_dataset)//batch_size, loss_yaw.data[0], loss_pitch.data[0], loss_roll.data[0]))

            if (i+1) % 100 == 0:
                print ('Epoch [%d/%d], Iter [%d/%d] Losses: Yaw %.4f, Pitch %.4f, Roll %.4f'
                       %(epoch+1, num_epochs, i+1, len(pose_dataset)//batch_size, loss_yaw.data[0], loss_pitch.data[0], loss_roll.data[0]))
                # if epoch == 0:
                #     torch.save(model.state_dict(),
                #     'output/snapshots/resnet18_sgd_iter_'+ str(i+1) + '.pkl')

        # Save models at numbered epochs.
        if epoch % 1 == 0 and epoch < num_epochs - 1:
            print 'Taking snapshot...'
            torch.save(model.state_dict(),
            'output/snapshots/resnet18_cr_epoch_'+ str(epoch+1) + '.pkl')
            'output/snapshots/resnet18_sgd_epoch_'+ str(epoch+1) + '.pkl')

    # Save the final Trained Model
    torch.save(model.state_dict(), 'output/snapshots/resnet18_cr_epoch_' + str(epoch+1) + '.pkl')
    torch.save(model.state_dict(), 'output/snapshots/resnet18_sgd_epoch_' + str(epoch+1) + '.pkl')

 code/train_resnet_bins_comb.py

New file
@@ -0,0 +1,198 @@
import numpy as np
import torch
import torch.nn as nn
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import transforms
import torchvision
import torch.backends.cudnn as cudnn
import torch.nn.functional as F

import cv2
import matplotlib.pyplot as plt
import sys
import os
import argparse

import datasets
import hopenet
import torch.utils.model_zoo as model_zoo

model_urls = {
    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
}

def parse_args():
    """Parse input arguments."""
    parser = argparse.ArgumentParser(description='Head pose estimation using the Hopenet network.')
    parser.add_argument('--gpu', dest='gpu_id', help='GPU device id to use [0]',
            default=0, type=int)
    parser.add_argument('--num_epochs', dest='num_epochs', help='Maximum number of training epochs.',
          default=5, type=int)
    parser.add_argument('--batch_size', dest='batch_size', help='Batch size.',
          default=16, type=int)
    parser.add_argument('--lr', dest='lr', help='Base learning rate.',
          default=0.001, type=float)
    parser.add_argument('--data_dir', dest='data_dir', help='Directory path for data.',
          default='', type=str)
    parser.add_argument('--filename_list', dest='filename_list', help='Path to text file containing relative paths for every example.',
          default='', type=str)

    args = parser.parse_args()

    return args

def get_ignored_params(model):
    # Generator function that yields ignored params.
    b = []
    b.append(model.conv1)
    b.append(model.bn1)
    b.append(model.layer1)
    b.append(model.layer2)
    b.append(model.layer3)
    b.append(model.layer4)
    for i in range(len(b)):
        for j in b[i].modules():
            for k in j.parameters():
                yield k

def get_non_ignored_params(model):
    # Generator function that yields params that will be optimized.
    b = []
    b.append(model.fc_yaw)
    b.append(model.fc_pitch)
    b.append(model.fc_roll)
    for i in range(len(b)):
        for j in b[i].modules():
            for k in j.parameters():
                    yield k

def load_filtered_state_dict(model, snapshot):
    # By user apaszke from discuss.pytorch.org
    model_dict = model.state_dict()
    # 1. filter out unnecessary keys
    snapshot = {k: v for k, v in snapshot.items() if k in model_dict}
    # 2. overwrite entries in the existing state dict
    model_dict.update(snapshot)
    # 3. load the new state dict
    model.load_state_dict(model_dict)

if __name__ == '__main__':
    args = parse_args()

    cudnn.enabled = True
    num_epochs = args.num_epochs
    batch_size = args.batch_size
    gpu = args.gpu_id

    if not os.path.exists('output/snapshots'):
        os.makedirs('output/snapshots')

    # ResNet101 with 3 outputs
    # model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 23, 3], 66)
    # ResNet50
    model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 6, 3], 66)
    # ResNet18
    # model = hopenet.Hopenet(torchvision.models.resnet.BasicBlock, [2, 2, 2, 2], 66)
    load_filtered_state_dict(model, model_zoo.load_url(model_urls['resnet50']))

    print 'Loading data.'

    transformations = transforms.Compose([transforms.Scale(224),transforms.RandomCrop(224),
                                          transforms.ToTensor()])

    pose_dataset = datasets.Pose_300W_LP_binned(args.data_dir, args.filename_list,
                                transformations)
    train_loader = torch.utils.data.DataLoader(dataset=pose_dataset,
                                               batch_size=batch_size,
                                               shuffle=True,
                                               num_workers=2)

    model.cuda(gpu)
    criterion = nn.CrossEntropyLoss()
    reg_criterion = nn.MSELoss()
    # Regression loss coefficient
    alpha = 0.1
    lsm = nn.Softmax()

    idx_tensor = [idx for idx in xrange(66)]
    idx_tensor = torch.FloatTensor(idx_tensor).cuda(gpu)

    optimizer = torch.optim.Adam([{'params': get_ignored_params(model), 'lr': args.lr},
                                  {'params': get_non_ignored_params(model), 'lr': args.lr * 10}],
                                  lr = args.lr)
    # optimizer = torch.optim.SGD([{'params': get_ignored_params(model), 'lr': args.lr},
    #                              {'params': get_non_ignored_params(model), 'lr': args.lr}],
    #                               lr = args.lr, momentum=0.9, weight_decay=5e-4)
    # optimizer = torch.optim.RMSprop([{'params': get_ignored_params(model), 'lr': args.lr},
    #                               {'params': get_non_ignored_params(model), 'lr': args.lr * 10}],
    #                               lr = args.lr)

    print 'Ready to train network.'

    for epoch in range(num_epochs):
        for i, (images, labels, name) in enumerate(train_loader):
            images = Variable(images).cuda(gpu)
            label_yaw = Variable(labels[:,0]).cuda(gpu)
            label_pitch = Variable(labels[:,1]).cuda(gpu)
            label_roll = Variable(labels[:,2]).cuda(gpu)

            optimizer.zero_grad()
            yaw, pitch, roll = model(images)

            loss_yaw = criterion(yaw, label_yaw)
            loss_pitch = criterion(pitch, label_pitch)
            loss_roll = criterion(roll, label_roll)

            # loss_seq = [loss_yaw, loss_pitch, loss_roll]
            # grad_seq = [torch.Tensor(1).cuda(gpu) for _ in range(len(loss_seq))]
            # torch.autograd.backward(loss_seq, grad_seq)
            # optimizer.step()

            # MSE loss
            yaw_predicted = F.softmax(yaw)
            pitch_predicted = F.softmax(pitch)
            roll_predicted = F.softmax(roll)

            yaw_predicted = torch.sum(yaw_predicted.data * idx_tensor, 1)
            pitch_predicted = torch.sum(pitch_predicted.data * idx_tensor, 1)
            roll_predicted = torch.sum(roll_predicted.data * idx_tensor, 1)

            loss_reg_yaw = reg_criterion(yaw_predicted, label_yaw.float())
            loss_reg_pitch = reg_criterion(pitch_predicted, label_pitch.float())
            loss_reg_roll = reg_criterion(roll_predicted, label_roll.float())

            # print yaw_predicted[0], label_yaw.data[0]

            loss_yaw += alpha * loss_reg_yaw
            loss_pitch += alpha * loss_reg_pitch
            loss_roll += alpha * loss_reg_roll

            loss_seq = [loss_yaw, loss_pitch, loss_roll]
            grad_seq = [torch.Tensor(1).cuda(gpu) for _ in range(len(loss_seq))]
            model.zero_grad()
            torch.autograd.backward(loss_seq, grad_seq)
            optimizer.step()

            # print ('Epoch [%d/%d], Iter [%d/%d] Losses: Yaw %.4f, Pitch %.4f, Roll %.4f'
            #        %(epoch+1, num_epochs, i+1, len(pose_dataset)//batch_size, loss_yaw.data[0], loss_pitch.data[0], loss_roll.data[0]))

            if (i+1) % 100 == 0:
                print ('Epoch [%d/%d], Iter [%d/%d] Losses: Yaw %.4f, Pitch %.4f, Roll %.4f'
                       %(epoch+1, num_epochs, i+1, len(pose_dataset)//batch_size, loss_yaw.data[0], loss_pitch.data[0], loss_roll.data[0]))
                if epoch == 0:
                    torch.save(model.state_dict(),
                    'output/snapshots/resnet50_iter_'+ str(i+1) + '.pkl')

        # Save models at numbered epochs.
        if epoch % 1 == 0 and epoch < num_epochs - 1:
            print 'Taking snapshot...'
            torch.save(model.state_dict(),
            'output/snapshots/resnet50_epoch_'+ str(epoch+1) + '.pkl')

    # Save the final Trained Model
    torch.save(model.state_dict(), 'output/snapshots/resnet50_epoch_' + str(epoch+1) + '.pkl')

 code/train_resnet_bins_comb_dup.py

New file
@@ -0,0 +1,198 @@
import numpy as np
import torch
import torch.nn as nn
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import transforms
import torchvision
import torch.backends.cudnn as cudnn
import torch.nn.functional as F

import cv2
import matplotlib.pyplot as plt
import sys
import os
import argparse

import datasets
import hopenet
import torch.utils.model_zoo as model_zoo

model_urls = {
    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
}

def parse_args():
    """Parse input arguments."""
    parser = argparse.ArgumentParser(description='Head pose estimation using the Hopenet network.')
    parser.add_argument('--gpu', dest='gpu_id', help='GPU device id to use [0]',
            default=0, type=int)
    parser.add_argument('--num_epochs', dest='num_epochs', help='Maximum number of training epochs.',
          default=5, type=int)
    parser.add_argument('--batch_size', dest='batch_size', help='Batch size.',
          default=16, type=int)
    parser.add_argument('--lr', dest='lr', help='Base learning rate.',
          default=0.001, type=float)
    parser.add_argument('--data_dir', dest='data_dir', help='Directory path for data.',
          default='', type=str)
    parser.add_argument('--filename_list', dest='filename_list', help='Path to text file containing relative paths for every example.',
          default='', type=str)

    args = parser.parse_args()

    return args

def get_ignored_params(model):
    # Generator function that yields ignored params.
    b = []
    b.append(model.conv1)
    b.append(model.bn1)
    b.append(model.layer1)
    b.append(model.layer2)
    b.append(model.layer3)
    b.append(model.layer4)
    for i in range(len(b)):
        for j in b[i].modules():
            for k in j.parameters():
                yield k

def get_non_ignored_params(model):
    # Generator function that yields params that will be optimized.
    b = []
    b.append(model.fc_yaw)
    b.append(model.fc_pitch)
    b.append(model.fc_roll)
    for i in range(len(b)):
        for j in b[i].modules():
            for k in j.parameters():
                    yield k

def load_filtered_state_dict(model, snapshot):
    # By user apaszke from discuss.pytorch.org
    model_dict = model.state_dict()
    # 1. filter out unnecessary keys
    snapshot = {k: v for k, v in snapshot.items() if k in model_dict}
    # 2. overwrite entries in the existing state dict
    model_dict.update(snapshot)
    # 3. load the new state dict
    model.load_state_dict(model_dict)

if __name__ == '__main__':
    args = parse_args()

    cudnn.enabled = True
    num_epochs = args.num_epochs
    batch_size = args.batch_size
    gpu = args.gpu_id

    if not os.path.exists('output/snapshots'):
        os.makedirs('output/snapshots')

    # ResNet101 with 3 outputs
    # model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 23, 3], 66)
    # ResNet50
    model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 6, 3], 66)
    # ResNet18
    # model = hopenet.Hopenet(torchvision.models.resnet.BasicBlock, [2, 2, 2, 2], 66)
    load_filtered_state_dict(model, model_zoo.load_url(model_urls['resnet50']))

    print 'Loading data.'

    transformations = transforms.Compose([transforms.Scale(224),transforms.RandomCrop(224),
                                          transforms.ToTensor()])

    pose_dataset = datasets.Pose_300W_LP_binned(args.data_dir, args.filename_list,
                                transformations)
    train_loader = torch.utils.data.DataLoader(dataset=pose_dataset,
                                               batch_size=batch_size,
                                               shuffle=True,
                                               num_workers=2)

    model.cuda(gpu)
    criterion = nn.CrossEntropyLoss()
    reg_criterion = nn.MSELoss()
    # Regression loss coefficient
    alpha = 0.1
    lsm = nn.Softmax()

    idx_tensor = [idx for idx in xrange(66)]
    idx_tensor = torch.FloatTensor(idx_tensor).cuda(gpu)

    optimizer = torch.optim.Adam([{'params': get_ignored_params(model), 'lr': args.lr},
                                  {'params': get_non_ignored_params(model), 'lr': args.lr * 10}],
                                  lr = args.lr)
    # optimizer = torch.optim.SGD([{'params': get_ignored_params(model), 'lr': args.lr},
    #                              {'params': get_non_ignored_params(model), 'lr': args.lr}],
    #                               lr = args.lr, momentum=0.9, weight_decay=5e-4)
    # optimizer = torch.optim.RMSprop([{'params': get_ignored_params(model), 'lr': args.lr},
    #                               {'params': get_non_ignored_params(model), 'lr': args.lr * 10}],
    #                               lr = args.lr)

    print 'Ready to train network.'

    for epoch in range(num_epochs):
        for i, (images, labels, name) in enumerate(train_loader):
            images = Variable(images).cuda(gpu)
            label_yaw = Variable(labels[:,0]).cuda(gpu)
            label_pitch = Variable(labels[:,1]).cuda(gpu)
            label_roll = Variable(labels[:,2]).cuda(gpu)

            optimizer.zero_grad()
            yaw, pitch, roll = model(images)

            loss_yaw = criterion(yaw, label_yaw)
            loss_pitch = criterion(pitch, label_pitch)
            loss_roll = criterion(roll, label_roll)

            # loss_seq = [loss_yaw, loss_pitch, loss_roll]
            # grad_seq = [torch.Tensor(1).cuda(gpu) for _ in range(len(loss_seq))]
            # torch.autograd.backward(loss_seq, grad_seq)
            # optimizer.step()

            # MSE loss
            yaw_predicted = F.softmax(yaw)
            pitch_predicted = F.softmax(pitch)
            roll_predicted = F.softmax(roll)

            yaw_predicted = torch.sum(yaw_predicted.data * idx_tensor, 1)
            pitch_predicted = torch.sum(pitch_predicted.data * idx_tensor, 1)
            roll_predicted = torch.sum(roll_predicted.data * idx_tensor, 1)

            loss_reg_yaw = reg_criterion(yaw_predicted, label_yaw.float())
            loss_reg_pitch = reg_criterion(pitch_predicted, label_pitch.float())
            loss_reg_roll = reg_criterion(roll_predicted, label_roll.float())

            # print yaw_predicted[0], label_yaw.data[0]

            loss_yaw += alpha * loss_reg_yaw
            loss_pitch += alpha * loss_reg_pitch
            loss_roll += alpha * loss_reg_roll

            loss_seq = [loss_yaw, loss_pitch, loss_roll]
            grad_seq = [torch.Tensor(1).cuda(gpu) for _ in range(len(loss_seq))]
            model.zero_grad()
            torch.autograd.backward(loss_seq, grad_seq)
            optimizer.step()

            # print ('Epoch [%d/%d], Iter [%d/%d] Losses: Yaw %.4f, Pitch %.4f, Roll %.4f'
            #        %(epoch+1, num_epochs, i+1, len(pose_dataset)//batch_size, loss_yaw.data[0], loss_pitch.data[0], loss_roll.data[0]))

            if (i+1) % 100 == 0:
                print ('Epoch [%d/%d], Iter [%d/%d] Losses: Yaw %.4f, Pitch %.4f, Roll %.4f'
                       %(epoch+1, num_epochs, i+1, len(pose_dataset)//batch_size, loss_yaw.data[0], loss_pitch.data[0], loss_roll.data[0]))
                if epoch == 0:
                    torch.save(model.state_dict(),
                    'output/snapshots/resnet50_lowlr_iter_'+ str(i+1) + '.pkl')

        # Save models at numbered epochs.
        if epoch % 1 == 0 and epoch < num_epochs - 1:
            print 'Taking snapshot...'
            torch.save(model.state_dict(),
            'output/snapshots/resnet50_lowlr_epoch_'+ str(epoch+1) + '.pkl')

    # Save the final Trained Model
    torch.save(model.state_dict(), 'output/snapshots/resnet50_lowlr_epoch_' + str(epoch+1) + '.pkl')

 practice/.ipynb_checkpoints/smoothing_ypr-checkpoint.ipynb

@@ -2,7 +2,7 @@
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 156,
   "execution_count": 187,
   "metadata": {
    "collapsed": false
   },
@@ -17,7 +17,7 @@
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "execution_count": 188,
   "metadata": {
    "collapsed": false
   },
@@ -26,13 +26,13 @@
    "video_path = '../data/video/SGT036_2016_07_25_pivothead_AVI.avi'\n",
    "bbox_path = '../data/video/annotations/SGT036_childface.txt'\n",
    "\n",
    "annot_path = '../output/video/output-SGT036_resnet18_cr_epoch_1.txt'\n",
    "output_string = 'SGT036_resnet18_cr_epoch_1_flat_smoothed'"
    "annot_path = '../output/video/output-SGT036_resnet50_lowlr_epoch_20.txt'\n",
    "output_string = 'SGT036_resnet50_lowlr_epoch_20_smoothed'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "execution_count": 189,
   "metadata": {
    "collapsed": false
   },
@@ -41,7 +41,7 @@
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-6.069214 -0.831665  0.53318  ..., -3.836042 -3.868275 -2.377155]\n",
      "[ 4.170376  0.790443 -0.178368 ..., -3.437805  0.396835 -1.276176]\n",
      "(8508,)\n",
      "(53464,)\n"
     ]
@@ -93,7 +93,7 @@
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "execution_count": 190,
   "metadata": {
    "collapsed": false
   },
@@ -107,31 +107,39 @@
    }
   ],
   "source": [
    "window_len = 6\n",
    "window_len = 5\n",
    "pad = window_len / 2\n",
    "window = 'flat'\n",
    "window_2 = 'flat'\n",
    "window_len_2 = 7\n",
    "pad_2 = window_len_2 / 2\n",
    "\n",
    "s = np.r_[y[window_len-1:0:-1],y,y[-2:-window_len-1:-1]]\n",
    "t = np.r_[p[window_len-1:0:-1],p,p[-2:-window_len-1:-1]]\n",
    "u = np.r_[r[window_len-1:0:-1],r,r[-2:-window_len-1:-1]]\n",
    "\n",
    "xa = np.r_[x_min_arr[window_len-1:0:-1],x_min_arr,x_min_arr[-2:-window_len-1:-1]]\n",
    "xb = np.r_[x_max_arr[window_len-1:0:-1],x_max_arr,x_max_arr[-2:-window_len-1:-1]]\n",
    "ya = np.r_[y_min_arr[window_len-1:0:-1],y_min_arr,y_min_arr[-2:-window_len-1:-1]]\n",
    "yb = np.r_[y_max_arr[window_len-1:0:-1],y_max_arr,y_max_arr[-2:-window_len-1:-1]]\n",
    "xa = np.r_[x_min_arr[window_len_2-1:0:-1],x_min_arr,x_min_arr[-2:-window_len_2-1:-1]]\n",
    "xb = np.r_[x_max_arr[window_len_2-1:0:-1],x_max_arr,x_max_arr[-2:-window_len_2-1:-1]]\n",
    "ya = np.r_[y_min_arr[window_len_2-1:0:-1],y_min_arr,y_min_arr[-2:-window_len_2-1:-1]]\n",
    "yb = np.r_[y_max_arr[window_len_2-1:0:-1],y_max_arr,y_max_arr[-2:-window_len_2-1:-1]]\n",
    "\n",
    "if window == 'flat':\n",
    "    w=np.ones(window_len, 'd')\n",
    "else:\n",
    "    w=eval('np.' + window + '(window_len)')\n",
    "    \n",
    "if window_2 == 'flat':\n",
    "    w_2=np.ones(window_len_2, 'd')\n",
    "else:\n",
    "    w_2=eval('np.' + window_2 + '(window_len_2)')    \n",
    "\n",
    "y = np.convolve(w / w.sum(), s, mode='valid')[pad:-pad]\n",
    "p = np.convolve(w / w.sum(), t, mode='valid')[pad:-pad]\n",
    "r = np.convolve(w / w.sum(), u, mode='valid')[pad:-pad]\n",
    "x_min_arr = np.convolve(w / w.sum(), xa, mode='valid')[pad:-pad]\n",
    "x_max_arr = np.convolve(w / w.sum(), xb, mode='valid')[pad:-pad]\n",
    "y_min_arr = np.convolve(w / w.sum(), ya, mode='valid')[pad:-pad]\n",
    "y_max_arr = np.convolve(w / w.sum(), yb, mode='valid')[pad:-pad]\n",
    "x_min_arr = np.convolve(w_2 / w_2.sum(), xa, mode='valid')[pad_2:-pad_2]\n",
    "x_max_arr = np.convolve(w_2 / w_2.sum(), xb, mode='valid')[pad_2:-pad_2]\n",
    "y_min_arr = np.convolve(w_2 / w_2.sum(), ya, mode='valid')[pad_2:-pad_2]\n",
    "y_max_arr = np.convolve(w_2 / w_2.sum(), yb, mode='valid')[pad_2:-pad_2]\n",
    "\n",
    "pose_dict = {}\n",
    "bbox_dict = {}\n",
@@ -151,7 +159,7 @@
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "execution_count": 191,
   "metadata": {
    "collapsed": false
   },

 practice/smoothing_ypr.ipynb

@@ -2,7 +2,7 @@
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 156,
   "execution_count": 197,
   "metadata": {
    "collapsed": false
   },
@@ -17,7 +17,7 @@
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "execution_count": 198,
   "metadata": {
    "collapsed": false
   },
@@ -26,13 +26,13 @@
    "video_path = '../data/video/SGT036_2016_07_25_pivothead_AVI.avi'\n",
    "bbox_path = '../data/video/annotations/SGT036_childface.txt'\n",
    "\n",
    "annot_path = '../output/video/output-SGT036_resnet18_cr_epoch_1.txt'\n",
    "output_string = 'SGT036_resnet18_cr_epoch_1_flat_smoothed'"
    "annot_path = '../output/video/output-SGT036_resnet50_lowlr_epoch_20.txt'\n",
    "output_string = 'SGT036_resnet50_lowlr_epoch_20_smoothed'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "execution_count": 199,
   "metadata": {
    "collapsed": false
   },
@@ -41,7 +41,7 @@
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-6.069214 -0.831665  0.53318  ..., -3.836042 -3.868275 -2.377155]\n",
      "[ 4.170376  0.790443 -0.178368 ..., -3.437805  0.396835 -1.276176]\n",
      "(8508,)\n",
      "(53464,)\n"
     ]
@@ -93,7 +93,7 @@
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "execution_count": 200,
   "metadata": {
    "collapsed": false
   },
@@ -107,31 +107,39 @@
    }
   ],
   "source": [
    "window_len = 6\n",
    "window_len = 7\n",
    "pad = window_len / 2\n",
    "window = 'flat'\n",
    "window_2 = 'flat'\n",
    "window_len_2 = 7\n",
    "pad_2 = window_len_2 / 2\n",
    "\n",
    "s = np.r_[y[window_len-1:0:-1],y,y[-2:-window_len-1:-1]]\n",
    "t = np.r_[p[window_len-1:0:-1],p,p[-2:-window_len-1:-1]]\n",
    "u = np.r_[r[window_len-1:0:-1],r,r[-2:-window_len-1:-1]]\n",
    "\n",
    "xa = np.r_[x_min_arr[window_len-1:0:-1],x_min_arr,x_min_arr[-2:-window_len-1:-1]]\n",
    "xb = np.r_[x_max_arr[window_len-1:0:-1],x_max_arr,x_max_arr[-2:-window_len-1:-1]]\n",
    "ya = np.r_[y_min_arr[window_len-1:0:-1],y_min_arr,y_min_arr[-2:-window_len-1:-1]]\n",
    "yb = np.r_[y_max_arr[window_len-1:0:-1],y_max_arr,y_max_arr[-2:-window_len-1:-1]]\n",
    "xa = np.r_[x_min_arr[window_len_2-1:0:-1],x_min_arr,x_min_arr[-2:-window_len_2-1:-1]]\n",
    "xb = np.r_[x_max_arr[window_len_2-1:0:-1],x_max_arr,x_max_arr[-2:-window_len_2-1:-1]]\n",
    "ya = np.r_[y_min_arr[window_len_2-1:0:-1],y_min_arr,y_min_arr[-2:-window_len_2-1:-1]]\n",
    "yb = np.r_[y_max_arr[window_len_2-1:0:-1],y_max_arr,y_max_arr[-2:-window_len_2-1:-1]]\n",
    "\n",
    "if window == 'flat':\n",
    "    w=np.ones(window_len, 'd')\n",
    "else:\n",
    "    w=eval('np.' + window + '(window_len)')\n",
    "    \n",
    "if window_2 == 'flat':\n",
    "    w_2=np.ones(window_len_2, 'd')\n",
    "else:\n",
    "    w_2=eval('np.' + window_2 + '(window_len_2)')    \n",
    "\n",
    "y = np.convolve(w / w.sum(), s, mode='valid')[pad:-pad]\n",
    "p = np.convolve(w / w.sum(), t, mode='valid')[pad:-pad]\n",
    "r = np.convolve(w / w.sum(), u, mode='valid')[pad:-pad]\n",
    "x_min_arr = np.convolve(w / w.sum(), xa, mode='valid')[pad:-pad]\n",
    "x_max_arr = np.convolve(w / w.sum(), xb, mode='valid')[pad:-pad]\n",
    "y_min_arr = np.convolve(w / w.sum(), ya, mode='valid')[pad:-pad]\n",
    "y_max_arr = np.convolve(w / w.sum(), yb, mode='valid')[pad:-pad]\n",
    "x_min_arr = np.convolve(w_2 / w_2.sum(), xa, mode='valid')[pad_2:-pad_2]\n",
    "x_max_arr = np.convolve(w_2 / w_2.sum(), xb, mode='valid')[pad_2:-pad_2]\n",
    "y_min_arr = np.convolve(w_2 / w_2.sum(), ya, mode='valid')[pad_2:-pad_2]\n",
    "y_max_arr = np.convolve(w_2 / w_2.sum(), yb, mode='valid')[pad_2:-pad_2]\n",
    "\n",
    "pose_dict = {}\n",
    "bbox_dict = {}\n",
@@ -151,7 +159,7 @@
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "execution_count": 201,
   "metadata": {
    "collapsed": false
   },