php线性回归算法技巧_Python机械进修算法线性回归

线性回归可能是最常见的算法之一，线性回归是机器学习实践者必须知道的。
这常日是初学者第一次打仗的机器学习算法，理解它的操作办法对付更好地理解它至关主要。

以是，大略地说，让我们来分解一下真正的问题：什么是线性回归？

线性回归是一种有监督的学习算法，旨在采取线性方法来建模因变量和自变量之间的关系。
换句话说，它的目标是拟合一条最好地捕捉数据关系的线性趋势线，并且，从这条线，它可以预测目标值可能是什么。

太好了，我知道它的定义，但它是如何事情的呢？好问题！
为了回答这个问题，让我们逐步理解一下线性回归是如何运作的：

这种拟合直线的方法称为最小二乘法。

如果已经理解的请随意跳过这一部分

线性回归算法如下：

可以简化为：

以下算法将基本完成以下操作：

这是你的目标向量，稍后将用于评估你的数据（稍后将详细先容）。

这是数据的特色，即年事、性别、性别、身高档。
这是算法将实际用于预测的数据。
把稳如何有一个特色0。
这称为截距项，且始终即是1。

这是算法的神奇之处。
所有的特色向量都会乘以这些权重。
这便是所谓的点积。
实际上，你将考试测验为给定的数据集找到这些值的最佳组合。
这便是所谓的优化。

这是从数据中输出的预测向量。
然后，你可以利用本钱函数来评估模型的性能。

这基本上便是用数学表示的全体算法。
现在你该当对线性回归的功能有一个坚实的理解。
但问题是，什么是优化算法？我们如何选择最佳权重？我们如何评估绩效？

本钱函数实质上是一个公式，用来衡量模型的丢失或“本钱”。
如果你曾经参加过任何Kaggle比赛，你可能会碰着过一些。
一些常见的方法包括：

这些函数对付模型演习和开拓是必不可少的，由于它们回答了“我的模型预测新实例的能力如何”这一基本问题？”. 请记住这一点，由于这与我们的下一个主题有关。

优化常日被定义为改进某事物，使其发挥其全部潜力的过程。
这也适用于机器学习。
在ML的天下里，优化实质上是试图为某个数据集找到最佳的参数组合。
这基本上是机器学习的“学习”部分。

我将谈论两种最常见的算法：梯度低落法和标准方程。

梯度低落是一种优化算法，旨在探求函数的最小值。
它通过在梯度的负方向上迭代地采纳步骤来实现这个目标。
在我们的例子中，梯度低落将通过移动函数切线的斜率来不断更新权重。

为了更好地解释梯度低落，让我们看一个大略的例子。
想象一个人在山顶上，他/她想爬到山底。
他们可能会做的是环顾四周，看看该当朝哪个方向迈出一步，以便更快地下来。
然后，他们可能会朝这个方向迈出一步，现在他们离目标更近了。
然而，它们不才降时必须小心，由于它们可能会在某一点卡住，以是我们必须确保相应地选择我们的步长。

同样，梯度低落的目标是最小化函数。
在我们的例子中，这是为了使我们的模型的本钱最小化。
它通过找到函数的切线并朝那个方向移动来实现这一点。
算法“步长”的大小是由已知的学习速率来定义的。
这基本上掌握着我们向下移动的间隔。
利用此参数，我们必须把稳两种情形：

我们还有一个参数，它掌握算法迭代数据集的次数。

从视觉上看，该算法将实行以下操作：

由于此算法对机器学习非常主要，让我们回顾一下它的浸染：

既然已经先容了梯度低落，现在我们来先容标准方程。

如果我们回到我们的例子中，而不是一步一步地往下走，我们将能够立即到达底部。
标准方程便是这样。
它利用线性代数来天生权重，可以在很短的韶光内产生和梯度低落一样好的结果。

这是许多机器学习算法的主要预处理步骤，尤其是那些利用间隔度量和打算（如线性回归和梯度低落）的算法。
它实质上是缩放我们的特色，使它们在相似的范围内。
把它想象成一座屋子，一座屋子的比例模型。
两者的形状是一样的（他们都是屋子），但大小不同（5米！
=500米）。
我们这样做的缘故原由如下：

为了演示这一点，假设我们有三个特色，分别命名为A、B和C：

我们可以清楚地看到，这些特色比缩放之前更具可比性和无偏性。

好吧，现在你一贯在等待的时候；实现！

把稳：所有代码都可以从这个Github repo下载。
但是，我建议你在实行此操作之前先遵照教程，由于这样你将更好地理解你实际在编写什么代码：

https://github.com/Vagif12/ML-Algorithms-From-Scratch/blob/main/Linear%20Regression%20from%20Scratch.ipynb

首先，让我们做一些基本的导入：

import numpy as npimport matplotlib.pyplot as pltfrom sklearn.datasets import load_boston

是的，这便是所有须要导入的了！
我们利用的是numpy作为数学实现，matplotlib用于绘制图形，以及scikitlearn的boston数据集。

# 加载和拆分数据data = load_boston()X,y = data['data'],data['target']

接下来，让我们创建一个定制的train_test_split函数，将我们的数据拆分为一个演习和测试集：

# 拆分演习和测试集def train_test_divide(X,y,test_size=0.3,random_state=42): np.random.seed(random_state) train_size = 1 - test_size arr_rand = np.random.rand(X.shape[0]) split = arr_rand < np.percentile(arr_rand,(100train_size)) X_train = X[split] y_train = y[split] X_test = X[~split] y_test = y[~split] return X_train, X_test, y_train, y_testX_train,X_test,y_train,y_test = train_test_divide(X,y,test_size=0.3,random_state=42)

基本上，我们在进行

我们将实现MSE或均方偏差，一个用于回归任务的常见本钱函数：

def mse(preds,y): m = len(y) return 1/(m) np.sum(np.square((y - preds)))M指的是演习实例的数量yi指的是我们标签向量中的一个实例preds指的是我们的预测

为了编写干净、可重复和高效的代码，并遵守软件开拓实践，我们将创建一个线性回归类：

class LinReg: def __init__(self,X,y): self.X = X self.y = y self.m = len(y) self.bgd = Falsebgd是一个参数，它定义我们是否该当利用批量梯度低落。

现在我们将创建一个方法来添加截距项：

def add_intercept_term(self,X): X = np.insert(X,1,np.ones(X.shape[0:1]),axis=1).copy() return X

这基本上是在我们的特色开始处插入一个列。
它只是为了矩阵乘法。

如果我们不加上这一点，那么我们将迫使超平面通过原点，导致它大幅度倾斜，从而无法精确拟合数据

缩放我们的特色：

def feature_scale(self,X): X = (X - X.mean()) / (X.std()) return X

接下来，我们将随机初始化权重：

def initialise_thetas(self): np.random.seed(42) self.thetas = np.random.rand(self.X.shape[1])

现在，我们将利用以下公式从头开始编写标准方程：

def normal_equation(self): A = np.linalg.inv(np.dot(self.X.T,self.X)) B = np.dot(self.X.T,self.y) thetas = np.dot(A,B) return thetas

基本上，我们将算法分为三个部分：

这便是标准方程！
还不错！
现在，我们将利用以下公式实现批量梯度低落：

def batch_gradient_descent(self,alpha,n_iterations): self.cost_history = [0] (n_iterations) self.n_iterations = n_iterations for i in range(n_iterations): h = np.dot(self.X,self.thetas.T) gradient = alpha (1/self.m) ((h - self.y)).dot(self.X) self.thetas = self.thetas - gradient self.cost_history[i] = mse(np.dot(self.X,self.thetas.T),self.y) return self.thetas

在这里，我们实行以下操作：

让我们定义一个拟合函数来拟合我们的数据：

def fit(self,bgd=False,alpha=0.158,n_iterations=4000): self.X = self.add_intercept_term(self.X) self.X = self.feature_scale(self.X) if bgd == False: self.thetas = self.normal_equation() else: self.bgd = True self.initialise_thetas() self.thetas = self.batch_gradient_descent(alpha,n_iterations)

在这里，我们只须要检讨用户是否须要梯度低落，并相应地实行我们的步骤。

让我们构建一个函数来绘制本钱函数：

def plot_cost_function(self): if self.bgd == True: plt.plot(range((self.n_iterations)),self.cost_history) plt.xlabel('No. of iterations') plt.ylabel('Cost Function') plt.title('Gradient Descent Cost Function Line Plot') plt.show() else: print('Batch Gradient Descent was not used!')

末了一种预测未标记实例的方法：

def predict(self,X_test): self.X_test = X_test.copy() self.X_test = self.add_intercept_term(self.X_test) self.X_test = self.feature_scale(self.X_test) predictions = np.dot(self.X_test,self.thetas.T) return predictions

现在，让我们看看哪个优化产生了更好的结果。
首先，让我们试试梯度低落：

lin_reg_bgd = LinReg(X_train,y_train)lin_reg_bgd.fit(bgd=True)mse(y_test,lin_reg_bgd.predict(X_test))OUT:28.824024414708344

让我们画出我们的函数，看算作本函数是如何减少的：

以是我们可以看到，在大约1000次迭代时，它开始收敛。

现在的标准方程是：

lin_reg_normal = LinReg(X_train,y_train)lin_reg_normal.fit()mse(y_test,lin_reg_normal.predict(X_test))OUT:22.151417764247284

以是我们可以看到，标准方程的性能略优于梯度低落法。
这可能是由于数据集很小，而且我们没有为学习率选择最佳参数。