【笔记】tf 模型继续训练 fineturn ：fineturn是已用于其它目标，预训练好模型的权重或者部分权重，作为初始值开始训练；可以加快收敛，提升速度

注：

fineturn 的解释：

        已用于其它目标，预训练好模型的权重或者部分权重，作为初始值开始训练。

优点：加快收敛，提升速度。

具体做法：

1.复用相同层的权重，新定义层取随机权重初始值。

2.调大新定义层的学习率，调小复用层学习率。

正文：

        解决tf 如何在已训练模型上继续训练fineturn的问题。

Code:

        任务描述：x=3.0 ， y=100.0 ,运算公式 x x W + b= y，求W和b的最优解。

# -*- coding: utf-8 -*-)
import tensorflow as tf
 
 
# 声明占位变量x、y
x = tf.placeholder("float", shape=[None, 1])
y = tf.placeholder("float", [None, 1])
 
# 声明变量
W = tf.Variable(tf.zeros([1, 1]),name='w')
b = tf.Variable(tf.zeros([1]),name='b')
 
# 操作
result = tf.matmul(x, W) + b
 
# 损失函数
lost = tf.reduce_sum(tf.pow((result - y), 2))
 
# 优化
train_step = tf.train.GradientDescentOptimizer(0.0007).minimize(lost)
 
with tf.Session() as sess:
    # 初始化变量
    sess.run(tf.global_variables_initializer())
    saver = tf.train.Saver(max_to_keep=3)
 
    # 这里x、y给固定的值
    x_s = [[3.0]]
    y_s = [[100.0]]
 
    step = 0
    while (True):
        step += 1
        feed = {x: x_s, y: y_s}
        # 通过sess.run执行优化
        sess.run(train_step, feed_dict=feed)
 
        if step % 1000 == 0:
            print 'step: {0},  loss: {1}'.format(step, sess.run(lost, feed_dict=feed))
            if sess.run(lost, feed_dict=feed) < 1e-10 or step > 4e3:
                print ''
                # print 'final loss is: {}'.format(sess.run(lost, feed_dict=feed))
                print 'final result of {0} =  {1}（目标值是100.0）'.format('x×W+b', 3.0 * sess.run(W) + sess.run(b))
                print ''
                print("模型保存的W值 : %f" % sess.run(W))
                print("模型保存的b : %f" % sess.run(b))
                break
    saver.save(sess, "./save_model/re-train", global_step=step)  # 保存模型

 

训练输出：

step: 1000,  loss: 4.89526428282e-08
step: 2000,  loss: 4.89526428282e-08
step: 3000,  loss: 4.89526428282e-08
step: 4000,  loss: 4.89526428282e-08
step: 5000,  loss: 4.89526428282e-08
 
 
final result of x×W+b =  [[99.99978]]（目标值是100.0）
 
模型保存的W值 : 29.999931
模型保存的b : 9.999982

# -*- coding: utf-8 -*-)
import tensorflow as tf
 
 
# 声明占位变量x、y
x = tf.placeholder("float", shape=[None, 1])
y = tf.placeholder("float", [None, 1])
 
with tf.Session() as sess:
 
    # 初始化变量
    sess.run(tf.global_variables_initializer())
 
    # saver = tf.train.Saver(max_to_keep=3)
    saver = tf.train.import_meta_graph(r'./save_model/re-train-5000.meta') # 加载模型图结构
    saver.restore(sess, tf.train.latest_checkpoint(r'./save_model'))  # 恢复数据
 
    # 从保存模型中恢复变量
    graph = tf.get_default_graph()
    W = graph.get_tensor_by_name("w:0")
    b = graph.get_tensor_by_name("b:0")
 
    print("从保存的模型中恢复出来的W值 : %f" % sess.run("w:0"))
    print("从保存的模型中恢复出来的b值 : %f" % sess.run("b:0"))
 
    # 操作
    result = tf.matmul(x, W) + b
    # 损失函数
    lost = tf.reduce_sum(tf.pow((result - y), 2))
    # 优化
    train_step = tf.train.GradientDescentOptimizer(0.0007).minimize(lost)
 
    # 这里x、y给固定的值
    x_s = [[3.0]]
    y_s = [[200.0]]
 
    step = 0
    while (True):
        step += 1
        feed = {x: x_s, y: y_s}
        # 通过sess.run执行优化
        sess.run(train_step, feed_dict=feed)
        if step % 1000 == 0:
            print 'step: {0},  loss: {1}'.format(step, sess.run(lost, feed_dict=feed))
            if sess.run(lost, feed_dict=feed) < 1e-10 or step > 4e3:
                print ''
                # print 'final loss is: {}'.format(sess.run(lost, feed_dict=feed))
                print 'final result of {0} =  {1}（目标值是200.0）'.format('x×W+b', 3.0 * sess.run(W) + sess.run(b))
                print("模型保存的W值 : %f" % sess.run(W))
                print("模型保存的b : %f" % sess.run(b))
                break
    saver.save(sess, "./save_mode/re-train", global_step=step)  # 保存模型

训练输出：

从保存的模型中恢复出来的W值 : 29.999931
从保存的模型中恢复出来的b值 : 9.999982
step: 1000,  loss: 1.95810571313e-07
step: 2000,  loss: 1.95810571313e-07
step: 3000,  loss: 1.95810571313e-07
step: 4000,  loss: 1.95810571313e-07
step: 5000,  loss: 1.95810571313e-07
 
 
final result of x×W+b =  [[199.99956]]（目标值是200.0）
模型保存的W值 : 59.999866
模型保存的b : 19.999958

总结

Saver类构造函数定义：

def __init__(self,
               var_list=None,
               reshape=False,
               sharded=False,
               max_to_keep=5,
               keep_checkpoint_every_n_hours=10000.0,
               name=None,
               restore_sequentially=False,
               saver_def=None,
               builder=None,
               defer_build=False,
               allow_empty=False,
               write_version=saver_pb2.SaverDef.V2,
               pad_step_number=False,
               save_relative_paths=False,
               filename=None):

saver.save函数定义：

def save(self,
           sess,
           save_path,
           global_step=None,
           latest_filename=None,
           meta_graph_suffix="meta",
           write_meta_graph=True,
           write_state=True,
           strip_default_attrs=False):

        

        从头开始训练一个模型，需要通过 tf.train.Saver创建一个保存器，完成之后使用save方法保存模型到本地：

saver = tf.train.Saver(max_to_keep=3)
...
saver.save(sess,"./saver_model/re-train",global_step=step) #保存模型

        在训练好的模型上继续训练，fineturn一个模型，可以使用tf.train.import_meta_graph方法加载图结构，使用restore方法恢复训练数据，最后使用同样的save方法保存到本地：

saver=tf.train.import_meta_graph(r"./save_model/re-train-10050.meta") # 加载模型图结构
saver.restore(sess,tf.train.latest_checkpoint(r"./save_model")) # 恢复数据
saver.save(sess,"./save_mode/re-train",global_step=step) # 保存模型

注：特殊情况下（如本例）需要从恢复的模型中加载出数据：

# 从保存模型中恢复变量
graph=tf.get_default_graph()
W=graph.get_tensor_by_name("w:0")
b=graph.get_tensor_by_name("b:0")