DL4-单变量线性回归：TensorFlow(1.x)实战

1、线性方程

单变量的线性方程可以 表示为：y = wx + b 即 y = 2.0x +1

本例通过生成人工数据集。随机生成一个近似采样随机分布，使得w=2.0, b=1, 并加入一个噪声，噪声的最大振幅为0.4

（1）人工数据集生成

%matplotlib inline

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

# 设置随机数种子：这样每个人产生的随机数都相同
np.random.seed(5)

# 生成输入数据
x_data = np.linspace(-1,1,100)

# y = 2x + 1 + 噪声。其中，噪声的维度与x_data一致
y_data = 2 * x_data + 1.0 + np.random.randn(*x_data.shape) * 0.4

# numpy.random.randn(d0, d1, d2, ..., dn)是从标准正太分布中返回一个或多个样本值
# 标准正态分布又称为u分布，是以0为均值、以1为标准差的正态分布，记为N(0,1)
np.random.randn(10)

# x_data.shape值为一个元组
x_data.shape

# 实参的前面加上*或**，意味着拆包，单个*表示将元组拆成一个个单独的实参
np.random.randn(*x_data.shape)
#np.random.randn(100)
# 上两语句在本例中实现的功能相同

Jupyter使用小技巧

可以使用Tab键进行代码补齐

(2) 利用 matplotlib 画出生成结果

# 画出随机生成数据的散点图
plt.scatter(x_data,y_data)

# 画出线性函数 y = 2x + 1
plt.plot(x_data,2 * x_data + 1.0, color = 'red', linewidth = 3)

help(plt.plot)

(3) 构建模型

定义训练数据的占位符，x是特征值，y是标签值

import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
tf.reset_default_graph()


x = tf.placeholder("float", name = "x")
y = tf.placeholder("float", name = "y")

构建回归模型

def model(x,w,b):
    return tf.multiply(x,w) + b

创建变量

·TensorFlow变量的声明函数是tf.Variable

·tf.Variable的作用是保存和更新参数

·变量的初始值可以是随机数、常数，或是通过其他变量初始值计算得到

# 构建线性函数的斜率，变量w
w = tf.Variable(1.0,name="w0")
# 构建线性函数的截距，变量b
b = tf.Variable(0.0,name="b0")

WARNING:tensorflow:From C:\Users\PC\Anaconda3\lib\site-packages\tensorflow_core\python\ops\resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.

# pred是预测值，前向计算
pred = model(x,w,b)

(3) 训练模型

设置训练参数

# 迭代次数（训练轮数）
train_epochs = 10

# 学习率
learning_rate = 0.05

# 控制显示loss值的粒度
display_step = 10

定义损失函数

损失函数用于描述预测值与真实值之间的误差，从而指导模型收敛方向

常见损失函数：均方差（Mean Square Error, MSE）和交叉熵（cross-entropy）

L 2 损失函数

# 采样均方差作为损失函数
loss_function = tf.reduce_mean(tf.square(y-pred))

定义优化器

定义优化器Optimizer，初始化一个GradientDescentOptimizer

设置学习率和优化目标：最小化损失

# 梯度下降优化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

创建会话

sess = tf.Session()

变量初始化

init = tf.global_variables_initializer()
sess.run(init)

迭代训练

# 开始训练，轮数为 epoch，采用SGD随机梯度下降优化方法

step = 0
loss_list = []

for epoch in range(train_epochs):# 训练轮数为3次即可
    for xs,ys in zip(x_data,y_data):
        _, loss = sess.run([optimizer,loss_function],feed_dict={x:xs,y:ys})# 一轮100次
        
        #显示损失值loss
        loss_list.append(loss)
        step = step + 1
        if step % display_step == 0:
            print("训练轮数：",'%02d' % (epoch + 1),"Step: %3d" % (step), "损失：","{:.9f}".format(loss))
        
        
    b0temp = b.eval(session = sess)
    w0temp = w.eval(session = sess)
    plt.plot(x_data,w0temp * x_data + b0temp)

训练轮数： 01 Step:  10 损失： 0.179423183
训练轮数： 01 Step:  20 损失： 0.067458346
训练轮数： 01 Step:  30 损失： 0.000281519
训练轮数： 01 Step:  40 损失： 0.344065875
训练轮数： 01 Step:  50 损失： 0.021391280
训练轮数： 01 Step:  60 损失： 0.006406436
训练轮数： 01 Step:  70 损失： 0.142010629
训练轮数： 01 Step:  80 损失： 0.000233675
训练轮数： 01 Step:  90 损失： 0.094913408
训练轮数： 01 Step: 100 损失： 0.052370854
训练轮数： 02 Step: 110 损失： 0.044097763
训练轮数： 02 Step: 120 损失： 0.082669340
训练轮数： 02 Step: 130 损失： 0.000454877
训练轮数： 02 Step: 140 损失： 0.327929199
训练轮数： 02 Step: 150 损失： 0.026971471
训练轮数： 02 Step: 160 损失： 0.009875795
训练轮数： 02 Step: 170 损失： 0.128553197
训练轮数： 02 Step: 180 损失： 0.000938686
训练轮数： 02 Step: 190 损失： 0.102202758
训练轮数： 02 Step: 200 损失： 0.048671149
训练轮数： 03 Step: 210 损失： 0.036854628
训练轮数： 03 Step: 220 损失： 0.084023297
训练轮数： 03 Step: 230 损失： 0.000471393
训练轮数： 03 Step: 240 损失： 0.326585472
训练轮数： 03 Step: 250 损失： 0.027471786
训练轮数： 03 Step: 260 损失： 0.010202700
训练轮数： 03 Step: 270 损失： 0.127448648
训练轮数： 03 Step: 280 损失： 0.001019721
训练轮数： 03 Step: 290 损失： 0.102829941
训练轮数： 03 Step: 300 损失： 0.048365295
训练轮数： 04 Step: 310 损失： 0.036273275
训练轮数： 04 Step: 320 损失： 0.084138028
训练轮数： 04 Step: 330 损失： 0.000472802
训练轮数： 04 Step: 340 损失： 0.326472342
训练轮数： 04 Step: 350 损失： 0.027514204
训练轮数： 04 Step: 360 损失： 0.010230534
训练轮数： 04 Step: 370 损失： 0.127355635
训练轮数： 04 Step: 380 损失： 0.001026707
训练轮数： 04 Step: 390 损失： 0.102882855
训练轮数： 04 Step: 400 损失： 0.048339501
训练轮数： 05 Step: 410 损失： 0.036224432
训练轮数： 05 Step: 420 损失： 0.084147744
训练轮数： 05 Step: 430 损失： 0.000472908
训练轮数： 05 Step: 440 损失： 0.326462865
训练轮数： 05 Step: 450 损失： 0.027517686
训练轮数： 05 Step: 460 损失： 0.010232801
训练轮数： 05 Step: 470 损失： 0.127347812
训练轮数： 05 Step: 480 损失： 0.001027287
训练轮数： 05 Step: 490 损失： 0.102887444
训练轮数： 05 Step: 500 损失： 0.048337404
训练轮数： 06 Step: 510 损失： 0.036220346
训练轮数： 06 Step: 520 损失： 0.084148541
训练轮数： 06 Step: 530 损失： 0.000472921
训练轮数： 06 Step: 540 损失： 0.326461911
训练轮数： 06 Step: 550 损失： 0.027518081
训练轮数： 06 Step: 560 损失： 0.010233018
训练轮数： 06 Step: 570 损失： 0.127347127
训练轮数： 06 Step: 580 损失： 0.001027349
训练轮数： 06 Step: 590 损失： 0.102887906
训练轮数： 06 Step: 600 损失： 0.048337195
训练轮数： 07 Step: 610 损失： 0.036220029
训练轮数： 07 Step: 620 损失： 0.084148541
训练轮数： 07 Step: 630 损失： 0.000472929
训练轮数： 07 Step: 640 损失： 0.326461911
训练轮数： 07 Step: 650 损失： 0.027518081
训练轮数： 07 Step: 660 损失： 0.010233042
训练轮数： 07 Step: 670 损失： 0.127347127
训练轮数： 07 Step: 680 损失： 0.001027349
训练轮数： 07 Step: 690 损失： 0.102888055
训练轮数： 07 Step: 700 损失： 0.048337195
训练轮数： 08 Step: 710 损失： 0.036219940
训练轮数： 08 Step: 720 损失： 0.084148541
训练轮数： 08 Step: 730 损失： 0.000472929
训练轮数： 08 Step: 740 损失： 0.326461911
训练轮数： 08 Step: 750 损失： 0.027518081
训练轮数： 08 Step: 760 损失： 0.010233042
训练轮数： 08 Step: 770 损失： 0.127347127
训练轮数： 08 Step: 780 损失： 0.001027349
训练轮数： 08 Step: 790 损失： 0.102888055
训练轮数： 08 Step: 800 损失： 0.048337195
训练轮数： 09 Step: 810 损失： 0.036219940
训练轮数： 09 Step: 820 损失： 0.084148541
训练轮数： 09 Step: 830 损失： 0.000472929
训练轮数： 09 Step: 840 损失： 0.326461911
训练轮数： 09 Step: 850 损失： 0.027518081
训练轮数： 09 Step: 860 损失： 0.010233042
训练轮数： 09 Step: 870 损失： 0.127347127
训练轮数： 09 Step: 880 损失： 0.001027349
训练轮数： 09 Step: 890 损失： 0.102888055
训练轮数： 09 Step: 900 损失： 0.048337195
训练轮数： 10 Step: 910 损失： 0.036219940
训练轮数： 10 Step: 920 损失： 0.084148541
训练轮数： 10 Step: 930 损失： 0.000472929
训练轮数： 10 Step: 940 损失： 0.326461911
训练轮数： 10 Step: 950 损失： 0.027518081
训练轮数： 10 Step: 960 损失： 0.010233042
训练轮数： 10 Step: 970 损失： 0.127347127
训练轮数： 10 Step: 980 损失： 0.001027349
训练轮数： 10 Step: 990 损失： 0.102888055
训练轮数： 10 Step: 1000 损失： 0.048337195

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zsFd8Rw9-1588865192065)(output_29_1.png)]

print("w=",sess.run(w)) # w=2
print("b=",sess.run(b))# b = 1

w= 1.9822965
b= 1.0420128

# 可视化
plt.scatter(x_data,y_data,label="Original data")
plt.plot(x_data,x_data * sess.run(w) + sess.run(b),label = "Fitted line",color = "r",linewidth=3)
plt.legend(loc = 2)#通过参数loc指定图例位置

for xs,ys in zip(x_data,y_data):# zip 元素组装
    print(xs,ys)

print(y_data)

plt.plot(loss_list)

[<matplotlib.lines.Line2D at 0x29979e715c8>]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xRU2IvQk-1588865192070)(output_34_1.png)]

plt.plot(loss_list,'b+')

[<matplotlib.lines.Line2D at 0x2997b267648>]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rP5aayVP-1588865192074)(output_35_1.png)]

[x for x in loss_list if x > 1]

[2.3539772,
 2.3148305,
 1.3175836,
 1.0387748,
 1.5018207,
 1.547514,
 1.5514,
 1.5517284,
 1.5517554,
 1.551758,
 1.551758,
 1.551758,
 1.551758,
 1.551758]

(4) 利用模型，进行预测

x_test = 3.21

predict = sess.run(pred,feed_dict={x:x_test})
print("预测值：%f" % predict)

target = 2 * x_test + 1.0
print("目标值：%f" % target)

预测值：7.403980
目标值：7.420000

# 不用pred模型也能完成
x_test = 3.21

predict = sess.run(w) * x_test + sess.run(b)
print("预测值：%f" % predict)

预测值：7.403980

(5) 在训练中显示损失值

#
step = 0
loss_list = []