TensorFlow初体验之模拟深度学习出函数y=2*x

一、准备模拟数据

我们准备模拟被学习出来的函数时y=2x，因此，我们需要准备好大约（几乎所有现实模型都不会那么匹配，这就是学习的以为）符合这样的点（x，y）。这里我们可以直接使用生成随机数train_X，同时在随机生成干扰数b。而我们最终希望生成的W就是2（注：深度学习最终的数学模型就是WX+b=Y，W为系数矩阵，X为输入矩阵，b为偏执值，Y为输出），因此我们可以直接令tarin_Y=train_X*2+b。具体代码如下：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt   #python的2D绘图库

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)   #生成100个-1到1之间的数作为x
train_Y = 2*train_X + np.random.randn(*train_X.shape)*0.3 #y=2x,并加入一定的噪声

二、绘制用来训练的train_X和train_Y图像

这里我们调用绘图工具，将用来训练的数据点绘制出来，一边查看大体形状是否符合y=2*x
代码如下：

#'bo'表示颜色为蓝色,label后面的则为该图像的标签信息
plt.plot(train_X,train_Y,'bo',label='Original data')   
 #自动检测要显示在图例中的元素,如图片左上角显示的'Original data'
plt.legend()  
plt.show()

图像结果如下：

三、创建变量、前向结构与反向优化机构

这里我们首先利用tf.placeholder(‘float32’）方法声明变量X和Y，并初始化W和b。

#占位符
X = tf.placeholder('float32')
Y = tf.placeholder('float32')
#模型参数
#初始化W为[-1,1]的随机数,且是一维数字
W = tf.Variable(tf.random_normal([1]),name='weight')
#初始化为0,一维
b = tf.Variable(tf.zeros([1]),name='bias')

前向结构即为直接计算公式z=W*X+b，

#前向结构
z = tf.multiply(X,W)+b

反向优化则需要根据所选定的梯度下降算法，从而计算与设定出相应的参数，进行反向优化

#反向优化
#cost为生成值和真实值的平方差
cost = tf.reduce_mean(tf.square(Y-z))
#定义学习效率,不得超过1,越大调整速度越大,但越不精确,反之速度慢,且精确
learning_rate = 0.01
#这里GradientDescentOptimizer是封装好的梯度下降算法,minimize()方法的意思是减少差值
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
#梯度下降

四、利用模型开始学习及学习检验

当我们将所需要的数据准备完毕后，便可利用前向和反向结构进行学习，最终运用输出公式

#初始化所有变量
init = tf.global_variables_initializer()
#定义参数
train_epochs = 20
display_step = 2

#启动session
with tf.Session() as sess:
    sess.run(init)
    plotdata={"batchsize":[],"loss":[]}   #存放批次值和损失值
    for epoch in range(train_epochs):
        for (x,y) in zip(train_X,train_Y):
            sess.run(optimizer,feed_dict={X:x,Y:y})
            #显示训练中的详细信息,即每2步显示一次
        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))
    
    #图形显示
    plt.plot(train_X,train_Y,'ro',label='Original data')
    plt.plot(train_X,sess.run(W)*train_X+sess.run(b),label='Fittedline')
    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}))

这里最终输出的学习图像为：

loss的图像为：

控制台输出语句如下：

Epoch: 1 cost= 0.16939259 W= [1.590732] b= [0.1145621]
Epoch: 3 cost= 0.089710124 W= [1.9175267] b= [0.02490955]
Epoch: 5 cost= 0.083120786 W= [2.0059147] b= [-0.00840732]
Epoch: 7 cost= 0.082641535 W= [2.0288339] b= [-0.01719232]
Epoch: 9 cost= 0.08260084 W= [2.0347629] b= [-0.01946726]
Epoch: 11 cost= 0.0825959 W= [2.036295] b= [-0.02005519]
Epoch: 13 cost= 0.082595 W= [2.0366905] b= [-0.02020703]
Epoch: 15 cost= 0.0825948 W= [2.0367935] b= [-0.02024655]
Epoch: 17 cost= 0.08259473 W= [2.0368197] b= [-0.02025656]
Epoch: 19 cost= 0.08259472 W= [2.0368266] b= [-0.02025924]
Finished!
cost= 0.08259472 W= [2.0368283] b= [-0.02025987]
x=0.2,z= [0.3871058]

可以看到，经过训练后的w接近为2，b接近为0，也就是说我们训练得出了十分接近输入案例的函数模型了！