TensorFlow编程基础

TensorFlow编程基础

1.编程模型

Tensorflow：
Tensor（张量）flow（流）
张量从图像的一段流动到另一端的计算过程

了解模型的运行机制

定义和运行相分离

在操作层面可以抽象成两种：模型构建和模型运行

模型构建中的概念：

名称	含义
张量（tensor）	数据，即某一类型的多维数组
变量（Variable）	常用于定义模型中的参数
占位符（placeholder）	输入变量的载体。也可以理解成定义函数时的参数
图中的节点操作（operation，OP）	即一个OP获得0个或者多个tensor，执行计算，输出额外的0个或多个tensor

• 一个图表示一个计算任务
• 在模型运行的环节中，图会在会话session中被启动
• session将图的OP分发到如CPU或GPU之类的设备上，同时提供执行OP的方法。这些方法执行后，将产生的tensor返回

在实际环境中，这种运行情况会有 种应用场景，分别是训练场景、测试场景与使用场景。在训练场景下图的运行方式与其他两种不同，具体介绍如下。

• 训练场景 是实现模型从无到有的过程，通过对样本的学习训练，调整学习参数 ，形成最终的模型。其过程是将给定的样本和标签作为输入节点，通过大量的循环法代，将图中的正向运算（从输入的样本通过 OP 运算得到输出的方向〉得到的输出值，再进行反向运算（从输出到输入的方向〉，以更新模型中的学习参数，最终使模型产生的正向结果最大化地接近样本标签。这样就得到了一个可以拟合样本规律的模型。
• 测试场景和使用场景：测试场景是利用图的正向运算得到的结果与真实值进行比较的差别；使用场景也是利用图的正向运算得到结果，并直接使用。所 二者的运算过程是一样的。对于该场景下的模型与正常编程用到的函数特别相似。在函数中 ，可以分为实参、形参、函数体与返回值。同样在模型中，实参就是输入的样本，形参就是占位符，运算过程就相当于函数体，得到的结果相当于返回值。

另外， session 与图的交互过程中还定义了以下两种数据的流向机制。

• 注入机制（ feed） 通过占位符向模式中传入数据。
• 取回机制（ fetch ）：从模式中得到结果

例：编写Hello World 开始理解session的作用

import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')  		# 定义一个常量
sess = tf.Session()                             # 建立一个session
print (sess.run(hello))                        	# 通过session里面的run来运行结果
sess.close()                                    # 关闭session

得到如下输出：

b'Hello, TensorFlow!'

例：演示with session的使用

使用 with session 方法建立 session ，并 session 中计算两个变量 。3 和 4的相加与相乘值

import tensorflow as tf
a = tf.constant(3)                     	# 定义常量3
b = tf.constant(4)                     	# 定义常量4
with tf.Session() as sess:           	# 建立session
    print ("相加: %i" % sess.run(a+b))
    print( "相乘: %i" % sess.run(a*b))

得到以下输出：

相加: 7
相乘: 12

例：演示注入机制 并使用注入机制获取节点

定义占位符，使用 feed 机制将具体数值。3 和 4 通过占位符传入，并进行相加和相乘运算。

import tensorflow as tf
a = tf.placeholder(tf.int16)
b = tf.placeholder(tf.int16)
add = tf.add(a, b)
mul = tf.multiply(a, b)                      #a与b相乘
with tf.Session() as sess:
    # Run every operation with variable input
    print ("相加: %i" % sess.run(add, feed_dict={a: 3, b: 4}))
    print ("相乘: %i" % sess.run(mul, feed_dict={a: 3, b: 4}))
    print (sess.run([mul, add], feed_dict = {a: 3, b: 4}))

得到以下输出：

相加: 7
相乘: 12
[12, 7]

标记的方法是：使用 tf.placeholder 为这些操作创建占位符，然后使用 feed_dict 把具体的值放到占位符里。

指定GPU运算

设置GPU使用资源

保存和载入模型的方法介绍

1. 保存模型

首先需要建立一个 saver， 然后在 session 中通过 saver 的 save 即可将模型保存起来。

# 各种构建模型的操作

saver = tf.train.Saver() # 生成saver
with tf.Session() as sess:
    sess.run(init)	# 初始化
    # 将数据丢进模型balabala
    # 训练完以后，使用saver.save来保存
    saver.save(sess, "save_path/file_name")
	# 如果file_name不存在，会自动创建

2. 载入模型

将模型保存好以后，载入也比较方便。在 session 中通 saver 的 restore() 函数会从指定的路径找到模型文件, 并覆盖到相关参数中。

saver = tf.train.Saver() # 生成saver

with tf.Session() as sess:
    # 参数可以不进行初始化，初始化的值也会被restore的值给覆盖掉
    sess.run(init)
    saver.restore(sess, "save_path/file_name")

例：线性回归模型的保存和载入

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# 模拟数据
……
plt.plot(train_X, train_Y, 'ro', label='Original data')
plt.legend()
plt.show()

# 重置图
tf.reset_default_graph()

# 初始化等操作
……
display_step = 2
saver = tf.train.Saver() # 生成saver
savedir = "log/"

# 启动session
with tf.Session() as sess:
    sess.run(init)

    # Sess中的训练代码：
    print (" Finished!")
    saver.save(sess, savedir+"linermodel.cpkt")
    print ("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
    
    # 其他代码
    ……

运行代码会在代码的同级目录下log文件夹中生成几个文件

再重启一个session，并命名为sess2，在代码里通过saver的restore函数将模型载入

#重启一个session    
with tf.Session() as sess2:
    sess2.run(tf.global_variables_initializer())     
    saver.restore(sess2, savedir+"linermodel.cpkt")
    print ("x=0.2，z=", sess2.run(z, feed_dict={X: 0.2}))

3. 分析模型内容，演示模型的其他保存方法

模型内容

虽然模型己经保存了，但是仍然对我们不透明。下面通过编写代码将模型里的内容打印出来，看看到底保存了哪些东西，都是什么样的。

import tensorflow as tf
from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file
savedir = "log/"
print_tensors_in_checkpoint_file(savedir+"linermodel.cpkt", None, True)

W = tf.Variable(1.0, name="weight")
b = tf.Variable(2.0, name="bias")

# 放到一个字典里:
saver = tf.train.Saver({'weight': b, 'bias': W})

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    saver.save(sess, savedir+"linermodel.cpkt")

print_tensors_in_checkpoint_file(savedir+"linermodel.cpkt", None, True)

得到以下信息：

tensor_name：bias
[0.01919404]
tensor_name:weight
[2.03479218]

可以看到后面跟的就是创建变量名，接着的是它的数值。

保存模型的其他方法

前面的例子使用Saver的创建比较简单

其实tf.train.Saver函数里面还可以放参数来实现更高级的功能，可以指定存储变量名字的对应关系。

W = tf.Variable(1.0, name="weight")
b = tf.Variable(2.0, name="bias)

# 放到一个字典里
saver = tf.train.Saver({'weight': b, 'bias': W})

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    saver.save(sess, savedir+"linermodel.cpkt")
                
print_tenssors_in_checkpoint_file(savedir+"linermodel.cpkt", None, Ture)

得到以下信息：

tensor_name：bias
1.0
tensor_name:weight
2.0

例子中， W值设为 1.0 , b 的值设为 2.0 。在创建 saver 时才将它们颠倒， 保存的模型打印出来之后可以看到， bias 变成了 1.0 ，而 weight 变成了 2.0

检查点（Checkpoint）

保存模型并不限于在训练之后，在训练之中也需要保存，因为 Tensorflow 训练模型时难免会出现中断的情况。我们自然希望能够将辛苦得到的中间参数保留下来，否则下次又要重新开始。

这种在训练中保存模型，习惯上称之为保存检查点。

例：为模型添加保存检查点

实例描述：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

plotdata = { "batchsize":[], "loss":[] }
def moving_average(a, w=10):
    if len(a) < w: 
        return a[:]    
    return [val if idx < w else sum(a[(idx-w):idx])/w for idx, val in enumerate(a)]

#生成模拟数据
train_X = np.linspace(-1, 1, 100)
train_Y = 2 * train_X + np.random.randn(*train_X.shape) * 0.3 # y=2x，但是加入了噪声
#图形显示
plt.plot(train_X, train_Y, 'ro', label='Original data')
plt.legend()
plt.show()


tf.reset_default_graph()

# 创建模型
# 占位符
X = tf.placeholder("float")
Y = tf.placeholder("float")
# 模型参数
W = tf.Variable(tf.random_normal([1]), name="weight")
b = tf.Variable(tf.zeros([1]), name="bias")
# 前向结构
z = tf.multiply(X, W)+ b

#反向优化
cost =tf.reduce_mean( tf.square(Y - z))
learning_rate = 0.01
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) #Gradient descent

# 初始化变量
init = tf.global_variables_initializer()
#参数设置
training_epochs = 20
display_step = 2
saver = tf.train.Saver(max_to_keep=1) # 生成saver,最多只保存一个检查点文件
savedir = "log/"
# 启动session
with tf.Session() as sess:
    sess.run(init)

    # Fit all training data
    for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            sess.run(optimizer, feed_dict={X: x, Y: y})

        #显示训练中的详细信息
        if epoch % display_step == 0:
            loss = sess.run(cost, feed_dict={X: train_X, Y:train_Y})
            print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))
            if not (loss == "NA" ):
                plotdata["batchsize"].append(epoch)
                plotdata["loss"].append(loss)
            saver.save(sess, savedir+"linermodel.cpkt", global_step=epoch)
                
    print (" Finished!")
    
    print ("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
    #print ("cost:",cost.eval({X: train_X, Y: train_Y}))

    #图形显示
    plt.plot(train_X, train_Y, 'ro', label='Original data')
    plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
    plt.legend()
    plt.show()
    
    plotdata["avgloss"] = moving_average(plotdata["loss"])
    plt.figure(1)
    plt.subplot(211)
    plt.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')
    plt.xlabel('Minibatch number')
    plt.ylabel('Loss')
    plt.title('Minibatch run vs. Training loss')
     
    plt.show()

    
#重启一个session    
load_epoch=18    
with tf.Session() as sess2:
    sess2.run(tf.global_variables_initializer())     
    saver.restore(sess2, savedir+"linermodel.cpkt-" + str(load_epoch))
    print ("x=0.2，z=", sess2.run(z, feed_dict={X: 0.2}))
    
with tf.Session() as sess3:
    sess3.run(tf.global_variables_initializer()) 
    ckpt = tf.train.get_checkpoint_state(savedir)
    if ckpt and ckpt.model_checkpoint_path:
        saver.restore(sess3, ckpt.model_checkpoint_path)
        print ("x=0.2，z=", sess3.run(z, feed_dict={X: 0.2}))

with tf.Session() as sess4:
    sess4.run(tf.global_variables_initializer()) 
    kpt = tf.train.latest_checkpoint(savedir)
    if kpt!=None:
        saver.restore(sess4, kpt) 
        print ("x=0.2，z=", sess4.run(z, feed_dict={X: 0.2}))

实例：更简便的保存检查点

本例中介绍另一种更简便地保存检查点功能代码的方法一一tf.train.MonitoredTrainingSession 函数

该函数可以直接实现保存及载入检查点模型的文件。

本例中不是按照循环步数来保存，而是按照训练时间来保存的

通过指定save_checkpoint_secs参数的具体秒数，来设置每训练多久保存一次检查点

import tensorflow as tf
tf.reset_default_graph()
global_step = tf.train.get_or_create_global_step()
step = tf.assign_add(global_step, 1)

with tf.train.MonitoredTrainingSession(checkpoint_dir='log/checkpoints',save_checkpoint_secs  = 2) as sess:
    print(sess.run([global_step]))	# 必须使用 global_step 变量
    while not sess.should_stop():
        i = sess.run( step)
        print( i)

运行代码，得到如下输出:

252 12851 
252 12852 
252 12853 
252 12854 
252 12855 
252 12856

将程序停止，可以看到 log/checkpoints 下面生成了检查点文件 model.ckpt-8968 meta。

再次运行代码，输出如下：

252 8969 
252 8970 
252 8971

可见，程序自动载入检查点文件是从第 969 次开始运行的