tensorflow项目构建流程

⼀、构建路线

个⼈感觉对于任何⼀个深度学习库，如mxnet、tensorflow、theano、caffe等，基本上我都采⽤同样的⼀个学习流程，⼤体流程如下：(1)训练阶段：数据打包-》⽹络构建、训练-》模型保存-》可视化查看损失函数、验证精度(2)测试阶段：模型加载-》测试图⽚读取-》预测显⽰结果(3)移植阶段：量化、压缩加速-》微调-》C++移植打包-》上线

这边我就以tensorflow为例⼦，讲解整个流程的⼤体架构，完成⼀个深度学习项⽬所需要熟悉的过程代码。⼆、训练、测试阶段1、tensorflow打包数据

这⼀步对于tensorflow来说，也可以直接⾃⼰在线读取：.jpg图⽚、标签⽂件等，然后通过phaceholder变量，把数据送⼊⽹络中，进⾏计算。

不过这种效率⽐较低，对于⼤规模训练数据来说，我们需要⼀个⽐较⾼效的⽅式，tensorflow建议我们采⽤tfrecoder进⾏⾼效数据读取。学习tensorflow⼀定要学会tfrecoder⽂件写⼊、读取，具体⽰例代码如下：

1.

#coding=utf-82.

#tensorflow⾼效数据读取训练3.

import tensorflow as tf4.

import cv25. 6.

#把train.txt⽂件格式，每⼀⾏：图⽚路径名 类别标签7.

#奖数据打包，转换成tfrecords格式，以便后续⾼效读取8.

def encode_to_tfrecords(lable_file,data_root,new_name='data.tfrecords',resize=None):9.

writer=tf.python_io.TFRecordWriter(data_root+'/'+new_name)10.

num_example=011.

with open(lable_file,'r') as f:12.

for l in f.readlines():13.

l=l.split()14.

image=cv2.imread(data_root+\"/\"+l[0])15.

if resize is not None:16.

image=cv2.resize(image,resize)#为了17.

height,width,nchannel=image.shape18.

19.

label=int(l[1])20.

21.

example=tf.train.Example(features=tf.train.Features(feature={22.

'height':tf.train.Feature(int_list=tf.train.IntList(value=[height])),23.

'width':tf.train.Feature(int_list=tf.train.IntList(value=[width])),24.

'nchannel':tf.train.Feature(int_list=tf.train.IntList(value=[nchannel])),25.

'image':tf.train.Feature(bytes_list=tf.train.BytesList(value=[image.tobytes()])),26.

'label':tf.train.Feature(int_list=tf.train.IntList(value=[label]))27.

}))28.

serialized=example.SerializeToString()29.

writer.write(serialized)30.

num_example+=131.

print lable_file,\"样本数据量：\32.

writer.close()33.

#读取tfrecords⽂件34.

def decode_from_tfrecords(filename,num_epoch=None):35.

filename_queue=tf.train.string_input_producer([filename],num_epochs=num_epoch)#因为有的训练数据过于庞⼤，被分成了很多个⽂件，所以第⼀个参数就是⽂件列表名参数36.

reader=tf.TFRecordReader()37.

_,serialized=reader.read(filename_queue)38.

example=tf.parse_single_example(serialized,features={39.

'height':tf.FixedLenFeature([],tf.int),40.

'width':tf.FixedLenFeature([],tf.int),41.

'nchannel':tf.FixedLenFeature([],tf.int),42.

'image':tf.FixedLenFeature([],tf.string),43.

'label':tf.FixedLenFeature([],tf.int)44.

})45.

label=tf.cast(example['label'], tf.int32)46.

image=tf.decode_raw(example['image'],tf.uint8)47.

image=tf.reshape(image,tf.pack([48.

tf.cast(example['height'], tf.int32),49.

tf.cast(example['width'], tf.int32),50.

tf.cast(example['nchannel'], tf.int32)]))51.

#label=example['label']52.

return image,label53.

#根据队列流数据格式，解压出⼀张图⽚后，输⼊⼀张图⽚，对其做预处理、及样本随机扩充54.

def get_batch(image, label, batch_size,crop_size):55.

#数据扩充变换

56.

distorted_image = tf.random_crop(image, [crop_size, crop_size, 3])#随机裁剪57.

distorted_image = tf.image.random_flip_up_down(distorted_image)#上下随机翻转58.

#distorted_image = tf.image.random_brightness(distorted_image,max_delta=63)#亮度变化59.

#distorted_image = tf.image.random_contrast(distorted_image,lower=0.2, upper=1.8)#对⽐度变化60.

61.

#⽣成batch62.

#shuffle_batch的参数：capacity⽤于定义shuttle的范围，如果是对整个训练数据集，获取batch，那么capacity就应该够⼤63.

#保证数据打的⾜够乱.

images, label_batch = tf.train.shuffle_batch([distorted_image, label],batch_size=batch_size,65.

num_threads=16,capacity=50000,min_after_dequeue=10000)66.

#images, label_batch=tf.train.batch([distorted_image, label],batch_size=batch_size)67.

68.

69.

70.

# 调试显⽰71.

#tf.image_summary('images', images)72.

return images, tf.reshape(label_batch, [batch_size])73.

#这个是⽤于测试阶段，使⽤的get_batch函数74.

def get_test_batch(image, label, batch_size,crop_size):75.

#数据扩充变换76.

distorted_image=tf.image.central_crop(image,39./45.)77.

distorted_image = tf.random_crop(distorted_image, [crop_size, crop_size, 3])#随机裁剪78.

images, label_batch=tf.train.batch([distorted_image, label],batch_size=batch_size)79.

return images, tf.reshape(label_batch, [batch_size])80.

#测试上⾯的压缩、解压代码81.

def test():82.

encode_to_tfrecords(\"data/train.txt\83.

image,label=decode_from_tfrecords('data/data.tfrecords')84.

batch_image,batch_label=get_batch(image,label,3)#batch ⽣成测试85.

init=tf.initialize_all_variables()86.

with tf.Session() as session:87.

session.run(init)88.

coord = tf.train.Coordinator().

threads = tf.train.start_queue_runners(coord=coord)

90.

for l in range(100000):#每run⼀次，就会指向下⼀个样本，⼀直循环91.

#image_np,label_np=session.run([image,label])#每调⽤run⼀次，那么92.

'''cv2.imshow(\"temp\93.

cv2.waitKey()'''94.

#print label_np95.

#print image_np.shape96.

97.

98.

batch_image_np,batch_label_np=session.run([batch_image,batch_label])99.

print batch_image_np.shape100.

print batch_label_np.shape101.

102.

103.

104.

coord.request_stop()#queue需要关闭，否则报错105.

coord.join(threads)106.

#test()

2、⽹络架构与训练

经过上⾯的数据格式处理，接着我们只要写⼀写⽹络结构、⽹络优化⽅法，把数据搞进⽹络中就可以了，具体⽰例代码如下：

1.

#coding=utf-82.

import tensorflow as tf3.

from data_encoder_decoeder import encode_to_tfrecords,decode_from_tfrecords,get_batch,get_test_batch4.

import cv25.

import os6. 7.

class network(object):8.

def __init__(self):9.

with tf.variable_scope(\"weights\"):10.

self.weights={11.

#39*39*3->36*36*20->18*18*2012.

'conv1':tf.get_variable('conv1',[4,4,3,20],initializer=tf.contrib.layers.xavier_initializer_conv2d()),13.

#18*18*20->16*16*40->8*8*40

14.

'conv2':tf.get_variable('conv2',[3,3,20,40],initializer=tf.contrib.layers.xavier_initializer_conv2d()),15.

#8*8*40->6*6*60->3*3*6016.

'conv3':tf.get_variable('conv3',[3,3,40,60],initializer=tf.contrib.layers.xavier_initializer_conv2d()),17.

#3*3*60->12018.

'fc1':tf.get_variable('fc1',[3*3*60,120],initializer=tf.contrib.layers.xavier_initializer()),19.

#120->620.

'fc2':tf.get_variable('fc2',[120,6],initializer=tf.contrib.layers.xavier_initializer()),21.

}22.

with tf.variable_scope(\"biases\"):23.

self.biases={24.

'conv1':tf.get_variable('conv1',[20,],initializer=tf.constant_initializer(value=0.0, dtype=tf.float32)),25.

'conv2':tf.get_variable('conv2',[40,],initializer=tf.constant_initializer(value=0.0, dtype=tf.float32)),26.

'conv3':tf.get_variable('conv3',[60,],initializer=tf.constant_initializer(value=0.0, dtype=tf.float32)),27.

'fc1':tf.get_variable('fc1',[120,],initializer=tf.constant_initializer(value=0.0, dtype=tf.float32)),28.

'fc2':tf.get_variable('fc2',[6,],initializer=tf.constant_initializer(value=0.0, dtype=tf.float32))29.

30.

}31.

32.

def inference(self,images):33.

# 向量转为矩阵34.

images = tf.reshape(images, shape=[-1, 39,39, 3])# [batch, in_height, in_width, in_channels]35.

images=(tf.cast(images,tf.float32)/255.-0.5)*2#归⼀化处理36.

37.

38.

39.

#第⼀层40.

conv1=tf.nn.bias_add(tf.nn.conv2d(images, self.weights['conv1'], strides=[1, 1, 1, 1], padding='VALID'),41.

self.biases['conv1'])42.

43.

relu1= tf.nn.relu(conv1)44.

pool1=tf.nn.max_pool(relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')45.

46.

47.

#第⼆层

48.

conv2=tf.nn.bias_add(tf.nn.conv2d(pool1, self.weights['conv2'], strides=[1, 1, 1, 1], padding='VALID'),49.

self.biases['conv2'])50.

relu2= tf.nn.relu(conv2)51.

pool2=tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')52.

53.

54.

# 第三层55.

conv3=tf.nn.bias_add(tf.nn.conv2d(pool2, self.weights['conv3'], strides=[1, 1, 1, 1], padding='VALID'),56.

self.biases['conv3'])57.

relu3= tf.nn.relu(conv3)58.

pool3=tf.nn.max_pool(relu3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')59.

60.

61.

# 全连接层1，先把特征图转为向量62.

flatten = tf.reshape(pool3, [-1, self.weights['fc1'].get_shape().as_list()[0]])63.

.

drop1=tf.nn.dropout(flatten,0.5)65.

fc1=tf.matmul(drop1, self.weights['fc1'])+self.biases['fc1']66.

67.

fc_relu1=tf.nn.relu(fc1)68.

69.

fc2=tf.matmul(fc_relu1, self.weights['fc2'])+self.biases['fc2']70.

71.

return fc272.

def inference_test(self,images):73.

# 向量转为矩阵74.

images = tf.reshape(images, shape=[-1, 39,39, 3])# [batch, in_height, in_width, in_channels]75.

images=(tf.cast(images,tf.float32)/255.-0.5)*2#归⼀化处理76.

77.

78.

79.

#第⼀层80.

conv1=tf.nn.bias_add(tf.nn.conv2d(images, self.weights['conv1'], strides=[1, 1, 1, 1], padding='VALID'),81.

self.biases['conv1'])

82.

83.

relu1= tf.nn.relu(conv1)84.

pool1=tf.nn.max_pool(relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')85.

86.

87.

#第⼆层88.

conv2=tf.nn.bias_add(tf.nn.conv2d(pool1, self.weights['conv2'], strides=[1, 1, 1, 1], padding='VALID'),.

self.biases['conv2'])90.

relu2= tf.nn.relu(conv2)91.

pool2=tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')92.

93.

94.

# 第三层95.

conv3=tf.nn.bias_add(tf.nn.conv2d(pool2, self.weights['conv3'], strides=[1, 1, 1, 1], padding='VALID'),96.

self.biases['conv3'])97.

relu3= tf.nn.relu(conv3)98.

pool3=tf.nn.max_pool(relu3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')99.

100.

101.

# 全连接层1，先把特征图转为向量102.

flatten = tf.reshape(pool3, [-1, self.weights['fc1'].get_shape().as_list()[0]])103.

104.

fc1=tf.matmul(flatten, self.weights['fc1'])+self.biases['fc1']105.

fc_relu1=tf.nn.relu(fc1)106.

107.

fc2=tf.matmul(fc_relu1, self.weights['fc2'])+self.biases['fc2']108.

109.

return fc2110.

111.

#计算softmax交叉熵损失函数112.

def sorfmax_loss(self,predicts,labels):113.

predicts=tf.nn.softmax(predicts)114.

labels=tf.one_hot(labels,self.weights['fc2'].get_shape().as_list()[1])115.

loss =-tf.reduce_mean(labels * tf.log(predicts))# tf.nn.softmax_cross_entropy_with_logits(predicts, labels)

116.

self.cost= loss117.

return self.cost118.

#梯度下降119.

def optimer(self,loss,lr=0.001):120.

train_optimizer = tf.train.GradientDescentOptimizer(lr).minimize(loss)121.

122.

return train_optimizer123.

124.

125.

def train():126.

encode_to_tfrecords(\"data/train.txt\127.

image,label=decode_from_tfrecords('data/train.tfrecords')128.

batch_image,batch_label=get_batch(image,label,batch_size=50,crop_size=39)#batch ⽣成测试129.

130.

131.

132.

133.

134.

135.

136.

#⽹络链接,训练所⽤137.

net=network()138.

inf=net.inference(batch_image)139.

loss=net.sorfmax_loss(inf,batch_label)140.

opti=net.optimer(loss)141.

142.

143.

#验证集所⽤144.

encode_to_tfrecords(\"data/val.txt\145.

test_image,test_label=decode_from_tfrecords('data/val.tfrecords',num_epoch=None)146.

test_images,test_labels=get_test_batch(test_image,test_label,batch_size=120,crop_size=39)#batch ⽣成测试147.

test_inf=net.inference_test(test_images)148.

correct_prediction = tf.equal(tf.cast(tf.argmax(test_inf,1),tf.int32), test_labels)149.

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

150.

151.

152.

153.

154.

155.

init=tf.initialize_all_variables()156.

with tf.Session() as session:157.

session.run(init)158.

coord = tf.train.Coordinator()159.

threads = tf.train.start_queue_runners(coord=coord)160.

max_iter=100000161.

iter=0162.

if os.path.exists(os.path.join(\"model\163.

tf.train.Saver(max_to_keep=None).restore(session, os.path.join(\"model\1.

while iterloss_np,_,label_np,image_np,inf_np=session.run([loss,opti,batch_label,batch_image,inf])166.

#print image_np.shape167.

#cv2.imshow(str(label_np[0]),image_np[0])168.

#print label_np[0]169.

#cv2.waitKey()170.

#print label_np171.

if iter%50==0:172.

print 'trainloss:',loss_np173.

if iter%500==0:174.

accuracy_np=session.run([accuracy])175.

print '***************test accruacy:',accuracy_np,'*******************'176.

tf.train.Saver(max_to_keep=None).save(session, os.path.join('model','model.ckpt'))177.

iter+=1178.

179.

180.

181.

182.

183.

coord.request_stop()#queue需要关闭，否则报错

184.

coord.join(threads)185.

186.

train()

3、可视化显⽰

(1)⾸先再源码中加⼊需要跟踪的变量：

tf.scalar_summary(\"cost_function\损失函数值

(2)然后定义执⾏操作：

merged_summary_op = tf.merge_all_summaries()

(3)再session中定义保存路径：

summary_writer = tf.train.SummaryWriter('log', session.graph)

(4)然后再session执⾏的时候，保存：

1.

summary_str,loss_np,_=session.run([merged_summary_op,loss,opti])2.

summary_writer.add_summary(summary_str, iter)(5)最后只要训练完毕后，直接再终端输⼊命令：

python /usr/local/lib/python2.7/dist-packages/tensorflow/tensorboard/tensorboard.py --logdir=log

然后打开浏览器⽹址：

http://0.0.0.0:6006

即可观训练曲线。4、测试阶段

测试阶段主要是直接通过加载图模型、读取参数等，然后直接通过tensorflow的相关函数，进⾏调⽤，⽽不需要⽹络架构相关的代码；通过内存feed_dict的⽅式，对相关的输⼊节点赋予相关的数据，进⾏前向传导，并获取相关的节点数值。

1.

#coding=utf-82.

import tensorflow as tf3.

import os4.

import cv25. 6.

def load_model(session,netmodel_path,param_path):7.

new_saver = tf.train.import_meta_graph(netmodel_path)8.

new_saver.restore(session, param_path)9.

x= tf.get_collection('test_images')[0]#在训练阶段需要调⽤tf.add_to_collection('test_images',test_images),保存之10.

y = tf.get_collection(\"test_inf\")[0]11.

batch_size = tf.get_collection(\"batch_size\")[0]12.

return x,y,batch_size13.

14.

def load_images(data_root):15.

filename_queue = tf.train.string_input_producer(data_root)16.

image_reader = tf.WholeFileReader()17.

key,image_file = image_reader.read(filename_queue)18.

image = tf.image.decode_jpeg(image_file)19.

return image, key20.

21.

def test(data_root=\"data/race/cropbrown\"):22.

image_filenames=os.listdir(data_root)23.

image_filenames=[(data_root+'/'+i) for i in image_filenames]24.

25.

26.

#print cv2.imread(image_filenames[0]).shape27.

#image,key=load_images(image_filenames)28.

race_listsrc=['black','brown','white','yellow']29.

with tf.Session() as session:30.

coord = tf.train.Coordinator()31.

threads = tf.train.start_queue_runners(coord=coord)32.

33.

34.

35.

x,y,batch_size=load_model(session,os.path.join(\"model\36.

os.path.join(\"model\37.

predict_label=tf.cast(tf.argmax(y,1),tf.int32)38.

print x.get_shape()39.

for imgf in image_filenames:40.

image=cv2.imread(imgf)41.

image=cv2.resize(image,(76,76)).reshape((1,76,76,3))42.

print \"cv shape:\43.

44.

45.

#cv2.imshow(\"t\46.

y_np=session.run(predict_label,feed_dict = {x:image, batch_size:1})47.

print race_listsrc[y_np]48.

49.

50.

coord.request_stop()#queue需要关闭，否则报错51.

coord.join(threads)

4、移植阶段

(1)⼀个算法经过实验阶段后，接着就要进⼊移植商⽤，因此接着需要采⽤tensorflow的c api函数，直接进⾏预测推理，⾸先我们先把tensorflow编译成链接库，然后编写cmake，调⽤tensorflow链接库：

1.

bazel build -c opt //tensorflow:libtensorflow.so2. 在bazel-bin/tensorflow⽬录下会⽣成libtensorflow.so⽂件5、C++ API调⽤、cmake 编写：

三、熟悉常⽤API1、LSTM使⽤

1.

import tensorflow.nn.rnn_cell2. 3.

lstm = rnn_cell.BasicLSTMCell(lstm_size)#创建⼀个lstm cell单元类，隐藏层神经元个数为lstm_size4. 5.

state = tf.zeros([batch_size, lstm.state_size])#⼀个序列隐藏层的状态值6. 7.

loss = 0.08.

for current_batch_of_words in words_in_dataset:9.

output, state = lstm(current_batch_of_words, state)#返回值为隐藏层神经元的输出10.

logits = tf.matmul(output, softmax_w) + softmax_b#matmul矩阵点乘11.

probabilities = tf.nn.softmax(logits)#softmax输出12.

loss += loss_function(probabilities, target_words)

1、one-hot函数：

1.

#ont hot 可以把训练数据的标签，直接转换成one_hot向量，⽤于交叉熵损失函数2.

import tensorflow as tf3.

a=tf.convert_to_tensor([[1],[2],[4]])4.

b=tf.one_hot(a,5)>>b的值为

1.

[[[ 0. 1. 0. 0. 0.]]2. 3.

[[ 0. 0. 1. 0. 0.]]4. 5.

[[ 0. 0. 0. 0. 1.]]]

2、assign_sub

1.

import tensorflow as tf2. 3.

x = tf.Variable(10, name=\"x\")4.

sub=x.assign_sub(3)#如果直接采⽤x.assign_sub，那么可以看到x的值也会发⽣变化5.

init_op=tf.initialize_all_variables()6.

with tf.Session() as sess:7.

sess.run(init_op)8.

print sub.eval()9.

print x.eval()可以看到输⼊sub=x=7

state_ops.assign_sub

采⽤state_ops的assign_sub也是同样sub=x=7

也就是说assign函数返回结果值的同时，变量本⾝的值也会被改变3、变量查看

1.

#查看所有的变量2.

for l in tf.all_variables():3.

print l.name4、slice函数：

1.

import cv22.

import tensorflow as tf3.

#slice 函数可以⽤于切割⼦矩形图⽚，参数矩形框的rect,begin=(minx,miny),size=(width,height)4.

minx=205.

miny=306.

height=1007.

width=2008. 9.

image=tf.placeholder(dtype=tf.uint8,shape=(386,386,3))10.

rect_image=tf.slice(image,(miny,minx,0),(height,width,-1))11.

12.

13.

cvimage=cv2.imread(\"1.jpg\")14.

cv2.imshow(\"cv2\15.

16.

17.

with tf.Session() as sess:18.

tfimage=sess.run([rect_image],{image:cvimage})19.

cv2.imshow('tf',tfimage[0])20.

cv2.waitKey()

5、正太分布随机初始化

tf.truncated_normal

6、打印操作运算在硬件设备信息

tf.ConfigProto(log_device_placement=True)

7、变量域名的reuse：

1.

import tensorflow as tf2.

with tf.variable_scope('foo'):#在没有启⽤reuse的情况下,如果该变量还未被创建,那么就创建该变量,如果已经创建过了,那么就获取该共享变量3.

v=tf.get_variable('v',[1])4.

with tf.variable_scope('foo',reuse=True):#如果启⽤了reuse,那么编译的时候,如果get_variable没有遇到⼀个已经创建的变量,是会出错的5.

v1=tf.get_variable('v1',[1])

8、allow_soft_placement的使⽤：allow_soft_placement=True，允许当在代码中指定tf.device设备，如果设备找不到，那么就采⽤默认的设备。如果该参数设置为false，当设备找不到的时候，会直接编译不通过。9、batch normalize调⽤：

tf.contrib.layers.batch_norm(x, decay=0.9, updates_collections=None, epsilon=self.epsilon, scale=True, scope=self.name)