深度学习之TensorFlow入门、原理与进阶实战（一）

1.准备数据

• 主体公式y=2x，生成-1到1之间的100个数为自变量x
• 添加随机噪声，即x乘2，加入一个[-1,1]之间的随机数*0.3.
  线性回归代码：

"""1.准备数据"""
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import os
# 只显示 warning 和 Erro
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'
# 生成-1到1的100个数
train_X = np.linspace(-1,1,100)
# y=2x加入随机噪声即y=2x+b
train_Y = 2 * train_X + np.random.randn(*train_X.shape) * 0.1
# 等价于train_Y = 2 * train_X + np.random.randn(100) * 0.1
# 显示数据点
plt.plot(train_X,train_Y,'ro',label='Original data')
plt.legend()
plt.show()

如下散点图就是我们的数据。

2.搭建模型

2.1正向搭建模型

我们的神经元网络模型是具有单个神经元的模型，模型图省略，对于神经网络的解释和发展历程，参见我的博客：https://blog.csdn.net/qq_45416295/article/details/104093029的第一代神经网络。
$z=\displaystyle\sum_{i=1}^{n} w_ix_i+b=wx+b$
其中， $z$为输出结果， $x$是输入， $w$是权重， $b$是偏置值。
给出代码：

"""2.创建正向模型"""
# 占位符定义
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

2.2 反向搭建模型

反向调整参数，再正向生成预测值，与真实值比对。
反向传播使用封装的梯度下降算法。学习率的值小于1，值越大，不精确。

"""3.反向优化"""
#平方差
cost = tf.reduce_mean(tf.square(Y-z))
#学习率，即微调速度
learning_rate = 0.01
#梯度下降算法
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

3.迭代训练模型

3.1训练模型

"""4.训练模型"""
# 初始化变量
init = tf.global_variables_initializer()
# 定义参数
training_epochs = 20
display_step = 2
# 启动session
with tf.Session() as sess:
    sess.run(init)
    # 存放批次和损失值
    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})
        # 显示训练信息
        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))

运行以上程序，给出我的运行结果：

Epoch: 1 cost= 0.56755114 W= [0.86081904] b= [0.3397411]
Epoch: 3 cost= 0.05426327 W= [1.697762] b= [0.11609375]
Epoch: 5 cost= 0.01229015 W= [1.9247781] b= [0.03061856]
Epoch: 7 cost= 0.009508252 W= [1.9836562] b= [0.00805209]
Epoch: 9 cost= 0.009338261 W= [1.9988838] b= [0.00220902]
Epoch: 11 cost= 0.009331079 W= [2.002822] b= [0.00069783]
Epoch: 13 cost= 0.009331681 W= [2.0038385] b= [0.00030758]
Epoch: 15 cost= 0.009331999 W= [2.0041018] b= [0.00020666]
Epoch: 17 cost= 0.009332093 W= [2.00417] b= [0.00018057]
Epoch: 19 cost= 0.0093321195 W= [2.0041878] b= [0.00017356]
Epoch: 21 cost= 0.009332124 W= [2.0041924] b= [0.00017193]
Epoch: 23 cost= 0.009332127 W= [2.0041938] b= [0.00017136]
Epoch: 25 cost= 0.009332128 W= [2.0041938] b= [0.00017135]
Epoch: 27 cost= 0.009332128 W= [2.0041938] b= [0.00017135]
Epoch: 29 cost= 0.009332128 W= [2.0041938] b= [0.00017135]
Finished!
cost= 0.009332128 W= [2.0041938] b= [0.00017135]

比较结果是：w->2,b->0则越准确。

3.2 模型可视化

我们将生成的模型和训练的状态值用可视化图表表示出来 。

	"""5.图像显示"""
    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.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')
    plt.xlabel('Minibatch number')
    plt.ylabel('Loss')
    plt.title('Minibatch run vs. Training loss')
    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)]

运行程序，看一看：


损失值在5次左右趋于平稳。

4.使用模型

训练好的模型现在可以检验，传入0.2（通过feed_dict={X:0.2}）,使sess.run运行模型的z节点。
代码：

print("x=0.2,z=", sess.run(z, feed_dict={X: 0.2}))

运行结果：

x=0.2,z= [0.390122]

z与y的差距确实不太大，这样，我们的第一个TensorFlow程序就OK了。
注：注意所有代码运行在一个py程序中。均按照从前到后的顺序写代码。