Python 中的机器学习简介：简单线性回归
一、说明
简单线性回归为机器学习提供了优雅的介绍。它可用于标识自变量和因变量之间的关系。使用梯度下降，可以训练基本模型以拟合一组点以供未来预测。
二、技术背景
这是涵盖回归、梯度下降、分类和机器学习的其他基本方面的系列文章的第一篇文章。本文重点介绍简单的线性回归，它确定了一组点的最佳拟合线，以便进行将来的预测。
2.1 最佳拟合线
最佳拟合线是最准确地表示一组点的方程。对于给定的输入，公式的输出应尽可能接近预期输出。
在上图中，很明显，中间线比左线或右线更适合蓝点。但是，它是最适合的路线吗？有没有第四条线更适合这些观点？这条线当然可以向上或向下移动，以确保相同数量的点落在其上方和下方。但是，可能有十几行符合此确切标准。是什么让其中任何一个成为最好的？
值得庆幸的是，有一种方法可以使用回归在数学上确定一组点的最佳拟合线。
2.2 回归
回归有助于识别两个或多个变量之间的关系，它采用多种形式，包括简单线性、多重线性、多项式等。为了证明这种方法的有用性，将使用简单的线性回归。
简单线性回归尝试找到一组点的最佳拟合线。更具体地说，它标识自变量和因变量之间的关系。最佳拟合线的形式为 y = mx + b。
- x 是输入或自变量
- m 是直线的斜率或陡度
- b 是 y 截距
- y 是输出或因变量
简单线性回归的目标是确定 m 和 b 的值，当给定 x 时，这些值将生成最准确的 y 值。这个方程，也称为模型，也可以用机器学习术语进行评估。在等式中，w 表示"重量"：Ŷ = Xw₁+ w₀
- X 是输入或特征
- w₁ 是斜率
- w₀ 是偏置或 y 截距
- Ŷ是预测，发音为"y-hat"
虽然这很有用，但需要评估方程的准确性。如果它的预测很差，它就不是很有用。为此，使用成本或损失函数。
2.3 成本或损失函数
回归需要某种方法来跟踪模型预测的准确性。给定输入，方程的输出是否尽可能接近预期输出？成本函数，也称为损失函数，用于确定方程的精度。
例如，如果预期输出为 5，而方程输出为 18，则损失函数应表示此差值。一个简单的损失函数可以输出 13，这是这些值之间的差值。这表明模型的性能很差。另一方面，如果预期输出为 5，模型预测为 5，则损失函数应输出 0，这表明模型的性能非常出色。
执行此操作的常用损失函数是均方误差 （MSE）：
此函数用于查找模型的预测 （Ŷ ） 和预期输出 （Y ） 之间的差异。然后对差值进行平方，以确保输出始终为正。它跨一组大小为 n 的点执行此操作。通过将所有这些点的平方差相加并除以 n，输出是均方差（误差）。这是一种同时评估模型在所有点上的性能的简单方法。下面可以看到一个简单的例子：
虽然还有无数其他损失函数同样适用于这种情况，但由于其简单性，这是机器学习中回归中最受欢迎的损失函数之一，尤其是在梯度下降方面，这将在后面解释。
为了最好地理解梯度下降的位置，可以评估一个示例。
三、预测最佳拟合线
若要显示操作中的简单线性回归，需要数据来训练模型。这以 X 数组和 Y 数组的形式出现。对于此示例，可以手动生成数据。它可以从"蓝图"函数创建。随机性可以添加到蓝图中，模型将被强制学习底层函数。PyTorch，一个标准的机器学习库，用于实现回归。
3.1 生成数据
首先，下面的代码使用随机整数生成器生成一个输入值数组。X 当前具有 （n 个样本，num 特征） 的形状。请记住，特征是一个自变量，简单线性回归有 1。在本例中，n 将为 20。
ba
import torch
torch.manual_seed(5)
torch.set_printoptions(precision=2)
# (n samples, features)
X = torch.randint(low=0, high=11, size=(20, 1))
ba
tensor([[ 9],
[10],
[ 0],
[ 3],
[ 8],
[ 8],
[ 0],
[ 4],
[ 1],
[ 0],
[ 7],
[ 9],
[ 3],
[ 7],
[ 9],
[ 7],
[ 3],
[10],
[10],
[ 4]])然后可以通过 Y = 1.5X + 2 传递这些值以生成输出值，并且可以使用平均值为 0 且标准差为 1 的正态分布将这些值添加一些随机性。Y 的形状为 （n 个样本 ，1）。
下面的代码显示了具有相同形状的随机值。
ba
torch.manual_seed(5)
# normal distribution with a mean of 0 and std of 1
normal = torch.distributions.Normal(loc=0, scale=1)
normal.sample(X.shape)
ba
tensor([[ 1.84],
[ 0.52],
[-1.71],
[-1.70],
[-0.13],
[-0.60],
[ 0.14],
[-0.15],
[ 2.61],
[-0.43],
[ 0.35],
[-0.06],
[ 1.48],
[ 0.49],
[ 0.25],
[ 1.75],
[ 0.74],
[ 0.03],
[-1.17],
[-1.51]])最后，可以使用下面的代码计算Y。
ba
Y = (1.5*X + 2) + normal.sample(X.shape)
Y
ba
tensor([[15.00],
[15.00],
[-0.36],
[ 6.75],
[13.59],
[15.16],
[ 2.33],
[ 8.72],
[ 2.67],
[ 1.81],
[13.74],
[14.06],
[ 7.15],
[12.81],
[15.91],
[13.15],
[ 6.76],
[18.05],
[18.71],
[ 6.80]])它们也可以与 matplotlib 一起绘制，以便更好地理解它们的关系：
ba
import matplotlib.pyplot as plt
plt.scatter(X,Y)
plt.xlim(-1,11)
plt.ylim(0,20)
plt.xlabel("$X$")
plt.ylabel("$Y$")
plt.show()
虽然为示例生成数据似乎违反直觉，但它是演示回归如何工作的好方法。该模型（如下所示）将仅提供 X 和 Y ，并且需要将 w₁ 标识为 1.5，将 w₀标识为 2。
权重可以存储在数组 w 中。 这个数组中有两个权重，一个用于偏差，一个用于特征的数量。它的形状为 （数字特征 + 1 个偏差，1）。对于此示例，数组的形状为 （2， 1）。
ba
torch.manual_seed(5)
w = torch.rand(size=(2, 1))
w
ba
tensor([[0.83],
[0.13]])生成这些值后，可以创建模型。
3.2 创建模型
模型的第一步是为最佳拟合线定义一个函数，为 MSE 定义另一个函数。
如前所述，该模型的方程为 Ŷ = Xw₁+ w₀。 截至目前，偏差已添加到每个样本中。这相当于将偏差广播为与 X 大小相同并将数组相加。输出如下所示。
ba
w[1]*X + w[0]
ba
tensor([[1.97],
[2.09],
[0.83],
[1.21],
[1.84],
[1.84],
[0.83],
[1.33],
[0.96],
[0.83],
[1.71],
[1.97],
[1.21],
[1.71],
[1.97],
[1.71],
[1.21],
[2.09],
[2.09],
[1.33]])下面的函数计算输出。
ba
# line of best fit
def model(w, X):
"""
Inputs:
w: array of weights | (num features + 1 bias, 1)
X: array of inputs | (n samples, num features + 1 bias)
Output:
returns the predictions | (n samples, 1)
"""
return w[1]*X + w[0]MSE 的功能非常简单：
ba
# mean squared error (MSE)
def MSE(Yhat, Y):
"""
Inputs:
Yhat: array of predictions | (n samples, 1)
Y: array of expected outputs | (n samples, 1)
Output:
returns the loss of the model, which is a scalar
"""
return torch.mean((Yhat-Y)**2) # mean((error)^2)3.3 预览最佳拟合线
创建函数后，可以使用绘图预览最佳拟合线，并且可以创建标准函数以供将来使用。它将以红色显示最佳拟合线，以橙色显示每个输入的预测，以蓝色显示预期输出。
ba
def plot_lbf():
"""
Output:
plots the line of best fit in comparison to the training data
"""
# plot the points
plt.scatter(X,Y)
# predictions for the line of best fit
Yhat = model(w, X)
plt.scatter(X, Yhat, zorder=3) # plot the predictions
# plot the line of best fit
X_plot = torch.arange(-1,11+0.1,.1) # generate values with a step of .1
plt.plot(X_plot, model(w, X_plot), color="red", zorder=0)
plt.xlim(-1, 11)
plt.xlabel("$X$")
plt.ylabel("$Y$")
plt.title(f"MSE: {MSE(Yhat, Y):.2f}")
plt.show()
plot_lbf()
具有当前权重的输出并不理想，因为MSE为105.29。为了获得更好的MSE，需要选择不同的权重。它们可以再次随机化，但获得完美线的机会很小。这是梯度下降算法可用于以定义的方式更改权重值的地方。
3.4 梯度下降
梯度下降算法的解释可以在这里找到：梯度下降的简单介绍。在继续之前应阅读本文以避免混淆。
总结一下这篇文章，梯度下降使用成本函数的梯度来揭示每个权重对其的方向和影响。通过使用学习率缩放梯度并从每个权重的当前值中减去梯度，成本函数最小化，迫使模型的预测尽可能接近预期输出。
对于简单的线性回归，f 将是 MSE。Python 实现可以在下面看到。请记住，每个权重都有自己的偏导数用于公式，如上所示。
ba
# optimizer
def gradient_descent(w):
"""
Inputs:
w: array of weights | (num features + 1 bias, 1)
Global Variables / Constants:
X: array of inputs | (n samples, num features + 1 bias)
Y: array of expected outputs | (n samples, 1)
lr: learning rate to scale the gradient
Output:
returns the updated weights
"""
n = len(X)
# update the bias
w[0] = w[0] - lr*2/n * torch.sum(model(w,X) - Y)
# update the weight
w[1] = w[1] - lr*2/n * torch.sum(X*(model(w,X) - Y))
return w现在，该函数可用于更新权重。学习率是根据经验选择的，但它通常是一个较小的值。还可以绘制最佳拟合的新线。
ba
lr = 0.01
print("weights before:", w.flatten())
print("MSE before:", MSE(model(w,X), Y))
# update the weights
w = gradient_descent(w)
print("weights after:", w.flatten())
print("MSE after:", MSE(model(w,X), Y))
plot_lbf()
ba
weights before: tensor([0.83, 0.13])
MSE before: tensor(105.29)
weights after: tensor([1.01, 1.46])
MSE after: tensor(2.99)
MSE 在第一次尝试时下降了 100 多分，但这条线仍然不能完全符合点数。请记住，目标是将 w₀ 设为 2，将 w₁设为 1.5。为了加快学习过程，可以再执行500次梯度下降，并且可以检查新结果。
ba
# update the weights
for i in range(0, 500):
# update the weights
w = gradient_descent(w)
# print the new values every 10 iterations
if (i+1) % 100 == 0:
print("epoch:", i+1)
print("weights:", w.flatten())
print("MSE:", MSE(model(w,X), Y))
print("="*10)
plot_lbf()
ba
epoch: 100
weights: tensor([1.44, 1.59])
MSE: tensor(1.31)
==========
epoch: 200
weights: tensor([1.67, 1.56])
MSE: tensor(1.25)
==========
epoch: 300
weights: tensor([1.80, 1.54])
MSE: tensor(1.24)
==========
epoch: 400
weights: tensor([1.87, 1.53])
MSE: tensor(1.23)
==========
epoch: 500
weights: tensor([1.91, 1.52])
MSE: tensor(1.23)
==========
500 个时期后，MSE 为 1.23。w₀ 为 1.91，w₁为 1.52。这意味着模型成功识别了最佳拟合线。可以执行其他更新，但添加到输出值的随机性可能会阻止模型实现完美的预测。
为了建立关于梯度下降如何工作的额外直觉，可以通过将它们与其输出 MSE 绘制来检查 w₀ 和 w₁的影响。绘制梯度下降的函数可以在附录中检查，输出可以在下面检查：
ba
torch.manual_seed(5)
w = torch.rand(size=(2, 1))
w0s, w1s, losses = list(),list(),list()
# update the weights
for i in range(0, 500):
if i == 0 or (i+1) % 10 == 0:
w0s.append(float(w[0]))
w1s.append(float(w[1]))
losses.append(MSE(model(w,X), Y))
# update the weights
w = gradient_descent(w)
plot_GD([-2, 5.2], [-2, 5.2])
每个橙色点表示权重的更新，红线表示从一个迭代到下一个迭代的变化。最大的更新是从第一次迭代到第二次迭代，即红线。其他橙色点靠得很近，因为它们的衍生物很小，因此更新更小。该图显示了权重如何更新，直到获得最佳 MSE。
虽然这种方法很有用，但可以通过几种方式简化。首先，它没有利用矩阵乘法，这将简化模型的方程。其次，梯度下降不是回归的闭式解，因为每个问题的 epoch 数和学习率都不同，并且解是近似的。本文的最后一部分将解决第一个问题，下一篇文章将解决第二个问题。
四、另一种方法
虽然这种方法很有用，但它并不像它可能的那么简单。它不利用矩阵。截至目前，整个方程 Ŷ = Xw₁+ w₀ 用于模型的函数，并且必须单独计算每个权重的偏导数以进行梯度下降。通过使用矩阵运算和微积分，这两个函数都简化了。
首先，X 的形状为 （n 个样本，num 特征），w 的形状为 （num 特征 + 1 个偏差，1 ）。通过在 X 中添加额外的列，可以使用矩阵乘法，因为它将具有 ***（n 个样本、num 特征 + 1 个偏差）***的新形状。这可以是一列将乘以偏差的列，这将缩放向量。这相当于广播偏差，这是先前计算预测的方式。
ba
X = torch.hstack((torch.ones(X.shape),X))
X
ba
tensor([[ 1., 9.],
[ 1., 10.],
[ 1., 0.],
[ 1., 3.],
[ 1., 8.],
[ 1., 8.],
[ 1., 0.],
[ 1., 4.],
[ 1., 1.],
[ 1., 0.],
[ 1., 7.],
[ 1., 9.],
[ 1., 3.],
[ 1., 7.],
[ 1., 9.],
[ 1., 7.],
[ 1., 3.],
[ 1., 10.],
[ 1., 10.],
[ 1., 4.]])这会将等式更改为 Ŷ = X₁w₁+ X₀w₀。 展望未来，偏差可以被视为一个特征，因此 num 特征 可以表示自变量和偏差，并且可以省略 + 1 偏差 。因此，X 的大小为 （n 个样本 ，num 特征 ），w 的大小为 （num features ，1 ）。当它们相互相乘时，输出是预测向量，其大小为 （n 个样本，1 ）。矩阵乘法的输出与 相同。w[1]*X + w[0]
ba
torch.manual_seed(5)
w = torch.rand(size=(2, 1))
torch.matmul(X, w)
ba
tensor([[1.97],
[2.09],
[0.83],
[1.21],
[1.84],
[1.84],
[0.83],
[1.33],
[0.96],
[0.83],
[1.71],
[1.97],
[1.21],
[1.71],
[1.97],
[1.71],
[1.21],
[2.09],
[2.09],
[1.33]])考虑到这一点，可以更新模型的功能：
ba
# line of best fit
def model(w, X):
"""
Inputs:
w: array of weights | (num features, 1)
X: array of inputs | (n samples, num features)
Output:
returns the output of X@w | (n samples, 1)
"""
return torch.matmul(X, w)由于不再将每个权重视为单个分量，因此梯度下降算法也可以更新。基于梯度下降的简单介绍，矩阵的梯度下降算法如下：
这可以通过 PyTorch 轻松实现。由于 w 在文章开头被重塑，因此导数的输出需要重新整形以进行减法。
ba
# optimizer
def gradient_descent(w):
"""
Inputs:
w: array of weights | (num features, 1)
Global Variables / Constants:
X: array of inputs | (n samples, num features)
Y: array of expected outputs | (n samples, 1)
lr: learning rate to scale the gradient
Output:
returns the updated weights | (num features, 1)
"""
n = X.shape[0]
return w - (lr * 2/n) * (torch.matmul(-Y.T, X) + torch.matmul(torch.matmul(w.T, X.T), X)).reshape(w.shape)使用 500 个 epoch，可以生成与以前相同的输出：
ba
lr = 0.01
# update the weights
for i in range(0, 501):
# update the weights
w = gradient_descent(w)
# print the new values every 10 iterations
if (i+1) % 100 == 0:
print("epoch:", i+1)
print("weights:", w.flatten())
print("MSE:", MSE(model(w,X), Y))
print("="*10)
ba
epoch: 100
weights: tensor([1.43, 1.59])
MSE: tensor(1.31)
==========
epoch: 200
weights: tensor([1.66, 1.56])
MSE: tensor(1.25)
==========
epoch: 300
weights: tensor([1.79, 1.54])
MSE: tensor(1.24)
==========
epoch: 400
weights: tensor([1.87, 1.53])
MSE: tensor(1.23)
==========
epoch: 500
weights: tensor([1.91, 1.53])
MSE: tensor(1.23)
==========由于这些函数不需要为每个要素手动添加其他变量，因此可用于多元线性回归和多项式回归。
五、结论
下一篇文章将讨论不近似权重的回归闭式解决方案。相反，最小化的值将使用 Python 中的机器学习简介：Python 中回归的正态方程直接计算。
请不要忘记点赞和关注！:)
七、引用
六、附录
绘制梯度下降
此函数利用 Plotly 在三维空间中显示梯度下降。
ba
import plotly.graph_objects as go
import plotly
import plotly.express as px
def plot_GD(w0_range, w1_range):
"""
Inputs:
w0_range: weight range [w0_low, w0_high]
w1_range: weight range [w1_low, w1_high]
Global Variables:
X: array of inputs | (n samples, num features + 1 bias)
Y: array of expected outputs | (n samples, 1)
lr: learning rate to scale the gradient
Output:
prints gradient descent
"""
# generate all the possible weight combinations (w0, w1)
w0_plot, w1_plot = torch.meshgrid(torch.arange(w0_range[0],
w0_range[1],
0.1),
torch.arange(w1_range[0],
w1_range[1],
0.1))
# rearrange into coordinate pairs
w_plot = torch.hstack((w0_plot.reshape(-1,1), w1_plot.reshape(-1,1)))
# calculate the MSE for each pair
mse_plot = [MSE(model(w, X), Y) for w in w_plot]
# plot the data
fig = go.Figure(data=[go.Mesh3d(x=w_plot[:,0],
y=w_plot[:,1],
z=mse_plot,)])
# plot gradient descent on loss function
fig.add_scatter3d(x=w0s,
y=w1s,
z=losses,
marker=dict(size=3,color="orange"),
line=dict(color="red",width=5))
# prepare ranges for plotting
xaxis_range = [w0 + 0.01 if w0 < 0 else w0 - 0.01 for w0 in w0_range]
yaxis_range = [w1 + 0.01 if w1 < 0 else w1 - 0.01 for w1 in w1_range]
fig.update_layout(scene = dict(xaxis_title='w<sub>0</sub>',
yaxis_title='w<sub>1</sub>',
zaxis_title='MSE',
xaxis_range=xaxis_range,
yaxis_range=yaxis_range))
fig.show()