notebook.community

Edit and run 





In [1]:



    


import sys
sys.path.append('../src/')
sys.path.append('/home/ipl/installs/caffe-rc/python/')
import matplotlib
%matplotlib inline
from matplotlib import pylab as plt
import numpy as np
import caffe
import cv2
import re
from sklearn import svm
from sklearn import metrics
import utils
from datetime import datetime as dt

from dataset import CUB_200_2011
from storage import datastore
from deep_extractor import CNN_Features_CAFFE_REFERENCE, Berkeley_Extractor
from datetime import datetime as dt
import settings



    











In [2]:



    


cub = CUB_200_2011(settings.CUB_ROOT)

load R data





In [ ]:



    


feature_extractor_r = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccrftt-100000')))
Xtrain_r, ytrain, Xtest_r, ytest = cub.get_train_test(feature_extractor_r.extract_one)



    











In [3]:



    


feature_extractor_r = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccrft2st-5000')))
Xtrain_r, ytrain, Xtest_r, ytest = cub.get_train_test(feature_extractor_r.extract_one)

load C data





In [ ]:



    


feature_extractor_c = Berkeley_Extractor(datastore(settings.storage('bmbc')))
Xtrain_c, ytrain, Xtest_c, ytest = cub.get_train_test(feature_extractor_c.extract_one)



    











In [ ]:



    


feature_extractor_c = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('cccftt-100000')))
Xtrain_c, ytrain, Xtest_c, ytest = cub.get_train_test(feature_extractor_c.extract_one)



    











In [4]:



    


feature_extractor_c = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('cccft2st-50000')))
Xtrain_c, ytrain, Xtest_c, ytest = cub.get_train_test(feature_extractor_c.extract_one)

load head and body data





In [ ]:



    


feature_extractor_h = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccpheadrfftn-100000')))
Xtrain_h, ytrain, Xtest_h, ytest = cub.get_train_test(feature_extractor_h.extract_one)



    











In [5]:



    


feature_extractor_h = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccpheadrfftn2st-50000')))
Xtrain_h, ytrain, Xtest_h, ytest = cub.get_train_test(feature_extractor_h.extract_one)



    











In [ ]:



    


feature_extractor_b = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccpbodyrfftn-100000')))
Xtrain_b, ytrain, Xtest_b, ytest = cub.get_train_test(feature_extractor_b.extract_one)



    











In [6]:



    


feature_extractor_b = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccpbodyrfftn2st-50000')))
Xtrain_b, ytrain, Xtest_b, ytest = cub.get_train_test(feature_extractor_b.extract_one)

load flipped versions





In [7]:



    


# feature_extractor_r = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccrfttflp-100000')))
feature_extractor_r = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccrft2stflp-5000')))
Xtrain_r_f, ytrain_f, Xtest_r_f, ytest = cub.get_train_test(feature_extractor_r.extract_one)



    











In [8]:



    


feature_extractor_c = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('cccft2stflp-50000')))
# feature_extractor_c = Berkeley_Extractor(datastore(settings.storage('bmbcflp')))
# feature_extractor_c = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('cccfttflp-100000')))
Xtrain_c_f, ytrain_f, Xtest_c_f, ytest = cub.get_train_test(feature_extractor_c.extract_one)



    











In [9]:



    


# feature_extractor_h = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccpheadrfftnflp-100000')))
feature_extractor_h = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccpheadrfftn2stflp-50000')))
Xtrain_h_f, ytrain_f, Xtest_h_f, ytest = cub.get_train_test(feature_extractor_h.extract_one)



    











In [10]:



    


# feature_extractor_h = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccpbodyrfftnflp-100000')))
feature_extractor_b = CNN_Features_CAFFE_REFERENCE(datastore(settings.storage('ccpbodyrfftn2stflp-50000')))
Xtrain_b_f, ytrain_f, Xtest_b_f, ytest = cub.get_train_test(feature_extractor_h.extract_one)

classification!





In [13]:



    


Xtrain = np.hstack((Xtrain_r, Xtrain_c, Xtrain_h, Xtrain_b))
Xtest = np.hstack((Xtest_r, Xtest_c, Xtest_h, Xtest_b))

Xtrain_f = np.hstack((Xtrain_r_f, Xtrain_c_f, Xtrain_h_f, Xtrain_b_f))
Xtest_aug = np.hstack((Xtest_r_f, Xtest_c_f, Xtest_h_f, Xtest_b_f))

Xtrain = np.vstack((Xtrain, Xtrain_f))
ytrain = np.concatenate((ytrain_f, ytrain_f))

################################

# Xtrain = utils.l2_feat_norm(Xtrain)
# Xtest = utils.l2_feat_norm(Xtest)



    











In [14]:



    


# svm_c = 0.1

for svm_c in [1e-5]:
    a = dt.now()
    model = svm.LinearSVC(C=svm_c)
    model.fit(Xtrain, ytrain)
    predictions = model.predict(Xtest)
    preds_train = model.predict(Xtrain)
    b = dt.now()

    print 'c', svm_c
    print 'accuracy', metrics.accuracy_score(ytest, predictions), '=== mean accuracy', utils.mean_accuracy(ytest, predictions)
    print 'train accuracy', metrics.accuracy_score(ytrain, preds_train)
    print 'in', (b - a)
    print '-----------------------'



    


















    






c 1e-05
accuracy 0.643596824301 === mean accuracy 0.647426
train accuracy 0.502085418752
in 0:00:31.273981
-----------------------

VIS Segmentations





In [6]:



    


o_image = caffe.io.load_image('/home/ipl/datasets/CUB-200-2011/CUB_200_2011/CUB_200_2011/images/058.Pigeon_Guillemot/Pigeon_Guillemot_0007_40313.jpg')
s_image = caffe.io.load_image('/home/ipl/datasets/CUB-200-2011/segmentations/058.Pigeon_Guillemot/Pigeon_Guillemot_0007_40313.png', color=False)



    











In [7]:



    


plt.matshow(s_image[:, :, 0]); plt.figure(); plt.imshow(o_image)
s_image.shape



    


















    
Out[7]:








(428, 500, 1)










    

















    
























In [9]:



    


so_image = np.where(s_image <= np.median(s_image), np.ones_like(s_image) * 0.5, o_image)
import skimage



    











In [10]:



    


plt.imshow(so_image)
skimage.io.imsave('/home/ipl/Desktop/test.jpg', so_image)



    


















    
























In [11]:



    


import scipy.io



    











In [12]:



    


pred_1 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-10000/cccftt-10000.mat')
pred_2 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-20000/cccftt-20000.mat')
pred_3 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-30000/cccftt-30000.mat')
pred_4 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-40000/cccftt-40000.mat')
pred_5 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-50000/cccftt-50000.mat')
pred_6 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-60000/cccftt-60000.mat')
pred_7 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-70000/cccftt-70000.mat')
pred_8 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-80000/cccftt-80000.mat')
pred_9 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-90000/cccftt-90000.mat')
pred_10 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftt-100000/cccftt-100000.mat')



    











In [16]:



    


pred_1 = pred_1['preds'][0, :]
pred_2 = pred_2['preds'][0, :]
pred_3 = pred_3['preds'][0, :]
pred_4 = pred_4['preds'][0, :]
pred_5 = pred_5['preds'][0, :]
pred_6 = pred_6['preds'][0, :]
pred_7 = pred_7['preds'][0, :]
pred_8 = pred_8['preds'][0, :]
pred_9 = pred_9['preds'][0, :]
pred_10 = pred_10['preds'][0, :]



    











In [17]:



    


cor_1 = pred_1 == ytest
cor_2 = pred_2 == ytest
cor_3 = pred_3 == ytest
cor_4 = pred_4 == ytest
cor_5 = pred_5 == ytest
cor_6 = pred_6 == ytest
cor_7 = pred_7 == ytest
cor_8 = pred_8 == ytest
cor_9 = pred_9 == ytest
cor_10 = pred_10 == ytest



    











In [18]:



    


(cor_1 | cor_2 | cor_3 | cor_4 | cor_5 | cor_6 | cor_7 | cor_8 | cor_9 | cor_10).sum() / 5794.



    


















    
Out[18]:








0.66051087331722469

















In [19]:



    


cors = [cor_1, cor_2, cor_3, cor_4, cor_5, cor_6, cor_7, cor_8, cor_9, cor_10]
cor = cor_3[:1024]
fig = plt.figure()
ax = fig.add_subplot(111)
ax.matshow(cor.reshape((32, 32)))
ax.matshow(cor.reshape((32, 32)))



    


















    
Out[19]:








<matplotlib.image.AxesImage at 0x1ce27150>










    
























In [20]:



    


svm_c = 0.0001
cub = CUB_200_2011(settings.CUB_ROOT)
ft_storage = datastore(settings.storage('cccftt-10000'))
ft_extractor = CNN_Features_CAFFE_REFERENCE(ft_storage, make_net=False)

a = dt.now()
Xtrain, ytrain, Xtest, ytest = cub.get_train_test(ft_extractor.extract_one)
model = svm.LinearSVC(C=svm_c)
model.fit(Xtrain, ytrain)
predictions = model.predict(Xtest)
b = dt.now()

print 'accuracy', metrics.accuracy_score(ytest, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest, predictions)
print 'in', (b - a)



    


















    






accuracy 0.634449430445
mean accuracy 0.637258
in 0:00:13.803277

















In [21]:



    


svm_c = 0.01
cub = CUB_200_2011(settings.CUB_ROOT)
ft_storage = datastore(settings.storage('cccftt-10000'))
ft_extractor = CNN_Features_CAFFE_REFERENCE(ft_storage, make_net=False)

a = dt.now()
Xtrain, ytrain, Xtest, ytest = cub.get_train_test(ft_extractor.extract_one)
model = svm.SVC(C=svm_c, kernel='linear', probability=True)
model.fit(Xtrain, ytrain)
predictions = model.predict(Xtest)
b = dt.now()

print 'accuracy', metrics.accuracy_score(ytest, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest, predictions)
print 'in', (b - a)



    


















    






accuracy 0.619433897135
mean accuracy 0.622933
in 0:16:21.162068

















In [22]:



    


svm_c = 0.01
cub = CUB_200_2011(settings.CUB_ROOT)
ft_storage = datastore(settings.storage('cccftt-10000'))
ft_extractor = CNN_Features_CAFFE_REFERENCE(ft_storage, make_net=False)

a = dt.now()
Xtrain, ytrain, Xtest, ytest = cub.get_train_test(ft_extractor.extract_one)
model = svm.SVC(C=svm_c, kernel='linear', probability=True)
model.fit(Xtrain, ytrain)
predictions = model.predict(Xtest)
b = dt.now()

print 'accuracy', metrics.accuracy_score(ytest, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest, predictions)
print 'in', (b - a)



    


















    






accuracy 0.619433897135
mean accuracy 0.622933
in 0:14:56.433400

















In [23]:



    


svm_c = 0.05
cub = CUB_200_2011(settings.CUB_ROOT)
ft_storage = datastore(settings.storage('cccftt-10000'))
ft_extractor = CNN_Features_CAFFE_REFERENCE(ft_storage, make_net=False)

a = dt.now()
Xtrain, ytrain, Xtest, ytest = cub.get_train_test(ft_extractor.extract_one)
model = svm.SVC(C=svm_c, kernel='linear', probability=True)
model.fit(Xtrain, ytrain)
predictions = model.predict(Xtest)
b = dt.now()

print 'accuracy', metrics.accuracy_score(ytest, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest, predictions)
print 'in', (b - a)



    


















    






accuracy 0.619433897135
mean accuracy 0.622933
in 0:14:56.749401

















In [24]:



    


svm_c = 0.001
cub = CUB_200_2011(settings.CUB_ROOT)
ft_storage = datastore(settings.storage('cccftt-10000'))
ft_extractor = CNN_Features_CAFFE_REFERENCE(ft_storage, make_net=False)

a = dt.now()
Xtrain, ytrain, Xtest, ytest = cub.get_train_test(ft_extractor.extract_one)
model = svm.SVC(C=svm_c, kernel='linear', probability=True)
model.fit(Xtrain, ytrain)
predictions = model.predict(Xtest)
b = dt.now()

print 'accuracy', metrics.accuracy_score(ytest, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest, predictions)
print 'in', (b - a)



    


















    






accuracy 0.619433897135
mean accuracy 0.622933
in 0:14:56.624264

















In [25]:



    


svm_c = 0.005
cub = CUB_200_2011(settings.CUB_ROOT)
ft_storage = datastore(settings.storage('cccftt-10000'))
ft_extractor = CNN_Features_CAFFE_REFERENCE(ft_storage, make_net=False)

a = dt.now()
Xtrain, ytrain, Xtest, ytest = cub.get_train_test(ft_extractor.extract_one)
model = svm.SVC(C=svm_c, kernel='linear', probability=True)
model.fit(Xtrain, ytrain)
predictions = model.predict(Xtest)
b = dt.now()

print 'accuracy', metrics.accuracy_score(ytest, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest, predictions)
print 'in', (b - a)



    


















    






accuracy 0.619433897135
mean accuracy 0.622933
in 0:14:56.474503

















In [26]:



    


pred_v_1_1 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftv1-10000/cccftv1-10000.mat')['preds'][0, :]
pred_v_1_2 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftv1-20000/cccftv1-20000.mat')['preds'][0, :]
pred_v_2_1 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftv2-10000/cccftv2-10000.mat')['preds'][0, :]
pred_v_2_2 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftv2-20000/cccftv2-20000.mat')['preds'][0, :]
pred_v_1_1_2 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftv1_2-10000/cccftv1_2-10000.mat')['preds'][0, :]
pred_v_1_2_2 = scipy.io.loadmat('/home/ipl/datastores/predictions/preds/cccftv1_2-20000/cccftv1_2-20000.mat')['preds'][0, :]



    











In [27]:



    


cor_v_1_1 = pred_v_1_1 == ytest
cor_v_1_2 = pred_v_1_2 == ytest
cor_v_2_1 = pred_v_2_1 == ytest
cor_v_2_2 = pred_v_2_2 == ytest
cor_v_1_1_2 = pred_v_1_1_2 == ytest
cor_v_1_2_2 = pred_v_1_2_2 == ytest



    











In [28]:



    


(cor_v_1_2 & ~cor_v_1_2_2).sum()



    


















    
Out[28]:








239

















In [29]:



    


net = caffe.Classifier('/home/ipl/installs/caffe-rc/models/bvlc_reference_caffenet/deploy_conv.prototxt', '/home/ipl/installs/caffe-rc/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel', mean=np.load('/home/ipl/installs/caffe-rc/python/caffe/imagenet/ilsvrc_2012_mean.npy'), channel_swap=(2, 1, 0), raw_scale=255)



    











In [30]:



    


net.set_mode_gpu()
net.set_phase_test()
out = net.forward_all(blobs=['data', 'conv1'], data=np.asarray([net.preprocess('data', img)]))
out['conv1'].shape, out['data'].shape



    


















    
Out[30]:








((1, 96, 55, 55), (1, 3, 227, 227))

















In [31]:



    


net.preprocess('data', img).shape



    


















    
Out[31]:








(3, 227, 227)

















In [10]:



    


import sys
sys.path.append('../src/')
sys.path.append('/home/ipl/installs/caffe-rc/python/')
import matplotlib
%matplotlib inline
from matplotlib import pylab as plt
import numpy as np
import caffe
import cv2
import re
from sklearn import svm
from sklearn import metrics
import utils
from datetime import datetime as dt

from dataset import CUB_200_2011
from storage import datastore
from deep_extractor import CNN_Features_CAFFE_REFERENCE
from datetime import datetime as dt
import settings
from parts import *
cub = CUB_200_2011(settings.CUB_ROOT)
cub_parts = cub.get_parts()
bbox = cub.get_bbox()
IDtrain, IDtest = cub.get_train_test_id()

def vis_near(test_id, train_id):
    img_test = caffe.io.load_image(cub.get_image_info(test_id))
    parts_test = cub_parts.for_image(test_id)
    
    img_train = caffe.io.load_image(cub.get_image_info(train_id))
    parts_train = cub_parts.for_image(train_id)
    
    parts_transfered = parts_train.transfer(bbox[train_id-1], bbox[test_id-1])
    fig = plt.figure(figsize=(15, 10))
    
    def vis_parts(ax, img, parts, img_id):
        filtered_parts = parts.filter_by_name(Parts.HEAD_PART_NAMES)
        new_img = filtered_parts.draw_rect(img)
        ax.imshow(new_img)
        ax.set_title(img_id)
        ax.set_xlim((0, img.shape[1]))
        ax.set_ylim((img.shape[0], 0))
        parts.draw_part(ax)
    
    ax = fig.add_subplot(131)
    vis_parts(ax, img_test, parts_test, test_id)
    
    ax = fig.add_subplot(132)
    vis_parts(ax, img_test, parts_transfered, 'transfered')
    
    ax = fig.add_subplot(133)
    vis_parts(ax, img_train, parts_train, train_id)



    











In [11]:



    


tests_id = [1]
train_ids = [379]

test_ids = range(500,502)

for i in test_ids:
    test_id = IDtest[i]
    train_id = IDtrain[NNS[i]]
    vis_near(test_id, train_id)



    


















    






---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-11-6207a3c8bc34> in <module>()
      6 for i in test_ids:
      7     test_id = IDtest[i]
----> 8     train_id = IDtrain[NNS[i]]
      9     vis_near(test_id, train_id)

NameError: name 'NNS' is not defined
















In [17]:



    


net = caffe.Classifier('/home/ipl/installs/caffe-rc/models/finetune_cub_cropped/deploy.prototxt', '/home/ipl/installs/caffe-rc/models/finetune_cub_cropped/finetune_cub_cropped_iter_100000.caffemodel', mean=np.load('/home/ipl/installs/caffe-rc/python/caffe/imagenet/ilsvrc_2012_mean.npy'), channel_swap=(2, 1, 0), raw_scale=255)
net.set_mode_gpu()
net.set_phase_test()



    











In [18]:



    


test_id = 50
train_id = 69

test_img = caffe.io.load_image(cub.get_image_info(test_id))
train_img = caffe.io.load_image(cub.get_image_info(train_id))

train_img_flip = np.fliplr(train_img)

def get_feat(img, layer='pool5'):
    net.predict([img])
    feat = net.blobs[layer].data[0].flatten()
    feat = feat / np.linalg.norm(feat)
    return feat

test_feat = get_feat(test_img)
train_feat = get_feat(train_img)
train_feat_flip = get_feat(train_img_flip)

print 'the distance'
print np.linalg.norm(test_feat - train_feat)
print 'the distance with flipped'
print np.linalg.norm(test_feat - train_feat_flip)



    


















    






the distance
1.00959
the distance with flipped
1.15572

final classification with transfered part locations





In [19]:



    


from storage import datastore
from dataset import CUB_200_2011, CUB_200_2011_Parts_Head, CUB_200_2011_Parts_Body
from deep_extractor import CNN_Features_CAFFE_REFERENCE
from parts import Parts
import click
import numpy as np
import sklearn.neighbors
import sklearn.svm
import sklearn.metrics
from time import time
import caffe



    











In [12]:



    


storage_name = 'cache-cccftt'
layer = 'pool5'
name = '%s-%s' % ('cccftt', 100000)
normalize_feat = True
n_neighbors = 1
feat_layer = 'fc7'  # obviously changing this only here will make things worse

cub = CUB_200_2011(settings.CUB_ROOT)
cub_part_head = CUB_200_2011_Parts_Head(settings.CUB_ROOT)
cub_part_body = CUB_200_2011_Parts_Body(settings.CUB_ROOT)

safe = datastore(settings.storage(storage_name))
safe.super_name = 'features'
safe.sub_name = name

instance_path = safe.get_instance_path(safe.super_name, safe.sub_name, 'feat_cache_%s' % layer)
feat = safe.load_large_instance(instance_path, 4)

# should we normalize the feats?
if normalize_feat:
    # snippet from : http://stackoverflow.com/a/8904762/428321
    # I've went for l2 normalization.
    # row_sums = feat.sum(axis=1)
    row_norms = np.linalg.norm(feat, axis=1)
    new_feat = feat / row_norms[:, np.newaxis]
    feat = new_feat

IDtrain, IDtest = cub.get_train_test_id()

# the following line is not really a good idea. Only works for this dataset.
Xtrain = feat[IDtrain-1, :]
Xtest = feat[IDtest-1, :]

nn_storage_name = 'nn-parts'
nn_storage = datastore(settings.storage(nn_storage_name))
nn_storage.super_name = '%s_%s' % (storage_name, name)
nn_storage.sub_name = layer
nn_storage.instance_name = 'norm_%s.mat' % str(normalize_feat)
nn_storage.instance_path = nn_storage.get_instance_path(nn_storage.super_name, nn_storage.sub_name, nn_storage.instance_name)

NNS = nn_storage.load_instance(nn_storage.instance_path)

# convert (N, 1) to (N,)
NNS = NNS.T[0]

# transfer part locations
all_parts_cub = cub.get_parts()
estimated_test_parts = Parts()
all_image_infos = cub.get_all_image_infos()
bbox = cub.get_bbox()

tic = time()
# estimate test parts with NN part transfer
for i in range(IDtest.shape[0]):
    test_id = IDtest[i]
    nn_id = IDtrain[NNS[i]]
    nn_parts = all_parts_cub.for_image(nn_id)

    test_bbox = bbox[test_id - 1]
    nn_bbox = bbox[nn_id - 1]

    estimated_parts = nn_parts.transfer(nn_bbox, test_bbox)
    estimated_parts.set_for(test_id)
    estimated_test_parts.appends(estimated_parts)

toc = time() - tic
print 'transfered in', toc



    


















    






---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-12-260bafc69122> in <module>()
      7 
      8 cub = CUB_200_2011(settings.CUB_ROOT)
----> 9 cub_part_head = CUB_200_2011_Parts_Head(settings.CUB_ROOT)
     10 cub_part_body = CUB_200_2011_Parts_Body(settings.CUB_ROOT)
     11 

NameError: name 'CUB_200_2011_Parts_Head' is not defined
















In [21]:



    


# load data
tic = time()
features_storage_r = datastore(settings.storage('ccrft'))
feature_extractor_r = CNN_Features_CAFFE_REFERENCE(features_storage_r, make_net=False)

features_storage_c = datastore(settings.storage('cccft'))
feature_extractor_c = CNN_Features_CAFFE_REFERENCE(features_storage_c, make_net=False)

features_storage_p_h = datastore(settings.storage('ccpheadft-100000'))
feature_extractor_p_h = CNN_Features_CAFFE_REFERENCE(features_storage_p_h, make_net=False)

features_storage_p_h = datastore(settings.storage('ccpheadft-100000'))
feature_extractor_p_h = CNN_Features_CAFFE_REFERENCE(features_storage_p_h, make_net=False)

features_storage_p_b = datastore(settings.storage('ccpbodyft-10000'))
feature_extractor_p_b = CNN_Features_CAFFE_REFERENCE(features_storage_p_b, make_net=False)

Xtrain_r, ytrain_r, Xtest_r, ytest_r = cub.get_train_test(feature_extractor_r.extract_one)
Xtrain_c, ytrain_c, Xtest_c, ytest_c = cub.get_train_test(feature_extractor_c.extract_one)
Xtrain_p_h, ytrain_p_h, Xtest_p_h, ytest_p_h = cub_part_head.get_train_test(feature_extractor_p_h.extract_one)
Xtrain_p_b, ytrain_p_b, Xtest_p_b, ytest_p_b = cub_part_body.get_train_test(feature_extractor_p_b.extract_one)
toc = time() - tic
print 'loaded data in', toc



    


















    






loaded data in 11.90700984

















In [22]:



    


# load caffe network
name = 'ccpheadft-100000'
net = caffe.Classifier(settings.model(name), settings.pretrained(name), mean=np.load(settings.ILSVRC_MEAN), channel_swap=(2, 1, 0), raw_scale=255)
net.set_phase_test()
net.set_mode_gpu()

# load estimated head data
new_Xtest_p_h = np.zeros(Xtest_p_h.shape)

for i, t_id in enumerate(IDtest):
    t_parts = estimated_test_parts.for_image(t_id)
    t_img_addr = all_image_infos[t_id]
    t_img = caffe.io.load_image(t_img_addr)
    t_parts_head = t_parts.filter_by_name(Parts.HEAD_PART_NAMES)
    t_img_head = t_parts_head.get_rect(t_img)
    net.predict([t_img_head], oversample=False)
    new_Xtest_p_h[i, :] = net.blobs[feat_layer].data[0].flatten()

# Xtest_p_h = new_Xtest_p_h

classify with oracle whole, bbox and head





In [23]:



    


# make the final feature vector
Xtrain = np.concatenate((Xtrain_r, Xtrain_c, Xtrain_p_h), axis=1)
Xtest = np.concatenate((Xtest_r, Xtest_c, Xtest_p_h), axis=1)

# do classification
tic = time()
model = sklearn.svm.LinearSVC(C=0.0001)
model.fit(Xtrain, ytrain_r)
predictions = model.predict(Xtest)
toc = time() - tic

print 'classified in', toc
print '--------------------'
print 'accuracy', sklearn.metrics.accuracy_score(ytest_r, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest_r, predictions)



    


















    






classified in 29.3628489971
--------------------
accuracy 0.772868484639
mean accuracy 0.775268

classifiying with oracle head parts





In [41]:



    


model = sklearn.svm.LinearSVC(C=0.0001)
model.fit(Xtrain_p_h, ytrain_r)
predictions = model.predict(Xtest_p_h)
print sklearn.metrics.accuracy_score(ytest_r, predictions)
print utils.mean_accuracy(ytest_r, predictions)



    


















    






0.667932343804
0.671085

classifying with estimated head parts





In [42]:



    


model = sklearn.svm.LinearSVC(C=0.0001)
model.fit(Xtrain_p_h, ytrain_r)
predictions = model.predict(new_Xtest_p_h)
print sklearn.metrics.accuracy_score(ytest_r, predictions)
print utils.mean_accuracy(ytest_r, predictions)



    


















    






0.465308940283
0.47045

classify with oracle whole, bbox and estimated head





In [43]:



    


# make the final feature vector
Xtrain = np.concatenate((Xtrain_r, Xtrain_c, Xtrain_p_h), axis=1)
Xtest = np.concatenate((Xtest_r, Xtest_c, new_Xtest_p_h), axis=1)

# do classification
tic = time()
model = sklearn.svm.LinearSVC(C=0.0001)
model.fit(Xtrain, ytrain_r)
predictions = model.predict(Xtest)
toc = time() - tic

print 'classified in', toc
print '--------------------'
print 'accuracy', sklearn.metrics.accuracy_score(ytest_r, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest_r, predictions)



    


















    






classified in 28.4475951195
--------------------
accuracy 0.681739730756
mean accuracy 0.685648

with BODY

oracle with: whole, bbox, head and body





In [44]:



    


# make the final feature vector
Xtrain = np.concatenate((Xtrain_c, Xtrain_p_h, Xtrain_p_b), axis=1)
Xtest = np.concatenate((Xtest_c, Xtest_p_h, Xtest_p_b), axis=1)

# do classification
tic = time()
model = sklearn.svm.LinearSVC(C=0.0001)
model.fit(Xtrain, ytrain_r)
predictions = model.predict(Xtest)
toc = time() - tic

print 'classified in', toc
print '--------------------'
print 'accuracy', sklearn.metrics.accuracy_score(ytest_r, predictions)
print 'mean accuracy', utils.mean_accuracy(ytest_r, predictions)



    


















    






classified in 27.7391281128
--------------------
accuracy 0.783051432516
mean accuracy 0.785313

debugging





In [24]:



    


for i, t_id in enumerate(IDtest):
    if i < 1923:
        continue
#     t_parts = estimated_test_parts.for_image(t_id)
    t_parts = all_parts_cub.for_image(t_id)
    t_img_addr = all_image_infos[t_id]
    t_img = caffe.io.load_image(t_img_addr)
    t_parts_head = t_parts.filter_by_name(Parts.HEAD_PART_NAMES)
    t_img_head = t_parts_head.get_rect(t_img, add_noise=True, noise_std_c=5, noise_std_d=5)
    plt.imshow(t_img_head)
    break



    


















    
























In [ ]:

Content source: yassersouri/omgh

Similar notebooks:

notebook.community | gallery | about