算法简介

线性回归是回归算法里最简略的一种算法了。
算法浅显介绍：举个二维平面的比方吧。初中数学里，已知2点能够求一条直线。那么假定给定100个点呢。怎样去求一条直线？一条直线是不可能拟算法工程师需求把握什么合100个点的。过错必定是会有的，那么线性规划的目的便是用一条直线去拟算法导论合这100个点。使得算法工程师需求把握什么总的过错最小。算法规划与剖析
回归一般用来研讨方针和特征之间的线性关系。首要适用于猜测剖析。

算法场景

咱们用代码来结构一下算法的运用场景，首要咱们界说n个点。看看这n个点的分算法布情况。

from sklearn.dataset算法s import load_di算法统宗abetes
import matplotlib.pyplot as plt
import nu算法工程师mpy as np
X = np.arange(0,10,0.05).reshape(-1, 1)
np.random.seed(100)
y = 0.5 * np.a算法规划与剖析range(0,10,0.05) + 3 + np.random.rand(len(X))
plt.s算法的特征catter(X.reshape(1, -1), y)

作用如下图所示：

线性回归--用梯度下降算法求解线性回归

能够看到咱们刻意结构的这n个点，大概是环绕 y=∗x+by = theta * x + b 这根直线散布的。

那么现在有一个问算法导论题来了，假定给定一个新的点，横坐标是x0x_算法0，请猜测纵坐标y0y_0。

算法模型

上一步咱们现已知道了给定了一批点，按照必定的线性规则散布，咱们算法需求用一条直线去拟合这批样本。

首要算法工程师需求把握什么假定样本是环绕着

y^=⋅x+bhat y = theta x + b

这条线散布的。y^hat y 标明猜测值。那么求解线性回归模型的问题，就转化为求算法规划与剖析解参数theta 和 bb。

上一步现已说过，线性回归的方针便是找到这样一条直线，使得所有点的过错最小。为了求解最佳参数，咱们选用什么规范来标明“过错”呢？

咱们现在算法的特征知道某个样本的特征是xix_i。一同样本xix_i对应的方针值yiy_i也是已知的。

咱们用参数theta 和 bb 核算得到猜测值y^ihat y_i:

y^i=⋅x+bhat算法是什么 y_i = theta x + b

然后界说单个点的丢掉

Costi=(y^i−yi)2Cost_i =(hat算法 y_i – y_i)^2

也便是真算法是什么实值和猜测值之间的平方间隔。
那么n个点的过错之和如下：

L=1n∑i=1n(y^i−yi)2L = frac {1} {n} su算法工程师需求把握什么m _{i=1} ^{n} {(hat y_i – y_算法导论i)^2}

把参数代入，得到：

L(,b)=1n∑i=1n(⋅xi+b−yi)2L(theta,b) = frac {1}算法规划与剖析 {n} sum _{i=1} ^{n} (theta x_i + b – y_i)^2

这便是咱们要界说的丢掉函数。
那么现在问题现已转化为

(∗,b∗)=argmin⁡(,b)∑i=1n(⋅xi+b−yi)2(theta^*, b^*) = arg m算法工程师in _{(theta, b)} sum _{i=1}算法规划与剖析 ^{算法是什么n} (theta x_i + b – y_i)^2

也便是求解 theta 和 ${b} 使得丢掉函数具有最小值。

模型求解

线性回归模型有2种常见的求解方法：算法的时刻复杂度是指什么（1）最小二乘算法工程师需求把握什么法 （2）梯度下降算法。

最小二乘法求解简略，思路是核算L对和bL 对 theta 和 b 的到导数，使得式子为0。这时候式子具有最小值。详细细节暂算法是什么不评论。

由于梯度下降算法具有更广泛的运用场景，咱们这儿也选用梯度下降算法求解。

梯度下降算法求解线性回归的进程：

（1）初始化 theta 和 bb 为不等于0的很小的值。

（2）用当时的 theta 和 bb 求解猜测值 y^hat y。

（3）假定 猜测值 y^算法的时刻复杂度是指什么hat y 和 实践值 猜测值 yy 的过错大于 epsilon，跳到（4）；假定 猜测值 y^算法规划与剖析hat y 和 实践值 猜测值 y算法的特征y 的过错小于 epsilon，回来当时的theta 和 bb。求解结束。
（4）求解丢掉函数的偏导数，更新参数theta 和 bb：

←−∂L∂the算法统宗ta leftarrow theta – eta frac {partial L} {partial theta}
b←b−∂L∂bb leftarrow b – eta frac算法开始 {partia算法统宗l L} {partial b}

自己完成梯度下降算法

class LinearRegression:
def __init__(算法的特征self, eta=0.02, n_iters = 1e4, epsilon = 1e-3):
self._theta = None
self._eta = eta
self._n_iters =算法开始 n_iters
self._epsilon = epsilon算法导论
def Cost(self, theta, X_b, y):
try:
return np.s算法开始um(np.square(y - X_b.dot(theta))) / len(X_算法工程师b)
except:
return float('inf')算法统宗
def dCost(self, theta, X_b, y):
return (X_b.dot算法工程师(theta) - y).dot(X_b) * 2 / len(X_b)
def gradient_descent(self, X_b, y, ini算法tial_theta, eta, n_iters, epsilon):
th算法工程师需求把握什么eta = initial_theta
eta = self._eta
n_iters = self._n_iters
epsilon = self._epsilon
i_iter = 0
try:
while i_iter < n_iters:
gradient = self.dCost(theta, X_b, y)
last_t算法工程师heta = theta
theta = theta - eta * gradient
diff = abs(self.Cost(theta,算法工程师 X_b, y) - self.Cost(last_theta, X_b算法的特征, y))
if (diff > 1e100):
print('eta is too large!')
br算法统宗eak
if (diff  < ep算法统宗silon):
break
i_iter += 1
self._theta = theta
ex算法cept:
self._theta = float('算法是什么inf')
return self
def fit(self, X_train, y_train):
assert X_train.shape[0] == y_train.shape[0], 'tra算法开始in data has wrong dimenssion'
self._X_train = X_train
self._y_train = y_train
X_b = np.hstack([np.ones((len(self._X_train), 1)), self._X_train])
initial_theta = np.zeros(X_b.shape[1])
eta = 0.01
self.gradient_descent(X_b, y_train, initial_theta, self._eta, self._n_iters, self._epsilon)
return self
def predict(self, X_test):
X_b = np.hstack算法与数据结构([np.ones((len(X_test), 1)), X_test])
return np.dot(X_b, self.算法的特征_theta)

上述代码算法工程师保存为独立文件，之后就能够引证并且调用了。
留神
咱们模型中的

X_train=[X_train[0][0]X_train[0][1]X_tra算法工程师需求把握什么in[0][2]…X_train[0][m]X_train[1][0]X_算法统宗train[1][1]X算法开始_train[1][2]算法开始…X_train[1][m]…X_train[n][0]X_train[0][1]X_train[0][2算法统宗]..算法工程师需求把握什么.X_train[n][m]]X_train = left [ begin{matrix} X_t算法是什么rain[0][0] & X_train[0][1] & X_train[0][2] & …算法 & X_train[0][m] X_train[1][0] & X_train[1][1] & X_train[1][2] & … & X_train[1][m] … X_train[n][0] & X_train[0][1] & X算法开始_train[0][2] & … & X_train[n][m] end{matrix} right]

对应代码中的

X_b=[1X_算法工程师train[0][0]X_t算法的时刻复杂度是指什么rain[0][1]X_train[0][2算法的时刻复杂度是指什么]…X_train[0][m]1X_train[1][0]X_train[1][1]X_train[1][2]…X_train[1][m]…1X_train[n][0]X_train[0][1]X_train[0][2]…X_train[n][m]]X_b = left [ begin{matrix} 1 & X_train[0][0] & X_train[0][1] & X_算法工程师需求把握什么train[0][2] & … & X_算法是什么train[0][m] 1 & X_train[1][0] & X_train[1][1] & X_train[1][2] & … & X_train[1][m] … 1 & X_算法导论train[n][0] & X_train[0][1] &算法开始 X_train[0][2] &amp算法是什么; … & X_train[n][m] end{matrix} right]

在咱们的算法的时刻复杂度是指什么单特征的模型里,其实便是：

X_b=[1X_train[0]1X_train[1]…1X_train[n]]X_b = le算法统宗ft [begin{matrix} 1 & X_train[0] 1 & X_train[1] … 1 & X_train[n] end{matrix} right]
_theta=[b]_theta = left [begin{matrix} b & theta end{mat算法的特征rix} right]

经过矩阵运算后，能够发现

X_train⋅+b==X_b⋅_thetaX_train theta + b == X_b _theta

等式左边是模算法与数据结构型中的标明，等式右边是代码中的标明，这样做是为了便当矩阵运算。

调用自己写的线性规划模型

linear_regress算法导论ion = LinearRegression(
epsilon = 1e-6,
eta = 0.02
)
linear_regres算法开始sion.算法导论fit(X_train, y_train)
y_predict = lin算法统宗ear_reg算法开始ression.predict(X_test)
params = linear算法的特征_regression._theta

作用如下：

array([3.454算法的时刻复杂度是指什么02算法工程师需求把握什么168, 0.51257892])

也便是说,算法求解得到：

=0.51257892theta = 0.5125789算法统宗2
b=3.45402168b = 3.45402168

其实和开始结构这一批样本时的散布曲线是很接近的。
咱们把点和直线画在同一个图里，看看作用吧：

plt.scatter(X.reshape(1, -1), y)
theta = params[1]
b =算法开始 params[算法的特征0]
X = np.arange(0,10,0.05).reshape(-1, 1)
y_predict = theta * X + b
plt.scatter(X, y_predict)

作用如下图：

线性回归--用梯度下降算法求解线性回归

其完成已很好的拟合了这一批样本了。

留神：

eta的取值必定要恰当，值太算法统宗小，作用就收敛太慢了。在给定迭代次数运转结束后，还没有收敛到咱们想要的值；假定太大了，不光不会收敛，还会发生爆炸式的发散。

epsilon是咱们给定的过错规模，当过错epsilon小于必算法的特征定值得时候，咱们以为直线现已满意拟合的精确度了。

调用sklearn中的线性规划模型

接算法规划与剖析下来咱们再调用s算法开始klearn中的模型看看作用：

from sklearn.linea算法工程师需求把握什么r_model import LinearRegression
linear_reg算法ression = LinearRegression()
linear_regression.fit(X_train, y_train)
y_predict = linear_r算法统宗egression.predict(X_test)
linear_regression.coef_, linear_regression.interc算法ept_算法统宗

作用如下：

(array([0.51042252]), 3.4682654875517605)

也便是说,算法的时刻复杂度是指什么经过sk算法导论learn中的线性模型，算法导论求解得到：

=0.51042252theta = 0.51042252
b=3.46826548755176算法导论05b = 3.4682654875517605

看个拟合图：

线性回归--用梯度下降算法求解线性回归

发现作用是肉眼不可见的不同。

调用sklearn中的线性规划模型时，咱们并没有设算法与数据结构定详细参数，运用了默许参算法是什么数。
发现经过咱们自己模型得到的作用算法与数据结构，和sklearn中算法导论的模型不同仍是很小的，有必定过错，是由于两个模型的可选参数算法工程师需求把握什么取值不一致。
假定各种参数取值相同，信赖作用也会愈加接近。

总结

线性算法开始规划是比较简单了解的算法。本文只介绍了梯度下降算法，对最算法开始小二乘法感兴算法的特征趣的同学，能够自行研讨。