初学深度学习（一）TensorFlow基本开发步骤之迭代训练and使用模型

本文以逻辑回归拟合二维数据为例进行演示tensorflow的基本开发步骤。

实例：从一组看似混乱的数据中找出y≈2x的规律

实例描述：

假设有一组数据集，其x和y的对应关系为y≈2x。

深度学习大概有如下四个步骤：

（1） 准备数据
（2） 搭建模型
（3） 迭代训练
（4） 使用模型

3、迭代训练

（1）训练模型

通过初学深度学习（一）TensorFlow基本开发步骤之准备数据and搭建模型（正向+反向）的第二步搭建模型中建立好的模型，就可以通过迭代来训练模型了。

注意：tensorflow中的任务是通过session来进行的

# 初始化变量
init = tf.global_variables_initializer() # global_variables_initializer（）函数初始化所有变量

# 训练参数
training_epochs = 20 # 设置迭代次数为20次
display_step = 2

# 启动session
with tf.Session() as sess:
    sess.run(init) # 通过sess.进行网络节点的运算
    plotdata = {
    
    "batchsize":[],"loss":[]} # 存放批次值和损失值

    # 向模型输入数据
    for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            sess.run(optimizer, feed_dict={
    
    X: x, Y: y}) # 通过feed机制将真实数据灌到占位符（第二步创建模型时）对应的位置

        # 输出显示训练中的详细信息，每执行一次都会将网络结构的节点打印出来
        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)

    print (" Finished!")
    print ("cost=", sess.run(cost, feed_dict={
    
    X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))

结果显示：

由以上结果可以看出，cost（生成的预测值与真实值之间的差距）在不断的变小，W和b（两个参数）也在不断的变换。

（2）训练模型的可视化

# 初始化变量
init = tf.global_variables_initializer() # global_variables_initializer（）函数初始化所有变量

# 训练参数
training_epochs = 20 # 设置迭代次数为20次
display_step = 2

# 启动session
with tf.Session() as sess:
    sess.run(init) # 通过sess.进行网络节点的运算
    plotdata = {
    
    "batchsize":[],"loss":[]} # 存放批次值和损失值

    # 向模型输入数据
    for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            sess.run(optimizer, feed_dict={
    
    X: x, Y: y}) # 通过feed机制将真实数据灌到占位符（第二步创建模型时）对应的位置

        # 输出显示训练中的详细信息，每执行一次都会将网络结构的节点打印出来
        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)

    print (" Finished!")
    print ("cost=", sess.run(cost, feed_dict={
    
    X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))

    def moving_average(a,w=10): # 定义moving_average()函数
        if len(a) < w:
            return a[:]
        return [val if idx<w else sum(a[(idx-w):idx])/w for idx,val in enumerate(a)]

    #图形显示
    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()

结果显示：

• 第一张图中所示的斜线，是模型的参数w和b为常量时所组成的关于x与y的直线方程，几乎是一条y=2x的直线。
• 第二张图可以看出刚开始损失值一直下降，到第五次左右趋于平稳。

4、使用模型

模型训练好后，只需要往里面传入一个输入值，然后使用sess.run来运行模型中的各个节点就可以使用模型了。

# 初始化变量
init = tf.global_variables_initializer() # global_variables_initializer（）函数初始化所有变量

# 训练参数
training_epochs = 20 # 设置迭代次数为20次
display_step = 2

# 启动session
with tf.Session() as sess:
    sess.run(init) # 通过sess.进行网络节点的运算
    plotdata = {
    
    "batchsize":[],"loss":[]} # 存放批次值和损失值

    # 向模型输入数据
    for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            sess.run(optimizer, feed_dict={
    
    X: x, Y: y}) # 通过feed机制将真实数据灌到占位符（第二步创建模型时）对应的位置

        # 输出显示训练中的详细信息，每执行一次都会将网络结构的节点打印出来
        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)

    print (" Finished!")
    print ("cost=", sess.run(cost, feed_dict={
    
    X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))

    def moving_average(a,w=10): # 定义moving_average()函数
        if len(a) < w:
            return a[:]
        return [val if idx<w else sum(a[(idx-w):idx])/w for idx,val in enumerate(a)]

    #图形显示
    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()
    
    print ("x=0.2，z=", sess.run(z, feed_dict={
    
    X: 0.2}))

如上面代码的最后一行即：往里面传入一个0.2（feed_dict={X: 0.2}），然后使用sess.run来运行模型中的z节点，就可以查看其生成的值。

产生结果：