TensorFlow 二

监督式学习

简单线性回归案例

通过数据训练找出 y = w * x + b 其中的w的值 这里使用一个神经元进行训练得出训练结果

术语

标签

y

特征

线性回归中的x

样本

数据的特定实例 x

有标签样本

{x, y} 用于进行训练

无标签样本

{x, ?} 对新数据进行预测

样本

指数据的特定实例 x

模型

样本映射到标签其中的参数值通过训练得出

训练

训练模型通过有标签样本 学习确定权重，偏差的理想值

在监督式学习中 通过多个模型进行减少损失的模型

这是经验风险最小化

损失

对糟糕预测的惩罚

训练模型的目标 找出平均损失最小的模型

损失函数

问题

上方那个mse较高

训练模型的迭代

要点

首先对权重w和偏差b进行初始猜测

反复调整这些猜测

直到获得损失为最低的权重和偏差 进行训练

收敛

学习优化过程中 机器学习根据标签评估特征 为损失函数生成新的值， 新的值又产生新的参数值 不断迭代 直到缓慢不在增长，此时为收敛

例子

使用mse进行计算

模型为

pred = w * x + b

使用凸图形进行运算

斜率为0的损失最小 此为损失函数的收敛之处

模型优化的找的是最低点，斜率为0

梯度下降法

初始值会随机取，

左走，还是右走，使用梯度下降法进行判断

梯度 一个向量 表示某一函数在该点处的方向导数沿着该方向取的最大值，函数在该点处 沿着该方向，梯度的方向变化最快，变化率最大

高等数学中的导数求导

梯度下降法

使用梯度下降法进行计算

沿着梯度负方向进行探索

学习率

沿着负梯度进行探索

下一步走多少，使用学习速率

超参数

初始值

非训练得到的值

训练过程

1. 准备数据
2. 构建模型
3. 训练模型
4. 进行预测

生成数据 加入噪声比

import tensorflow as tf
# 载入plt
import matplotlib.pyplot as plt
import numpy as np




# 设置种子
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.random(*x_data.shape) * 0.4

print(y_data)

/home/ming/PycharmProjects/untitled2/venv/bin/python /home/ming/PycharmProjects/untitled2/index2.py
[-9.11202732e-01 -6.11303037e-01 -8.36504257e-01 -5.11343516e-01
 -6.43019363e-01 -5.53282253e-01 -4.51212615e-01 -5.09804522e-01
 -5.58047476e-01 -5.61275145e-01 -5.63663088e-01 -2.60179437e-01
 -3.38627826e-01 -4.11423528e-01 -8.23686219e-02 -2.84304809e-01
 -1.87841346e-01 -1.94699340e-01 -2.12121092e-02 -3.88108247e-04
  4.80524867e-02 -4.51875045e-02  2.76324115e-03  3.07282116e-02
  1.00722549e-01  6.77667304e-02  1.16750195e-01  4.76481303e-01
  5.15403817e-01  2.47083034e-01  2.21843837e-01  3.34347471e-01
  5.72866739e-01  6.45139168e-01  3.82910611e-01  6.45206557e-01
  4.55202324e-01  7.01138540e-01  7.91271606e-01  9.70007337e-01
  7.19800655e-01  9.77564411e-01  1.04516293e+00  1.10647358e+00
  7.78663463e-01  1.00597717e+00  1.25117335e+00  1.05856782e+00
  1.26488693e+00  1.19838058e+00  1.32854366e+00  1.25457849e+00
  1.11265473e+00  1.17602442e+00  1.22639971e+00  1.32272027e+00
  1.64859238e+00  1.55573672e+00  1.67009842e+00  1.61027118e+00
  1.67838491e+00  1.78940742e+00  1.87572355e+00  1.91050525e+00
  1.91578287e+00  1.66394372e+00  1.81108603e+00  1.72127432e+00
  1.96601809e+00  2.10633588e+00  1.84873995e+00  1.94415396e+00
  2.05528202e+00  2.04721130e+00  2.30793398e+00  2.17114100e+00
  2.32625814e+00  2.30847713e+00  2.38491505e+00  2.56763893e+00
  2.60973927e+00  2.31740424e+00  2.65055330e+00  2.49194661e+00
  2.43427030e+00  2.58770706e+00  2.67888939e+00  2.89959275e+00
  2.70416060e+00  2.60090736e+00  2.98024639e+00  2.72121198e+00
  2.90850733e+00  3.09756777e+00  3.00387498e+00  3.01702697e+00
  3.19897845e+00  2.92734847e+00  3.18864342e+00  3.16455345e+00]

Process finished with exit code 0

生成的数 符合正态分布

绘图

import tensorflow as tf
# 载入plt
import matplotlib.pyplot as plt
import numpy as np




# 设置种子
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.random(*x_data.shape) * 0.4

plt.scatter(x_data, y_data)
plt.show()

构建模型

# 定义模型 训练模型请求w和b 使得最小
def model(x, w, b):
    return tf.multiply(x, w) + b

import tensorflow as tf
# 载入plt
import matplotlib.pyplot as plt
import numpy as np




# 设置种子
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.random(*x_data.shape) * 0.4

plt.scatter(x_data, y_data)
plt.show()

# 定义占位符
x = tf.placeholder("float", name="x")
y = tf.placeholder("float", name="y")

# 定义模型 训练模型请求w和b 使得最小 w * x + b
def model(x, w, b):
    return tf.multiply(x, w) + b


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

# 定义预测值
pred = model(x, w, b)

设置一些内容

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

# 定义预测值
pred = model(x, w, b)

# 设置迭代次数
train_epochs = 10
# 学习率
learning_rate = 0.05

# 定义损失函数
# 使用均方差
loss_function = tf.reduce_mean(tf.square(y-pred))

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

初始化

# 初始化
init = tf.global_variables_initializer()
sess.run(init)

训练

# 训练
for epoch in range(train_epochs):
    # 组合成为一维数组
    for xs, ys in zip(x_data, y_data):
        loss = sess.run([optimizer, loss_function], feed_dict={x:xs, y:ys})
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    plt.plot(x_data, w0temp * x_data + b0temp)

plt.show()

结果打印

# 结果打印
print("w" , sess.run(w))
print("b", sess.run(b))

绘图

# 结果打印
print("w" , sess.run(w))
print("b", sess.run(b))

# 根据求出 w 和 b进行画图
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)
plt.show()

完整文件

import tensorflow as tf
# 载入plt
import matplotlib.pyplot as plt
import numpy as np




# 设置种子
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.random(*x_data.shape) * 0.4

plt.scatter(x_data, y_data)
plt.show()

# 定义占位符
x = tf.placeholder("float", name="x")
y = tf.placeholder("float", name="y")

# 定义模型 训练模型请求w和b 使得最小 w * x + b
def model(x, w, b):
    return tf.multiply(x, w) + b


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

# 定义预测值
pred = model(x, w, b)

# 设置迭代次数
train_epochs = 10
# 学习率
learning_rate = 0.05

# 定义损失函数
# 使用均方差
loss_function = tf.reduce_mean(tf.square(y-pred))

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


sess = tf.Session()

# 初始化
init = tf.global_variables_initializer()
sess.run(init)

# 训练
for epoch in range(train_epochs):
    # 组合成为一维数组
    for xs, ys in zip(x_data, y_data):
        loss = sess.run([optimizer, loss_function], feed_dict={x:xs, y:ys})
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    plt.plot(x_data, w0temp * x_data + b0temp)

plt.show()

# 结果打印
print("w" , sess.run(w))
print("b", sess.run(b))

# 根据求出 w 和 b进行画图
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)
plt.show()

模型预测

# 预测结果
x_test = 3.21
predict = sess.run(pred, feed_dict={x:x_test})
print(predict)

步骤

1. 生成数据可视化
2. 构建模型
3. 定义损失函数
4. 定义优化器 ， 最下化损失函数
5. 训练结果可视化
6. 利用学习到的模型进行预测

显示损失

# 训练
step = 0 # 步数
loss_list = [] # 保存loss列表 损失值
display_step = 10 # 报告粒度

# 训练
for epoch in range(train_epochs):
    # 组合成为一维数组
    for xs, ys in zip(x_data, y_data):
        loss = sess.run([optimizer, loss_function], feed_dict={x:xs, y:ys})
        # 显示损失值
        loss_list.append(loss)
        step = step + 1
        if step % display_step == 0:
            print("第几轮" , (epoch + 1))
            print("第几次", step)
            print("损失值", format(loss))
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    plt.plot(x_data, w0temp * x_data + b0temp)

画图

# 显示损失值
plt.plot(loss_list)
plt.plot(loss_list, "r+")

完整文件

import tensorflow as tf
# 载入plt
import matplotlib.pyplot as plt
import numpy as np




# 设置种子
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.random(*x_data.shape) * 0.4

plt.scatter(x_data, y_data)
plt.show()

# 定义占位符
x = tf.placeholder("float", name="x")
y = tf.placeholder("float", name="y")

# 定义模型 训练模型请求w和b 使得最小 w * x + b
def model(x, w, b):
    return tf.multiply(x, w) + b


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

# 定义预测值
pred = model(x, w, b)

# 设置迭代次数
train_epochs = 10
# 学习率
learning_rate = 0.05

# 定义损失函数
# 使用均方差
loss_function = tf.reduce_mean(tf.square(y-pred))

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


sess = tf.Session()

# 初始化
init = tf.global_variables_initializer()
sess.run(init)

# 训练
step = 0 # 步数
loss_list = [] # 保存loss列表 损失值
display_step = 10 # 报告粒度

# 训练
for epoch in range(train_epochs):
    # 组合成为一维数组
    for xs, ys in zip(x_data, y_data):
        loss = sess.run([optimizer, loss_function], feed_dict={x:xs, y:ys})
        # 显示损失值
        loss_list.append(loss)
        step = step + 1
        if step % display_step == 0:
            print("第几轮" , (epoch + 1))
            print("第几次", step)
            print("损失值", format(loss))
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    plt.plot(x_data, w0temp * x_data + b0temp)

# 显示损失值
plt.plot(loss_list)
plt.plot(loss_list, "r+")
plt.show()

# 结果打印
print("w" , sess.run(w))
print("b", sess.run(b))

# 根据求出 w 和 b进行画图
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)
plt.show()

# 预测结果
x_test = 3.21
predict = sess.run(pred, feed_dict={x:x_test})
print(predict)

其他

随机梯度下降法