caffe：自己的数据训练模型 pycaffe(五)

caffe的python接口 调用训练好的模型：

caffe_root = 'D:\caffe\caffe-windows-master'
sys.path.insert(0,caffe_root+'python')
import caffe

利用滑动窗口提取图片特征：

（1）获取滑动窗口：

def get_RegionProposal(self):
        height = self.frame.shape[0]
        width = self.frame.shape[1]
        wi_width = [192,384]
        step_rate = 0.7
        boxes = []
        for si in wi_width:
            step_x = si * step_rate
            x_num = (width - si)/step_x + 1
            sj =si
            step_y = sj * step_rate
            y_num = (height-sj)/step_y +1
            for i in xrange(int(x_num)):
                for j in xrange(int(y_num)):
                    x1 = step_x * i
                    y1 = step_y * j
                    x2 = x1+si-1
                    y2 = y1+sj-1

                    subtractor = np.array([1, 1, 1, 1])
                    box = [x1,y1,x2,y2] + subtractor
                    boxes.append(box)
        return np.array(boxes)

（2）提取特征：

def extract_feature_from_RCNN(self,net,transformer):
        boxes = self.get_RegionProposal()
        feats = []
        for i,box in enumerate(boxes):
            box = box.astype(int)
            tile  = self.frame[box[1]:box[3],box[0]:box[2],:]
            feat = self.caffe_predict(tile,net,transformer)

            if len(feats) == 0:
                feats = [0] *len(feat)
            feats = np.vstack((feats,feat))
        return feats[1:]

参数net,transformer:

def extract_feature_from_RCNN(self,net,transformer):

     boxes = self.get_RegionProposal()
     feats = []
     labels = []
     for i,box in enumerate(boxes):
         box = box.astype(int)
         tile  = self.frame[box[1]:box[3],box[0]:box[2],:]
         feat, label = self.caffe_predict(tile,net,transformer)

         if len(feats) == 0:
             feats = [0] *len(feat)
         feats = np.vstack((feats,feat))
         labels.append(label)
      return feats[1:], labels

输出特征：

def caffe_predict(self, img, net, transformer):
     try: 
         # transform it and copy it into the net       
         net.blobs['data'].data[...] = transformer.preprocess('data', img)
         # perform classification

         net.forward()
         feat_vec = net.blobs['loss3/feature1'].data[0]

         output = net.forward()
         out_prob = output['prob'][0]# prob vector

         label = out_prob.argmax()#
         prob = out_prob[label]# the prob value correspoding to the predict catogory
         return feat_vec, label

     except Exception as e:
         print e
          return 0

提好特征存储在 .info文件中，在检索时调用特征匹配：

def ObjRetrival(self): #retrival an object
        Nan = float('nan')
        distance = {}
        videolistLen = len(self.videolist)

        for video in self.videolist:
            #load video keyframe feats # print video # media2/a/a.
            FeatsPath = self.FeatsDB + video
            FeatsPath = FeatsPath.replace('//','/')
            f = open(FeatsPath  + '.info','rb')           
            f.seek(0)
            video_info = pickle.load(f)
            frame_feats = video_info['keyframefeats']
            #save to pool
            video_dis = []

            for framename in frame_feats.keys():#framename = '6s.jpg'
                feats = frame_feats[framename] 
                min_dis = 100000.0
                name = 0

                for i,feat in enumerate(feats): 
                    if isnan(feat[0]):
                        continue
                    dis = self.similarity_computation1(self.template,feat)
                    if dis < min_dis:
                        name = framename
                        min_dis = dis

                if min_dis <= 220:
                    video_dis.append((name, min_dis))

            sorted_dis = sorted(video_dis, key = itemgetter(1)) 
            #combine:
            union_result = self.do_union(sorted_dis)
            distance[video] = union_result

参考：http://www.cnblogs.com/denny402/p/5686257.html

如果用公式  y=f(wx+b)

来表示整个运算过程的话，那么w和b就是我们需要训练的东西，w称为权值，在cnn中也可以叫做卷积核（filter），b是偏置项。f是激活函数，有sigmoid、relu等。x就是输入的数据。

数据训练完成后，保存的caffemodel里面，实际上就是各层的w和b值。

我们运行代码：

deploy=root + 'mnist/deploy.prototxt'    #deploy文件
caffe_model=root + 'mnist/lenet_iter_9380.caffemodel'   #训练好的 caffemodel
net = caffe.Net(net_file,caffe_model,caffe.TEST)   #加载model和network

就把所有的参数和数据都加载到一个net变量里面了，但是net是一个很复杂的object, 想直接显示出来看是不行的。其中：

net.params: 保存各层的参数值（w和b)

net.blobs: 保存各层的数据值

可用命令：

[(k,v[0].data) for k,v in net.params.items()]

查看各层的参数值，其中k表示层的名称，v[0].data就是各层的W值，而v[1].data是各层的b值。注意：并不是所有的层都有参数，只有卷积层和全连接层才有。

也可以不查看具体值，只想看一下shape,可用命令

[(k,v[0].data.shape) for k,v in net.params.items()]

假设我们知道其中第一个卷积层的名字叫'Convolution1', 则我们可以提取这个层的参数：

w1=net.params['Convolution1'][0].data
b1=net.params['Convolution1'][1].data

输入这些代码，实际查看一下，对你理解network非常有帮助。

同理，除了查看参数，我们还可以查看数据，但是要注意的是，net里面刚开始是没有数据的，需要运行：

net.forward()

之后才会有数据。我们可以用代码：

[(k,v.data.shape) for k,v in net.blobs.items()]

或

[(k,v.data) for k,v in net.blobs.items()]

来查看各层的数据。注意和上面查看参数的区别，一个是net.params, 一个是net.blobs.

实际上数据刚输入的时候，我们叫图片数据，卷积之后我们就叫特征了。

如果要抽取第一个全连接层的特征，则可用命令：

fea=net.blobs['InnerProduct1'].data

只要知道某个层的名称，就可以抽取这个层的特征。

推荐大家在spyder中，运行一下上面的所有代码，深入理解模型各层。

最后，总结一个代码：

import caffe
import numpy as np
root='/home/xxx/'   #根目录
deploy=root + 'mnist/deploy.prototxt'    #deploy文件
caffe_model=root + 'mnist/lenet_iter_9380.caffemodel'   #训练好的 caffemodel
net = caffe.Net(deploy,caffe_model,caffe.TEST)   #加载model和network

[(k,v[0].data.shape) for k,v in net.params.items()]  #查看各层参数规模

w1=net.params['Convolution1'][0].data  #提取参数w
b1=net.params['Convolution1'][1].data  #提取参数b

net.forward()   #运行测试

[(k,v.data.shape) for k,v in net.blobs.items()]  #查看各层数据规模

fea=net.blobs['InnerProduct1'].data   #提取某层数据（特征）