二、技术背景

        这是涵盖回归、梯度下降、分类和机器学习的其他基本方面的系列文章的第一篇文章。本文重点介绍简单的线性回归，它确定了一组点的最佳拟合线，以便进行将来的预测。

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。

import torchtorch.manual_seed(5)
torch.set_printoptions(precision=2)# (n samples, features) 
X = torch.randint(low=0, high=11, size=(20, 1)) 

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）。

        下面的代码显示了具有相同形状的随机值。

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)

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。

Y = (1.5*X + 2) + normal.sample(X.shape)Y

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 一起绘制，以便更好地理解它们的关系：

import matplotlib.pyplot as pltplt.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）。

torch.manual_seed(5)
w = torch.rand(size=(2, 1))
w 

tensor([[0.83],[0.13]])

        生成这些值后，可以创建模型。

3.2 创建模型

        模型的第一步是为最佳拟合线定义一个函数，为 MSE 定义另一个函数。

        如前所述，该模型的方程为 Ŷ = Xw₁+ w₀。 截至目前，偏差已添加到每个样本中。这相当于将偏差广播为与 X 大小相同并将数组相加。输出如下所示。

w[1]*X + w[0]

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]])

        下面的函数计算输出。

# 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 的功能非常简单：

# 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 预览最佳拟合线

        创建函数后，可以使用绘图预览最佳拟合线，并且可以创建标准函数以供将来使用。它将以红色显示最佳拟合线，以橙色显示每个输入的预测，以蓝色显示预期输出。

def plot_lbf():"""Output:plots the line of best fit in comparison to the training data"""# plot the pointsplt.scatter(X,Y)# predictions for the line of best fitYhat = model(w, X)plt.scatter(X, Yhat, zorder=3) # plot the predictions# plot the line of best fitX_plot = torch.arange(-1,11+0.1,.1) # generate values with a step of .1plt.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 实现可以在下面看到。请记住，每个权重都有自己的偏导数用于公式，如上所示。

# 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 gradientOutput:returns the updated weights""" n = len(X)# update the biasw[0] = w[0] - lr*2/n * torch.sum(model(w,X) - Y)# update the weightw[1] = w[1] - lr*2/n * torch.sum(X*(model(w,X) - Y))return w

        现在，该函数可用于更新权重。学习率是根据经验选择的，但它通常是一个较小的值。还可以绘制最佳拟合的新线。

lr = 0.01print("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()

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次梯度下降，并且可以检查新结果。

# update the weights
for i in range(0, 500):# update the weightsw = gradient_descent(w)# print the new values every 10 iterationsif (i+1) % 100 == 0:print("epoch:", i+1)print("weights:", w.flatten())print("MSE:", MSE(model(w,X), Y))print("="*10)plot_lbf()

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₁ 的影响。绘制梯度下降的函数可以在附录中检查，输出可以在下面检查：

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 weightsw = 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 个偏差）的新形状。这可以是一列将乘以偏差的列，这将缩放向量。这相当于广播偏差，这是先前计算预测的方式。

X = torch.hstack((torch.ones(X.shape),X))
X

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]

torch.manual_seed(5)
w = torch.rand(size=(2, 1))torch.matmul(X, w)

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]])

考虑到这一点，可以更新模型的功能：

# 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 在文章开头被重塑，因此导数的输出需要重新整形以进行减法。

# 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 gradientOutput: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，可以生成与以前相同的输出：

lr = 0.01# update the weights
for i in range(0, 501):# update the weightsw = gradient_descent(w)# print the new values every 10 iterationsif (i+1) % 100 == 0:print("epoch:", i+1)print("weights:", w.flatten())print("MSE:", MSE(model(w,X), Y))print("="*10)

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 中回归的正态方程直接计算。

请不要忘记点赞和关注！:)

七、引用

1. plot 3D 绘图

六、附录

绘制梯度下降

此函数利用 Plotly 在三维空间中显示梯度下降。

import plotly.graph_objects as go
import plotly
import plotly.express as pxdef 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 gradientOutput: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 pairsw_plot = torch.hstack((w0_plot.reshape(-1,1), w1_plot.reshape(-1,1)))# calculate the MSE for each pairmse_plot = [MSE(model(w, X), Y) for w in w_plot]# plot the datafig = go.Figure(data=[go.Mesh3d(x=w_plot[:,0], y=w_plot[:,1],z=mse_plot,)])# plot gradient descent on loss functionfig.add_scatter3d(x=w0s, y=w1s, z=losses, marker=dict(size=3,color="orange"),line=dict(color="red",width=5))# prepare ranges for plottingxaxis_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()

 七、参考和引用

1. plot 3D 绘图
2. 亨特·菲利普斯