【Tensorflow】编程基础

前面说了那么多都是理论的东西，太空洞了。从今天开始就着手编程了，并在编程的过程中，会对前面提到的理论一一的实现一遍，以加深对理论的理解，闲话少说，这就开始。

1.Tensorflow编程模型

关键要素：
1.图：它包含训练模型的参数、语句、操作，它是Tensorflow 的核心，例如：上面提到的WX + B 就是放到图中的，图是运行到内存中的，所以在运行的过程中是特别的吃内存的。
2.张量：在线性代数中叫向量，在程序中一般叫多维数组，也就是上个文档中提到的样本（X）和标签（Y）,在tensorflow 中使用placeholder表示方式。
3.OP：全称，operate。做的就是把输入的张量组合按WX + B起来。
4.Variable：W、B就是Variable的表现形式之一。

图1
图的执行流程就是：张量 （输入） -> op (组合成 W*X + B) -> 运算资源（CPU/GPU）-> 输出结果，而整个图则是要放到session中运行的，也就是只有运行了session，图才能运行。

2.Tensorflow编程示例

示例1：

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

运行结果：

图2

注意：1.constant() 是定义一个常量。2.Session创建了以后需要关闭，不然会造成内存泄漏。
示例2

a = tf.constant(3)                         #定义一个常量3
b = tf.constant(4)                         #定义一个常量4
with tf.Session() as sess:                 #建立Session
    print("相加：%i" % sess.run(a+b))      #运行a+b 也就是上面提到的OP
    print("相乘：%i" % sess.run(a*b))

运行结果：

图3

注意：1.使用with创建的Session() ,是不需要调用sess.close()的，它会在使用完了自动的调用close(),释放掉内存。
示例3

c = tf.placeholder(tf.int16)
d = tf.placeholder(tf.int16)
add = tf.add(c, d)
mul = tf.multiply(c, d)
with tf.Session() as sess2:
    print("相加：%i" % sess2.run(add, feed_dict={c: 3, d: 4}))  
    print("相乘：%i" % sess2.run(mul, feed_dict={c: 3, d: 4}))
    print(sess2.run([add, mul], feed_dict={c: 3, d: 4}))

运行结果：

图4

注意：1.这是使用placeholder注入的方式声明变量。

3.Tensorflow 变量的操作

1.variable 和 get_variable 的区别
使用tf.Variable时，如果检测到命名冲突，系统会自己处理。使用tf.get_variable()时，系统不会处理冲突，而会报错。但是，Variable 与get_variable 首次重名可以自动生成。本质就是：tf.Variable() 每次都在创建新对象，而tf.get_variable则不是。

with tf.Session() as sess2:
var1 = tf.Variable(1, name="var1")
var2 = tf.Variable(2, name="var1")
sess2.run(tf.global_variables_initializer())
print(var1.name)
print(var1.eval())
print(var2.name)
print(var2.eval())
print(var1 is var2)
#输出
var1:0
1
var1_1:0
2
False

get_var1 = tf.get_variable(name="var1", initializer=1)
print(get_var1.name)
get_var2 = tf.get_variable(name="var1", initializer=2)
print(get_var2.name)
#输出
var1_2:0
#错误信息
#ValueError: Variable w_1 already exists, disallowed. Did
#you mean to set reuse=True in VarScope?

2.variable_scope 与共享变量
加上作用域以后get_variable可以定义同样的变量名称，系统会自动的生成加作用域的变量。如果在作用域声明的过程中，加入reuse=True，表示可以重复使用，定义了共享部分，如果已经创建的变量对象，就把那个对象返回。

with tf.variable_scope("test1", ""):
    var1 = tf.get_variable(name="var1", shape=[2],dtype=float)  #定义1行2列的var1变量
    with tf.variable_scope("test2"):
        var2 = tf.get_variable(name="var1",shape=[2],dtype=float)
print(var1.name)
print(var2.name)
#输出
test1/var1:0
test1/test2/var1:0

with tf.variable_scope("test1", reuse=True):
    var3 = tf.get_variable(name="var1", shape=[2], dtype=float)
    with tf.variable_scope("test2"):
        var4 = tf.get_variable(name="var1", shape=[2], dtype=float)
print(var3.name)
print(var4.name)
#输出
test1/var1:0
test1/test2/var1:0

3.variable_scope 与name_scope的区别
variable_scope ：是作用域，
name_scope：是操作符，针对上面提到的OP。如：下面的x = var2 + 0.1，就是一个操作。
示例：

with tf.variable_scope("scope3"):
    var1 = tf.get_variable("var1", [1])
    with tf.name_scope("scope_name"):  # 针对操作而言的
        var2 = tf.get_variable("var2", [1])
        x = var2 + 0.1
        with tf.variable_scope(""):
            with tf.name_scope(""):
                var3 = tf.get_variable("var3", [1])
                y = var2 + 0.2
print(var1.name)
print(var2.name)
print(x.op.name)
print(var3.name)
print(y.op.name)
# 输出
scope3/var1:0
scope3/var2:0
scope3/scope_name/add
scope3//var3:0
add_2

注意：
1.如果tf.name_scope("")，则提到顶层。
2.tf.variable_scope("")，则相当于增加了“”的域。
3.name_scope对变量的作用域variable_scope是没有任何影响的，但是variable_scope对name_scope是有影响的。

3.Tensorflow 图的操作

1.建立图

import tensorflow as tf
# 定义在全局默认图上的常量
c = tf.constant(0.0)  
# 重新的定义一个图
g = tf.Graph()
with g.as_default():
    c1 = tf.constant(0.0)
    # 获取c1所在的图的地址
    print(c1.graph)
    # 获取创建图的地址
    print(g)
    # 获取c所在图的地址，也就是全局图的地址
    print(c.graph)
# 获取全局图的地址
g2 = tf.get_default_graph()
print(g2)
# 重新生成全局图，并把旧的图销毁
tf.reset_default_graph()
# 获取全局图的地址
g3 = tf.get_default_graph()
print("g3:", g3)
#输出
<tensorflow.python.framework.ops.Graph object at 0x000001CD50C4AB70>
<tensorflow.python.framework.ops.Graph object at 0x000001CD50C4AB70>
<tensorflow.python.framework.ops.Graph object at 0x000001CD4BDA9EF0>
<tensorflow.python.framework.ops.Graph object at 0x000001CD4BDA9EF0>
g3: <tensorflow.python.framework.ops.Graph object at 0x000001CD50C4AE10>

注意：
1.如果在局部图的作用域中获取全局的默认图是不成功的，它只能得到局部的图。
2.重新设置全局图的方法tf.reset_default_graph()

with g.as_default():
    c1 = tf.constant(0.0)
    print(c1.graph)
    print(g)
    print(c.graph)
    g3 = tf.get_default_graph()
    print(g3)
# 输出
<tensorflow.python.framework.ops.Graph object at 0x000002138838BCF8>
<tensorflow.python.framework.ops.Graph object at 0x000002138838BCF8>
<tensorflow.python.framework.ops.Graph object at 0x00000213FF0CB0B8>
<tensorflow.python.framework.ops.Graph object at 0x000002138838BCF8>

2.获取张量

print(c1.name)
# 通过名字，使用所在的图获取张量
t = g.get_tensor_by_name(name="Const:0")
# 打印张量的属性
print(t)
#输出
Const:0
Tensor("Const:0", shape=(), dtype=float32)

3.获取节点操作OP

# 定义一行两列的数组
a = tf.constant([[1.0, 2.0]])
print(a.shape)
# 定义两行一列的数组
b = tf.constant([[1.0], [2.0]])
print(b.shape)
# 定义矩阵的乘法，操作的名字为：exampleop
tensor1 = tf.matmul(a, b, name="exampleop")
# 打印张量的名字、属性
print(tensor1.name, tensor1)
# 打印张量的名字、属性
test = g3.get_tensor_by_name("exampleop:0")
# 打印张量的属性
print(test)
# 输出
(1, 2)
(2, 1)
exampleop:0 Tensor("exampleop:0", shape=(1, 1), dtype=float32)
Tensor("exampleop:0", shape=(1, 1), dtype=float32)

print("获取操作的属性")
print('tensor1.op.name', tensor1.op.name)
# 通过名称使用所在的图得到操作OP的属性
testop = g3.get_operation_by_name("exampleop")
# 打印操作OP的属性
print(testop)
# 输出
tensor1.op.name exampleop
name: "exampleop"
op: "MatMul"
input: "Const"
input: "Const_1"
attr {
  key: "T"
  value {
    type: DT_FLOAT
  }
}
attr {
  key: "transpose_a"
  value {
    b: false
  }
}
attr {
  key: "transpose_b"
  value {
    b: false
  }
}

4.获取元素列表

# 返回图中的操作节点列表
tt2 = g.get_operations()
print(tt2)
# 输出 由上面可以看出在g图中只有c1 定义
[<tf.Operation 'Const' type=Const>]

5.获取对象

print("获取对象")
tt3 = g.as_graph_element(c1)
print(tt3)
# 输出
Tensor("Const:0", shape=(), dtype=float32)

4.深度学习训练模型简介

深度学习的基本开发流程为：
1.准备数据
2.搭建模型
3.训练模型
4.保存模型
5.测试模型
6.查看模型
下面以线性回归拟合为例（Y=2X）说明：
说明：1.numpy .random.randn(d0,d1,…,dn)：randn函数返回一个或一组样本，具有标准正态分布 ，dn表格每个维度。2.tf.random.normal([1])：从正太分布中随机输出一个值。3.tf.zeros([1])：创建一个所有元素都设置为零的张量，例如：tf.zeros([2]) ,其中的值就是[0. 0.]。

import tensorflow as tf
# 生成数据时使用
import numpy as np
# 图形化生成数据
import matplotlib.pyplot as plt
# 生成字典记录训练批次和loss值
plotdata = {"batchsize": [], "loss": []}
# 1.准备数据
t_X = np.linspace(-1, 1, 100)
t_Y = 2 * t_X + np.random.randn(100) * 0.3
# 显示模拟数据
plt.plot(t_X, t_Y, "ro", label="original data")
plt.legend()
plt.show()

# 重新初始化图
tf.reset_default_graph();
# 2.搭建模型
# 占位符
X = tf.placeholder("float")
Y = tf.placeholder("float")
# 2.1模型参数
W = tf.Variable(tf.random.normal([1]), name="weight")
b = tf.Variable(tf.zeros([1]), name="bias")
# 2.2向前结构
z = tf.multiply(X, W) + b
# 2.3反向优化（均方差）
cost = tf.reduce_mean(tf.square(Y-z))
learning_rate = 0.01
# 2.4使用tf的梯度下降优化器设定的学利率不断优化W和b使的loss最小化，最终使z于Y的误差最小
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# 3.训练模型
# 3.1初始化变量
init = tf.global_variables_initializer()
# 3.2训练参数
training_epochs = 20
display_step = 2

# 4.保存模型
saver = tf.train.Saver()
savedir = "Model/"
# 3.4启动Session
with tf.Session() as sess:
    sess.run(init)
    for epoch in range(training_epochs):
        for (x, y) in zip(t_X, t_Y):
            sess.run(optimizer, feed_dict={X: x, Y: y})

        # 显示训练中详细信息
        if epoch % display_step == 0:
            loss = sess.run(cost, feed_dict={X: t_X, Y: t_Y})
            print("测试cost：", cost)
            print("测试loss：", loss)
            print("Epoch:", epoch+1, "loss=", loss, "W=", sess.run(W), "b=", sess.run(b))
            if not (loss == "NA"):
                plotdata["batchsize"].append(epoch)
                plotdata["loss"].append(loss)

    print(" Finsohed!")
    print("loss=", sess.run(cost, feed_dict={X: t_X, Y: t_Y}), "")
    #  4-1保存模型
    saver.save(sess, savedir+"linermodel.cpkt")

    # 图形显示
    plt.plot(t_X, t_Y, "go", label="original data")
    plt.plot(t_X, sess.run(W)*t_X+sess.run(b), label="Fitted")
    plt.legend()
    plt.show()

    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)]
    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()

# 5.测试模型-1
    print("方式1：", "x= 0.2,z=", sess.run(z, feed_dict={X: 0.2}))

#   测试模型-2
with tf.Session() as sess2:
    # 从新初始一下变量
    sess2.run(tf.global_variables_initializer())
    saver.restore(sess2, savedir+"linermodel.cpkt")
    print("方式2：", "x= 0.2,z=", sess2.run(z, feed_dict={X: 0.2}))
# 输出


方式1： x= 0.2,z= [0.41271693]
方式2： x= 0.2,z= [0.41271693]

图5
图6
图7
查看模型：

import tensorflow as tf
# 从tensorflow.python.tools.inspect_checkpoint 引入 方法 print_tensors_in_checkpoint_file
from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file
savedir = "Model/"
# 打印参数
print_tensors_in_checkpoint_file(savedir +  "linermodel.cpkt",, tensor_name=None, all_tensors=True)

从新的修改参数：

import tensorflow as tf
# 从tensorflow.python.tools.inspect_checkpoint 引入 方法 print_tensors_in_checkpoint_file
from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file
savedir = "Model/"
# 修改参数
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 see:
    # 调用方式和以前的不一样
    tf.global_variables_initializer().run()
    # 保存参数
    saver.save(see, savedir + "linermodel.cpkt")
# 打印参数
print_tensors_in_checkpoint_file(savedir + "linermodel.cpkt", , tensor_name=None, all_tensors=True)

保存模型注意：
1.保存模型。由于训练的时间较长，且对内存要求过高，所以在训练的过程中，难免会出现异常，那么怎么样才能，不用多次重复的训练了呢。解决的最简单的办法就是训练几轮后对训练的结果进行保存，所以上面的演示代码是有问题的。修改的结果如下：

# 每次保存一次的检测点
saver = tf.train.Saver(max_to_keep=1)
savedir = "Model/"

if not (loss == "NA"):
    plotdata["batchsize"].append(epoch)
    plotdata["loss"].append(loss)
    # 加上保存的第几次循环
    saver.save(sess, savedir + "linermodel.cpkt", global_step=epoch)

2.使用模型的其他方式

with tf.Session() as sess2:
    # 从新初始一下变量
    sess2.run(tf.global_variables_initializer())
    saver.restore(sess2, savedir+"linermodel.cpkt")
    print("方式2：", "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)
    # 判断ckpt 存在
    if ckpt and ckpt.model_checkpoint_path:
        saver.restore(sess3, ckpt.model_checkpoint_path)
        print("方式3：", "x= 0.2,z=", sess3.run(z, feed_dict={X: 0.2}))

with tf.Session() as sess4:
    sess4.run(tf.global_variables_initializer())
    # 检测最后一个文件
    ckpt = tf.train.latest_checkpoint(savedir)
    if ckpt != None:
        saver.restore(sess4, ckpt)
        print("方式4：", "x= 0.2,z=", sess4.run(z, feed_dict={X: 0.2}))