DL5-单变量线性回归：TensorFlow(2.0)实战

使用TensorFlow进行算法设计与训练的核心步骤

1、准备数据

2、构建模型

3、训练模型

4、进行预测

（1） 导入相关库

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
%matplotlib inline
print("TensorFlow版本是：",tf.__version__)

TensorFlow版本是： 2.0.0

（2）生成数据集

# 设置随机数种子：这样每个人产生的随机数都相同
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

# 画出随机生成数据的散点图
plt.scatter(x_data,y_data)
plt.xlabel("x")
plt.ylabel("y")
plt.title("Figure:Traning Data")

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

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

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

（3）构建回归模型

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

（4）创建待优化变量

w = tf.Variable(np.random.randn(),tf.float32)

b = tf.Variable(0.0,tf.float32)

（5）定义损失函数

# 定义均方差损失函数

def loss(x,y,w,b):
    err = model(x,w,b) - y #计算模型预测值和标签值的差异
    squared_err = tf.square(err) # 求平方，得出方差
    return tf.reduce_mean(squared_err) # 求均值，得出均方差

（6）训练模型

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

# 学习率
learning_rate = 0.01

（7） 定义计算梯度函数

# 计算样本数据[x,y]在参数[w,b]点上的梯度
def grad(x,y,w,b):
    with tf.GradientTape() as tape:
        loss_ = loss(x,y,w,b)
    return tape.gradient(loss_,[w,b])   #返回梯度向量
# 在TensorFlow 2中，使用tf.GradientTape()这一上下文管理器封装需要求导的计算步骤，并使用其gradient()方法求导

（8）执行训练

step = 0 # 记录训练步数
loss_list = [] #保存loss值得列表
display_step = 50 # 控制显示loss的频率，不是超参数
for epoch in range(train_epochs):
    for xs,ys in zip(x_data,y_data):# 拉链匹配
        loss_ = loss(xs,ys,w,b)  #计算损失
        loss_list.append(loss_)  # 保存本次损失计算结果
        
        delta_w, delta_b = grad(xs, ys, w, b)   #计算该点当前[w,b]的梯度
        change_w = delta_w * learning_rate   #计算变量w需要调整的量
        change_b = delta_b * learning_rate    #计算变量b需要调整的量
        w.assign_sub(change_w)    #变量w的值变更为：减去change_w后的值
        b.assign_sub(change_b)    #变量b的值变更为：减去change_b后的值
        
        step += 1
        if step % display_step == 0:
            print("训练轮数：",'%02d' % (epoch + 1),"Step: %3d" % (step), "损失：","{:.9f}".format(loss_))
    plt.plot(x_data, w.numpy() * x_data + b.numpy())

训练轮数： 01 Step:  50 损失： 0.026670698
训练轮数： 01 Step: 100 损失： 0.302369088
训练轮数： 02 Step: 150 损失： 0.021674523
训练轮数： 02 Step: 200 损失： 0.038779143
训练轮数： 03 Step: 250 损失： 0.014568130
训练轮数： 03 Step: 300 损失： 0.000168041
训练轮数： 04 Step: 350 损失： 0.010989822
训练轮数： 04 Step: 400 损失： 0.006587421
训练轮数： 05 Step: 450 损失： 0.009303551
训练轮数： 05 Step: 500 损失： 0.016666954
训练轮数： 06 Step: 550 损失： 0.008492727
训练轮数： 06 Step: 600 损失： 0.023558175
训练轮数： 07 Step: 650 损失： 0.008093495
训练轮数： 07 Step: 700 损失： 0.027518773
训练轮数： 08 Step: 750 损失： 0.007894210
训练轮数： 08 Step: 800 损失： 0.029650694
训练轮数： 09 Step: 850 损失： 0.007793678
训练轮数： 09 Step: 900 损失： 0.030765586
训练轮数： 10 Step: 950 损失： 0.007742867
训练轮数： 10 Step: 1000 损失： 0.031340327

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

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

w= 1.995343
b= 1.0349013

（9）进行预测

x_test = 3.21

predict = model(x_test,w.numpy(),b.numpy())
print("预测值：%f" % predict)

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

预测值：7.439952
目标值：7.420000

批量梯度下降优化（ BGD ， Batch gradient descent ）实现

# 1、导入相关库
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
%matplotlib inline


# 2、生成数据集
# 设置随机数种子：这样每个人产生的随机数都相同
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


# 3、构建模型
def model(x,w,b):
    return tf.multiply(x,w) + b


# 4、声明变量
w = tf.Variable(np.random.randn(),tf.float32)
b = tf.Variable(0.0,tf.float32)


# 5、定义损失函数
# 定义均方差损失函数
def loss(x,y,w,b):
    err = model(x,w,b) - y #计算模型预测值和标签值的差异
    squared_err = tf.square(err) # 求平方，得出方差
    return tf.reduce_mean(squared_err) # 求均值，得出均方差



# 6、训练模型
# 超参数设置
train_epochs = 100 # 迭代次数（训练轮数）
learning_rate = 0.05 # 学习率 


# 7、梯度函数
# 计算样本数据[x,y]在参数[w,b]点上的梯度
def grad(x,y,w,b):
    with tf.GradientTape() as tape:
        loss_ = loss(x,y,w,b)
    return tape.gradient(loss_,[w,b])   #返回梯度向量


# 8、执行训练 BGD：批量梯度下降优化

loss_list = [] #保存loss值得列表

for epoch in range(train_epochs):
    loss_ = loss(x_data,y_data,w,b)  #计算损失,所有样本作为一个整体参与计算
    loss_list.append(loss_)  # 保存本次损失计算结果
        
    delta_w, delta_b = grad(x_data, y_data, w, b)   #计算该点当前[w,b]的梯度
    change_w = delta_w * learning_rate   #计算变量w需要调整的量
    change_b = delta_b * learning_rate    #计算变量b需要调整的量
    w.assign_sub(change_w)    #变量w的值变更为：减去change_w后的值
    b.assign_sub(change_b)    #变量b的值变更为：减去change_b后的值
        
    print("训练轮数：",'%02d' % (epoch + 1), "损失：","{:.9f}".format(loss_))
    plt.plot(x_data, w.numpy() * x_data + b.numpy())

训练轮数： 01 损失： 1.713498950
训练轮数： 02 损失： 1.475883365
训练轮数： 03 损失： 1.279296398
训练轮数： 04 损失： 1.116217613
训练轮数： 05 损失： 0.980537474
训练轮数： 06 损失： 0.867290139
训练轮数： 07 损失： 0.772436976
训练轮数： 08 损失： 0.692691803
训练轮数： 09 损失： 0.625379205
训练轮数： 10 损失： 0.568318486
训练轮数： 11 损失： 0.519731581
训练轮数： 12 损失： 0.478166759
训练轮数： 13 损失： 0.442437559
训练轮数： 14 损失： 0.411573023
训练轮数： 15 损失： 0.384777576
训练轮数： 16 损失： 0.361397922
训练轮数： 17 损失： 0.340897173
训练轮数： 18 损失： 0.322832882
训练轮数： 19 损失： 0.306839615
训练轮数： 20 损失： 0.292614907
训练轮数： 21 损失： 0.279907584
训练轮数： 22 损失： 0.268508673
训练轮数： 23 损失： 0.258243442
训练轮数： 24 损失： 0.248965532
训练轮数： 25 损失： 0.240551755
训练轮数： 26 损失： 0.232897952
训练轮数： 27 损失： 0.225915849
训练轮数： 28 损失： 0.219530120
训练轮数： 29 损失： 0.213676259
训练轮数： 30 损失： 0.208298832
训练轮数： 31 损失： 0.203349769
训练轮数： 32 损失： 0.198787346
训练轮数： 33 损失： 0.194575176
训练轮数： 34 损失： 0.190681174
训练轮数： 35 损失： 0.187077180
训练轮数： 36 损失： 0.183738157
训练轮数： 37 损失： 0.180641785
训练轮数： 38 损失： 0.177768216
训练轮数： 39 损失： 0.175099492
训练轮数： 40 损失： 0.172619537
训练轮数： 41 损失： 0.170313761
训练轮数： 42 损失： 0.168168902
训练轮数： 43 损失： 0.166172966
训练轮数： 44 损失： 0.164314926
训练轮数： 45 损失： 0.162584707
训练轮数： 46 损失： 0.160973072
训练轮数： 47 损失： 0.159471557
训练轮数： 48 损失： 0.158072352
训练轮数： 49 损失： 0.156768247
训练轮数： 50 损失： 0.155552596
训练轮数： 51 损失： 0.154419199
训练轮数： 52 损失： 0.153362423
训练轮数： 53 损失： 0.152376980
训练轮数： 54 损失： 0.151457950
训练轮数： 55 损失： 0.150600806
训练轮数： 56 损失： 0.149801314
训练轮数： 57 损失： 0.149055570
训练轮数： 58 损失： 0.148359910
训练轮数： 59 损失： 0.147710964
训练轮数： 60 损失： 0.147105545
训练轮数： 61 损失： 0.146540731
训练轮数： 62 损失： 0.146013781
训练轮数： 63 损失： 0.145522162
训练轮数： 64 损失： 0.145063445
训练轮数： 65 损失： 0.144635454
训练轮数： 66 损失： 0.144236118
训练轮数： 67 损失： 0.143863529
训练轮数： 68 损失： 0.143515855
训练轮数： 69 损失： 0.143191487
训练轮数： 70 损失： 0.142888799
训练轮数： 71 损失： 0.142606378
训练轮数： 72 损失： 0.142342821
训练轮数： 73 损失： 0.142096907
训练轮数： 74 损失： 0.141867459
训练轮数： 75 损失： 0.141653344
训练轮数： 76 损失： 0.141453549
训练轮数： 77 损失： 0.141267121
训练轮数： 78 损失： 0.141093165
训练轮数： 79 损失： 0.140930817
训练轮数： 80 损失： 0.140779346
训练轮数： 81 损失： 0.140637994
训练轮数： 82 损失： 0.140506089
训练轮数： 83 损失： 0.140383050
训练轮数： 84 损失： 0.140268177
训练轮数： 85 损失： 0.140161023
训练轮数： 86 损失： 0.140061021
训练轮数： 87 损失： 0.139967695
训练轮数： 88 损失： 0.139880612
训练轮数： 89 损失： 0.139799371
训练轮数： 90 损失： 0.139723554
训练轮数： 91 损失： 0.139652789
训练轮数： 92 损失： 0.139586776
训练轮数： 93 损失： 0.139525160
训练轮数： 94 损失： 0.139467672
训练轮数： 95 损失： 0.139414027
训练轮数： 96 损失： 0.139363974
训练轮数： 97 损失： 0.139317259
训练轮数： 98 损失： 0.139273658
训练轮数： 99 损失： 0.139233023
训练轮数： 100 损失： 0.139195055

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

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

w= 1.9671639
b= 1.0365912

plt.plot(loss_list)

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

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