In [1]:
import os
os.chdir('/home/renwh/gaze/renwh/caffe_with_cudnnv3/')

import sys
sys.path.insert(0,'./python')
import caffe

from pylab import *
%matplotlib inline


caffe.set_device(0)
caffe.set_mode_gpu()
solver = caffe.SGDSolver('examples/mymodel/05/quick_solver.prototxt')

#You can choose to load your model status
solver.restore('examples/mymodel/05/bvlc_googlenet_quick_iter_15500.solverstate')
In [2]:
# each output is (batch size, feature dim, spatial dim)
[(k, v.data.shape) for k, v in solver.net.blobs.items()]
#[(k, v.data.shape) for k, v in solver.test_nets[0].blobs.items()]
Out[2]:
[('data', (500, 1, 36, 60)),
 ('label', (500, 6)),
 ('gaze', (500, 3)),
 ('headpose', (500, 3)),
 ('conv1/5x5_s1', (500, 64, 32, 56)),
 ('pool1/3x3_s2', (500, 64, 16, 28)),
 ('pool1/norm1', (500, 64, 16, 28)),
 ('pool1/norm1_pool1/norm1_0_split_0', (500, 64, 16, 28)),
 ('pool1/norm1_pool1/norm1_0_split_1', (500, 64, 16, 28)),
 ('pool1/norm1_pool1/norm1_0_split_2', (500, 64, 16, 28)),
 ('pool1/norm1_pool1/norm1_0_split_3', (500, 64, 16, 28)),
 ('inception_1/1x1', (500, 64, 16, 28)),
 ('inception_1/3x3_reduce', (500, 96, 16, 28)),
 ('inception_1/3x3', (500, 128, 16, 28)),
 ('inception_1/5x5_reduce', (500, 16, 16, 28)),
 ('inception_1/5x5', (500, 32, 16, 28)),
 ('inception_1/pool', (500, 64, 16, 28)),
 ('inception_1/pool_proj', (500, 32, 16, 28)),
 ('inception_1/output', (500, 256, 16, 28)),
 ('pool2/3x3_s2', (500, 256, 8, 14)),
 ('conv2/3x3_s1', (500, 64, 6, 12)),
 ('pool3/2x2_s2', (500, 64, 3, 6)),
 ('ip1', (500, 500)),
 ('cat', (500, 503)),
 ('ip2', (500, 3)),
 ('loss', ())]
In [3]:
# just print the weight sizes (not biases)
[(k, v[0].data.shape) for k, v in solver.net.params.items()]
Out[3]:
[('conv1/5x5_s1', (64, 1, 5, 5)),
 ('inception_1/1x1', (64, 64, 1, 1)),
 ('inception_1/3x3_reduce', (96, 64, 1, 1)),
 ('inception_1/3x3', (128, 96, 3, 3)),
 ('inception_1/5x5_reduce', (16, 64, 1, 1)),
 ('inception_1/5x5', (32, 16, 5, 5)),
 ('inception_1/pool_proj', (32, 64, 1, 1)),
 ('conv2/3x3_s1', (64, 256, 3, 3)),
 ('ip1', (500, 1152)),
 ('ip2', (3, 503))]
In [4]:
solver.net.forward()  # train net
solver.test_nets[0].forward()  # test net (there can be more than one)
Out[4]:
{'loss': array(0.3085583746433258, dtype=float32)}
In [5]:
# we use a little trick to tile the first eight images
imshow(solver.test_nets[0].blobs['data'].data[:8, 0].transpose(1, 0, 2).reshape(36, 8*60), cmap='gray')
print solver.net.blobs['label'].data[:8]

[[ -2.44513273e-01   5.20949736e-02  -9.68245506e-01  -5.07045567e-01
   -1.12138920e-01  -2.90884897e-02]
 [ -7.41908699e-02   2.27922529e-01  -9.70848620e-01  -1.28387764e-01
    1.65355857e-02   1.06296828e-03]
 [ -1.74087971e-01   3.04691344e-02  -9.84258592e-01  -9.52000245e-02
   -3.14195365e-01  -1.50917871e-02]
 [ -2.49744281e-02   1.77879885e-01  -9.83735263e-01  -7.38587156e-02
   -1.21144764e-02  -4.47588827e-04]
 [ -1.61419377e-01   5.79187945e-02  -9.85184848e-01  -1.06810793e-01
    1.42905980e-01   7.65229668e-03]
 [ -1.52415037e-01   2.09456533e-01  -9.65866268e-01  -5.29863574e-02
   -1.14266567e-01  -3.03129526e-03]
 [ -1.76816806e-02   6.62708879e-02  -9.97644961e-01  -6.35477304e-02
   -2.95568883e-01  -9.46362782e-03]
 [  1.79661021e-01   2.34958977e-01  -9.55257118e-01  -8.40480402e-02
    1.60711512e-01   6.77234307e-03]]
In [6]:
solver.step(1)
In [7]:
imshow(solver.net.params['conv1/5x5_s1'][0].diff[:, 0].reshape(8, 8, 5, 5)
       .transpose(0, 2, 1, 3).reshape(8*5, 8*5), cmap='gray')
Out[7]:
<matplotlib.image.AxesImage at 0x7feb6b2a2b90>

Show the conv1 weights pics.

Then, I will train the model, and log some information.

In [8]:
%%time
niter = 1000
test_interval = 25
# losses will also be stored in the log
train_loss = zeros(niter)
mean_error= zeros(int(np.ceil(niter / test_interval)))
output = zeros((niter, 8, 3))

# the main solver loop
for it in range(niter):
    solver.step(1)  # SGD by Caffe
    
    # store the train loss
    train_loss[it] = solver.net.blobs['loss'].data
    
    # store the output on the first test batch
    # (start the forward pass at conv1 to avoid loading new data)
    solver.test_nets[0].forward(start='conv1/5x5_s1')
    output[it] = solver.test_nets[0].blobs['ip2'].data[:8]
    if it % test_interval == 0:
        # caculate the square error for each gaze vector
        solver.test_nets[0].forward()
        
        num_test = 100;
        sub_error = zeros((num_test, 2))
        square_error = zeros((num_test, 2))
        sum_Euclidean_error = zeros(num_test)
        gaze_3_l = zeros((num_test, 3));
        gaze_3_i = zeros((num_test, 3));
        gaze_2_l = zeros((num_test, 2));
        gaze_2_i = zeros((num_test, 2));
        gaze_3_l = solver.test_nets[0].blobs['gaze'].data[1:num_test+1];
        gaze_3_i = solver.test_nets[0].blobs['ip2'].data[1:num_test+1];
        gaze_2_l[:,0] = np.arcsin(-1*gaze_3_l[:,1])/np.pi*180;
        gaze_2_l[:,1] = np.arctan2(-1*gaze_3_l[:,0],-1*gaze_3_l[:,2])/np.pi*180;
        gaze_2_i[:,0] = np.arcsin(-1*gaze_3_i[:,1])/np.pi*180;
        gaze_2_i[:,1] = np.arctan2(-1*gaze_3_i[:,0],-1*gaze_3_i[:,2])/np.pi*180;
        for i in range(num_test):
            sub_error[i,:] = np.subtract(gaze_2_l[i]
                                         , gaze_2_i[i])
            square_error[i,:] = np.square(sub_error[i,:])
            sum_Euclidean_error[i] = np.sum(square_error[i,:],0)
            sum_Euclidean_error[i] = np.sqrt(sum_Euclidean_error[i])
        mean_error[it // test_interval] = np.sum(sum_Euclidean_error,0)/num_test
        print 'Iteration', it, '. Mean error is', mean_error[it // test_interval]
        #print sum_Euclidean_error

Iteration 0 . Mean error is 5.56457761257
Iteration 25 . Mean error is 6.44691358329
Iteration 50 . Mean error is 5.89212230156
Iteration 75 . Mean error is 6.31661414895
Iteration 100 . Mean error is 6.33742385238
Iteration 125 . Mean error is 8.35741338495
Iteration 150 . Mean error is 5.87506610143
Iteration 175 . Mean error is 5.01304377136
Iteration 200 . Mean error is 8.04641635509
Iteration 225 . Mean error is 5.66895957292
Iteration 250 . Mean error is 5.3962061307
Iteration 275 . Mean error is 6.77006762087
Iteration 300 . Mean error is 6.07147668041
Iteration 325 . Mean error is 6.6093807489
Iteration 350 . Mean error is 6.16242315795
Iteration 375 . Mean error is 8.54549327044
Iteration 400 . Mean error is 5.71221879775
Iteration 425 . Mean error is 5.47664945937
Iteration 450 . Mean error is 6.97413184727
Iteration 475 . Mean error is 5.57013469766
Iteration 500 . Mean error is 5.81354080474
Iteration 525 . Mean error is 6.80594971441
Iteration 550 . Mean error is 6.42979978176
Iteration 575 . Mean error is 6.08722762678
Iteration 600 . Mean error is 5.40358439778
Iteration 625 . Mean error is 8.69996932566
Iteration 650 . Mean error is 5.55237115076
Iteration 675 . Mean error is 4.93204246947
Iteration 700 . Mean error is 7.09688636176
Iteration 725 . Mean error is 5.76286694332
Iteration 750 . Mean error is 6.33955922186
Iteration 775 . Mean error is 6.80174188193
Iteration 800 . Mean error is 7.19629460001
Iteration 825 . Mean error is 6.34173896916
Iteration 850 . Mean error is 5.61023114747
Iteration 875 . Mean error is 8.41777532493
Iteration 900 . Mean error is 5.47717810271
Iteration 925 . Mean error is 5.46147139071
Iteration 950 . Mean error is 6.17464050089
Iteration 975 . Mean error is 5.62189381601
CPU times: user 3min 19s, sys: 33.5 s, total: 3min 52s
Wall time: 3min 52s
In [9]:
_, ax1 = subplots()
ax2 = ax1.twinx()
ax1.plot(arange(niter), train_loss)
ax2.plot(test_interval * arange(len(mean_error)), mean_error, 'r')
ax1.set_xlabel('iteration')
ax1.set_ylabel('train loss')
ax2.set_ylabel('mean error')
Out[9]:
<matplotlib.text.Text at 0x7feb6b1a7690>

**show you the train loss curve.

In [10]:
num_test = 1000


# (start the forward pass at conv1 to avoid loading new data)
solver.test_nets[0].forward(start='conv1/5x5_s1')
solver.test_nets[0].forward()

#figure(figsize=(10, 5))
#imshow(solver.test_nets[0].blobs['data'].data[:num_test, 0].transpose(1, 0, 2).reshape(36, num_test*60), cmap='gray')
    
#Print the label and train result
#for i in range(num_test):
#    print solver.test_nets[0].blobs['label'].data[i,:3] ,'label<->ip2', solver.test_nets[0].blobs['ip2'].data[i]

print '--------------------------------------------------------------------------------------------------------------'
# caculate the square error for each gaze vector
# caculate the square error for each gaze vector
sub_error = zeros((num_test, 2))
square_error = zeros((num_test, 2))
sum_Euclidean_error = zeros(num_test)
gaze_3_l = zeros((num_test, 3));
gaze_3_i = zeros((num_test, 3));
gaze_2_l = zeros((num_test, 2));
gaze_2_i = zeros((num_test, 2));
gaze_3_l = solver.test_nets[0].blobs['gaze'].data[:];
gaze_3_i = solver.test_nets[0].blobs['ip2'].data[:];
gaze_2_l[:,0] = np.arcsin(-1*gaze_3_l[:,1])/np.pi*180;
gaze_2_l[:,1] = np.arctan2(-1*gaze_3_l[:,0],-1*gaze_3_l[:,2])/np.pi*180;
gaze_2_i[:,0] = np.arcsin(-1*gaze_3_i[:,1])/np.pi*180;
gaze_2_i[:,1] = np.arctan2(-1*gaze_3_i[:,0],-1*gaze_3_i[:,2])/np.pi*180;
for i in range(num_test):
    sub_error[i,:] = np.subtract(gaze_2_l[i]
                                 , gaze_2_i[i])
    square_error[i,:] = np.square(sub_error[i,:])
    sum_Euclidean_error[i] = np.sum(square_error[i,:],0)
    sum_Euclidean_error[i] = np.sqrt(sum_Euclidean_error[i])
print num_test,'test pic, mean error is ',np.sum(sum_Euclidean_error,0)/num_test,'degree'
_, ax1 = subplots()
ax1.plot(arange(num_test), sum_Euclidean_error,'bo', label='sampled')
ax1.set_xlabel('num_test')
ax1.set_ylabel('sum_Euclidean_error')
    

--------------------------------------------------------------------------------------------------------------
1000 test pic, mean error is  6.10922246723 degree
Out[10]:
<matplotlib.text.Text at 0x7feb6b104c50>
In [11]:
imshow(solver.net.params['conv1/5x5_s1'][0].diff[:, 0].reshape(8, 8, 5, 5)
       .transpose(0, 2, 1, 3).reshape(8*5, 8*5), cmap='gray')
Out[11]:
<matplotlib.image.AxesImage at 0x7feb6b004ad0>
In [12]:
figure(figsize=(10, 5))
imshow(solver.net.params['conv2/3x3_s1'][0].diff[:, 0].reshape(8, 8, 3, 3)
       .transpose(0, 2, 1, 3).reshape(8*3, 8*3), cmap='gray')
Out[12]:
<matplotlib.image.AxesImage at 0x7feb6af8dfd0>
In [13]:
figure(figsize=(20, 10))
imshow(solver.test_nets[0].blobs['conv1/5x5_s1'].data[:8, :].reshape(16,32,32,56)
           .transpose(0,2,1,3).reshape(16*32, 32*56), cmap='gray')
Out[13]:
<matplotlib.image.AxesImage at 0x7feb6aebaa90>
In [14]:
figure(figsize=(20, 10))
imshow(solver.test_nets[0].blobs['conv2/3x3_s1'].data[:8, :].reshape(16, 32, 6, 12)
       .transpose(0,2,1,3).reshape(16*6,32*12), cmap='gray')
Out[14]:
<matplotlib.image.AxesImage at 0x7feb6ac7c4d0>
In [15]:
figure(figsize=(50, 25))
imshow(solver.test_nets[0].blobs['pool2/3x3_s2'].data[:8, :].reshape(64, 32, 8, 14)
       .transpose(0,2,1,3).reshape(64*8,32*14), cmap='gray')
Out[15]:
<matplotlib.image.AxesImage at 0x7feb6ade7790>
In [16]:
#solver.net.save('my_model.caffemodel') I do not know how to use this.
solver.snapshot() #SAVE MY MODEL IN THE DIR YOU DEFINE IN SOLVER FILE.
In [ ]: