代码笔记：caffereid利用训练好的模型提取特征

set -e
if [ ! -n "$1" ] ;then
echo "\$1 is empty, default is 0"
gpu=0
else
echo "use $1-th gpu"
gpu=$1
fi
#base_model=caffenet
base_model=vgg_reduce
#base_model=googlenet
#base_model=res50
feature_name=fc7
#feature_name=pool5/7x7_s1
#feature_name=pool5
model_file=./models/market1501/$base_model/snapshot/${base_model}.full_iter_18000.caffemodel

python examples/market1501/testing/extract_feature.py \
examples/market1501/lists/test.lst \
examples/market1501/datamat/test.lst.fc7.mat \
examples/market1501/datamat/test.lst.score.mat \
--gpu $gpu \
--model_def ./models/market1501/$base_model/dev.proto \
--feature_name $feature_name \
--pretrained_model $model_file \
--mean_value 97.8286,99.0468,105.606

python examples/market1501/testing/extract_feature.py \
examples/market1501/lists/query.lst \
examples/market1501/datamat/query.lst.fc7.mat \
examples/market1501/datamat/query.lst.score.mat \
--gpu $gpu \
--model_def ./models/market1501/$base_model/dev.proto \
--feature_name $feature_name \
--pretrained_model $model_file \
--mean_value 97.8286,99.0468,105.606

extract_feature.py

import numpy as np
import os
import sys
import argparse
import glob
import time
import _init_paths
from units import SClassifier
import caffe
import scipy.io as sio

def load_txt(xfile):
img_files = []
labels = []
for line in open(xfile):
line = line.strip('\n').split(' ')
assert(len(line) == 2)
img_files.append(line[0])
labels.append(int(float(line[1])))
return img_files, labels

def main(argv):·

parser = argparse.ArgumentParser()
# Required arguments: input and output files.
#由于没有设置default，因此这些参数在命令行中是必须的，否则会报错
parser.add_argument(
"input_file",
help="Input image, directory"
)
parser.add_argument(
"feature_file",
help="Feature mat filename."
)
parser.add_argument(
"score_file",
help="Score Output mat filename."
)
# Optional arguments.
# 由于设置了default，因此这些参数在命令行中是可选的
parser.add_argument(
"--model_def",
default=os.path.join(
"./models/market1501/caffenet/feature.proto"),
help="Model definition file."
)
parser.add_argument(
"--pretrained_model",
default=os.path.join(
"./models/market1501/caffenet/caffenet_iter_17000.caffemodel"),
help="Trained model weights file."
)
parser.add_argument(
"--gpu",
type=int,
default=-1,
help="Switch for gpu computation."
)
parser.add_argument(
//action='store_true'的意思是说，如果脚本有传递--center_only的参数则将该值center_only取值为true
//由于脚本没有传递center_only，则其值为false
"--center_only",
action='store_true',
help="Switch for prediction from center crop alone instead of " +
"averaging predictions across crops (default)."
)
parser.add_argument(
"--images_dim",
default='256,256',
help="Canonical 'height,width' dimensions of input images."
)
parser.add_argument(
"--mean_value",
default=os.path.join(
'examples/market1501/market1501_mean.binaryproto'),
help="Data set image mean of [Channels x Height x Width] dimensions " +
"(numpy array). Set to '' for no mean subtraction."
)
parser.add_argument(
"--input_scale",
type=float,
help="Multiply input features by this scale to finish preprocessing."
)
parser.add_argument(
"--raw_scale",
type=float,
default=255.0,
help="Multiply raw input by this scale before preprocessing."
)
parser.add_argument(
"--channel_swap",
default='2,1,0',
help="Order to permute input channels. The default converts " +
"RGB -> BGR since BGR is the Caffe default by way of OpenCV."
)
parser.add_argument(
"--ext",
default='jpg',
help="Image file extension to take as input when a directory " +
"is given as the input file."
)
parser.add_argument(
"--feature_name",
default="fc7",
help="feature blob name."
)
parser.add_argument(
"--score_name",
default="prediction",
help="prediction score blob name."
)
args = parser.parse_args()

//image_dims = [256,256]
image_dims = [int(s) for s in args.images_dim.split(',')]

channel_swap=[2,1,0]
channel_swap = None
if args.channel_swap:
channel_swap = [int(s) for s in args.channel_swap.split(',')]

mean_value= [97.8,99.0,105.6]
mean_value = None
if args.mean_value:
mean_value = [float(s) for s in args.mean_value.split(',')]
mean_value = np.array(mean_value)

if args.gpu >= 0:
caffe.set_mode_gpu()
caffe.set_device(args.gpu)
print("GPU mode, device : {}".format(args.gpu))
else:
caffe.set_mode_cpu()
print("CPU mode")

//这句话的意思是根据训练好的模型，使用dev.proto前向一遍，得到分类的结果
//同时，前向网络也计算了fc7，这正是我们需要的特征
--model_def = ./models/market1501/caffenet/dev.proto
args.pretrained_model在命令行中存在
input_scale为空，无默认值
raw_scale=255
channel_swap=[2,1,0]

# Make classifier.
classifier = SClassifier(args.model_def, args.pretrained_model,
image_dims=image_dims, mean_value=mean_value,
input_scale=args.input_scale, raw_scale=args.raw_scale,
channel_swap=channel_swap)

# Load numpy, directory glob (*.jpg), or image file.
//将符号路径扩展成完整路径
args.input_file = os.path.expanduser(args.input_file)
//args.ext='jpg'
//args.input_file以lst结尾
if args.input_file.endswith(args.ext):
print("Loading file: %s" % args.input_file)
inputs = [caffe.io.load_image(args.input_file)]
labels = [-1]
//lst也不是文件夹
elif os.path.isdir(args.input_file):
print("Loading folder: %s" % args.input_file)
inputs =[caffe.io.load_image(im_f)
for im_f in glob.glob(args.input_file + '/*.' + args.ext)]
labels = [-1 for _ in xrange(len(inputs))]
else:
## Image List Files
print("Loading file: %s" % args.input_file)
//按列读取
img_files, labels = load_txt(args.input_file)
//对于lst中的每一个地址，就读取一次，放入到input中
inputs = [caffe.io.load_image(im_f)
for im_f in img_files]

print("Classifying %d inputs." % len(inputs))

# Classify.
ok = 0.0

save_feature = None
save_score   = None
//由于脚本没有传递center_only，则其值为false
for idx, _input in enumerate(inputs):
start = time.time()
//_input是每一张图，后面的参数说明是否要对图像进行crop
//本例中是对图像进行了crop,四个角+一个中心，水平翻转之后再来一次，总计10张。否则我们仅仅需要中心的那张就可以
//返回的是一张N*C的numpy.ndarry,代表每张图片有可能对应的C个类别
_ = classifier.predict([_input], not args.center_only)
//提取fc7层的特征
feature = classifier.get_blob_data(args.feature_name)
//获取使用softmax后的结果
score   = classifier.get_blob_data(args.score_name)
//都是一维的数据
assert (feature.shape[0] == 1 and score.shape[0] == 1)
feature_shape = feature.shape
score_shape = score.shape
//打印结果

if save_feature is None:
args.feature_name feature fc7 feature_shape（1，4096）
print('feature : {} : {}'.format(args.feature_name, feature_shape))
save_feature = np.zeros((len(inputs), feature.size),dtype=np.float32)
save_feature[idx, :] = feature.reshape(1, feature.size)
if save_score is None:
args.score_name score prediction (1,751)
print('score : {} : {}'.format(args.score_name, score_shape))
save_score = np.zeros((len(inputs), score.size),dtype=np.float32)
save_score[idx, :] = score.reshape(1, score.size)
//找到得分中最大的一项
mx_idx = np.argmax(score.view())
ok = ok + int(int(mx_idx) == int(labels[idx]))
print("{:5d} / {:5d} images predict done in {:.2f} s. [PRED: {:3d}] vs [OK: {:3d}] accuracy: {:.4f} = good: {:5d} bad: {:5d}".format( \
idx+1, len(inputs), time.time() - start, mx_idx, labels[idx], ok/(idx+1), int(ok), idx+1-int(ok)))

# Save
if (args.feature_file):
print("Saving feature into %s" % args.feature_file)
sio.savemat(args.feature_file, {'feature':save_feature})
else:
print("Without saving feature")

if (args.score_file):
print("Saving score into %s" % args.score_file)
sio.savemat(args.score_file, {'feature':save_score})
else:
print("Without saving score")

if __name__ == '__main__':
main(sys.argv)