模型的保存于读取

保存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import tensorflow as tf

# 声明两个变量
v1 = tf.Variable(tf.random_normal([1, 2]), name="v1")
v2 = tf.Variable(tf.random_normal([2, 3]), name="v2")
init_op = tf.global_variables_initializer() # 初始化全部变量

saver = tf.train.Saver() # 声明tf.train.Saver类用于保存模型

with tf.Session() as sess:
    sess.run(init_op)
    print("v1:", sess.run(v1)) # 打印v1、v2的值一会读取之后对比
    print("v2:", sess.run(v2))
    
    saver_path = saver.save(sess, "save/model.ckpt")  # 将模型保存到save/model.ckpt文件
    print("Model saved in file:", saver_path)
1
2
3
4
v1: [[-0.33648431 -0.46078524]]
v2: [[-0.73017526 -0.42726403  1.74622989]
 [-1.50939059 -0.87901741  0.94227242]]
Model saved in file: save/model.ckpt

这段代码中，通过saver.save函数将TensorFlow模型保存到了save/model.ckpt文件中，这里代码中指定路径为”save/model.ckpt”，也就是保存到了当前程序所在文件夹里面的save文件夹中。

TensorFlow模型会保存在后缀为.ckpt的文件中。保存后在save这个文件夹中实际会出现3个文件，因为TensorFlow会将计算图的结构和图上参数取值分开保存。

  • model.ckpt.meta文件保存了TensorFlow计算图的结构，可以理解为神经网络的网络结构
  • model.ckpt文件保存了TensorFlow程序中每一个变量的取值
  • checkpoint文件保存了一个目录下所有的模型文件列表

读取

方法1

1
2
3
4
5
6
7
8
9
10
11
import tensorflow as tf

# 使用和保存模型代码中一样的方式来声明变量
v1 = tf.Variable(tf.random_normal([1, 2]), name="v1")
v2 = tf.Variable(tf.random_normal([2, 3]), name="v2")
saver = tf.train.Saver() # 声明tf.train.Saver类用于保存模型
with tf.Session() as sess:
    saver.restore(sess, "save/model.ckpt") # 即将固化到硬盘中的Session从保存路径再读取出来
    print("v1:", sess.run(v1)) # 打印v1、v2的值和之前的进行对比
    print("v2:", sess.run(v2))
    print("Model Restored")
1
2
3
4
v1: [[ 0.22189325  0.81017244]]
v2: [[-0.99802715 -0.54230249  1.92878962]
 [ 1.04581845  0.25543991 -0.6358065 ]]
Model Restored

这段加载模型的代码基本上和保存模型的代码是一样的。也是先定义了TensorFlow计算图上所有的运算，并声明了一个tf.train.Saver类。两段唯一的不同是，在加载模型的代码中没有运行变量的初始化过程，而是将变量的值通过已经保存的模型加载进来。

方法2

如果不希望重复定义图上的运算，也可以直接加载已经持久化的图：

1
2
3
4
5
6
7
8
import tensorflow as tf
# 在下面的代码中，默认加载了TensorFlow计算图上定义的全部变量
# 直接加载持久化的图
saver = tf.train.import_meta_graph("save/model.ckpt.meta")
with tf.Session() as sess:
    saver.restore(sess, "save/model.ckpt")
    # 通过张量的名称来获取张量
    print(sess.run(tf.get_default_graph().get_tensor_by_name("v1:0")))
1
[[ 0.22189325  0.81017244]]

恢复操作和其它元数据

我想分享的最后一个信息是，Saver将保存与图有关联的任何元数据。这就意味着，当我们恢复一个模型的时候，我们还同时恢复了所有与图相关的变量、操作和集合。

当我们恢复一个元模型（restore a meta checkpoint）时，实际上我们执行的操作是将恢复的图载入到当前的默认图中。所有当你完成模型恢复之后，你可以在默认图中访问载入的任何内容，比如一个张量，一个操作或者集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
import tensorflow as tf 

# Let's laod a previous meta graph in the current graph in use: usually the default graph 
# This actions returns a Saver 
saver = tf.train.import_meta_graph('results/model.ckpt-1000.meta') 

# We can now access the default graph where all our metadata has been loaded 
graph = tf.get_default_graph() 

# Finally we can retrieve tensors, operations, etc. 
global_step_tensor = graph.get_tensor_by_name('loss/global_step:0')
train_op = graph.get_operation_by_name('loss/train_op') 
hyperparameters = tf.get_collection('hyperparameters')

在新图中导入预训练模型

至此，你应该已经明白了如何去保存和恢复一个模型。然而，我们还可以使用一些技巧去帮助你更快的保存和恢复一个模型。比如：

  • 一个图的输出能成为另一个图的输入吗？

答案是确定的。但是目前我的做法是先将第一个图进行保存，然后在另一个图中进行恢复。但是这种方案感觉很笨重，我不知道是否有更好的方法。

但是这种方法确实能工作，除非你想要去重新训练第一个图。在这种情况下，你需要将输入的梯度重新输入到第一张图中的特定的训练步骤中。我想你已经被这种复杂的方案给逼疯了把。:-)

  • 我可以在一个图中混合不同的图吗？

答案当然是肯定的，但是你必须非常小心命名空间。这种方法有一点好处是，简化了一切。比如，你可以预加载一个VGG-19模型。然后访问图中的任何节点，并执行你自己的后续操作，从而训练一整个完整的模型。

如果你只想微调你自己的节点，那么你可以在你想要的地方中断梯度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import tensorflow as tf

# Load the VGG-16 model in the default graph
vgg_saver = tf.train.import_meta_graph(dir + '/vgg/results/vgg-16.meta')
# Access the graph
vgg_graph = tf.get_default_graph()

# Retrieve VGG inputs
self.x_plh = vgg_graph.get_tensor_by_name('input:0')

# Choose which node you want to connect your own graph
output_conv =vgg_graph.get_tensor_by_name('conv1_2:0')
# output_conv =vgg_graph.get_tensor_by_name('conv2_2:0')
# output_conv =vgg_graph.get_tensor_by_name('conv3_3:0')
# output_conv =vgg_graph.get_tensor_by_name('conv4_3:0')
# output_conv =vgg_graph.get_tensor_by_name('conv5_3:0')

# Stop the gradient for fine-tuning
output_conv_sg = tf.stop_gradient(output_conv) # It's an identity function

# Build further operations
output_conv_shape = output_conv_sg.get_shape().as_list()
W1 = tf.get_variable('W1', shape=[1, 1, output_conv_shape[3], 32], initializer=tf.random_normal_initializer(stddev=1e-1))
b1 = tf.get_variable('b1', shape=[32], initializer=tf.constant_initializer(0.1))
z1 = tf.nn.conv2d(output_conv_sg, W1, strides=[1, 1, 1, 1], padding='SAME') + b1
a = tf.nn.relu(z1)

数据增强

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 随机裁剪图片
# Randomly crop a [height, width] section of the image.
distorted_image = tf.random_crop(reshaped_image, [height, width, 3])

# 随机翻转图片，每张图片有50%的概率被水平左右翻转，另有50%的概率保持不变
# Randomly flip the image horizontally.
distorted_image = tf.image.random_flip_left_right(distorted_image)

# 随机改变亮度和对比度
# Because these operations are not commutative, consider randomizing
# the order their operation.
distorted_image = tf.image.random_brightness(distorted_image,
                                             max_delta=63)
distorted_image = tf.image.random_contrast(distorted_image,
                                           lower=0.2, upper=1.8)

原始的训练图片是 reshaped_image，最后会得到一个数据增强后的训练样本 distorted_image。 训练时，直接使用 distorted_image 进行训练即可

1
2
3
转载与参考：
http://www.cnblogs.com/seaspring/  
https://www.jianshu.com/p/8487db911d9a