初始线性回归 - 正规方程 - 梯度下降法 - 岭回归

一、初始线性回归：

1、线性回归的定义：
线性回归（Linear regression)是利用回归方程(函数)对一个或多个自变量(特征值)和因变量(目标值)之间关系进行建模的一种分析方式。
2、通用公式：
h(w) = w1x1 + w2x2 +w3x3 ... + b = （wτ)x + b

通用公式.png

其中：w,x可以理解为矩阵：

image.png

3、线性回归的分类： 线性关系、非线性关系。

4、线性回归API：
sklearn.linear_model.LinearRegression()

• LinearRegression.coef_: 线性回归系数。

5、代码演示🌰：根据学生的平时成绩、期末成绩预测学生的最终成绩。

# coding:utf-8

from sklearn.linear_model import LinearRegression

# 1.获取数据
x = [[80, 86],
     [82, 80],
     [85, 78],
     [90, 90],
     [86, 82],
     [82, 90],
     [78, 80],
     [92, 94]]

y = [84.2, 80.6, 80.1, 90, 83.2, 87.6, 79.4, 93.4]

# 2.模型训练
# 2.1 实例化一个估计器
estimator = LinearRegression()

# 2.2 使用fit方法进行训练
estimator.fit(x, y)

# 打印对应的系数：
print("线性回归的系数是:\n", estimator.coef_)

# 打印的预测结果是：
print("输出预测结果:\n", estimator.predict([[100, 80]]))

6、运行结果：

运行结果：.png

二、导数-求导：

1、常见函数的导数：

常见函数的导数：.png

2、导数的四则运算：

导数的四则运算.png

3、矩阵(向量)求导：

矩阵(向量)求导.png

三、线性回归的损失和优化：

1、损失函数公式：

损失函数公式.png

其中：
（1）yi为第i个训练样本的真实值。
（2）h(xi)为第i个训练样本特征值组合预测函数。
（3）又称最小二乘法。
那么，如何减少这个损失，使我们预测的更加准确些？既然存在这个损失，我们一直说机器学习有自动学习的功能，在线性回归这里是能够体现的。这里可以通过一些优化方法去优化(其实是数学当中的求导功能)回归的总损失！

2、正规方程:利用矩阵的逆，转置进行一步求解，只适合样本和特征比较少的情况。

2.1、代码示范🌰：

# coding:utf-8

"""
# 1.获取数据
# 2.数据基本处理
# 2.1 分割数据
# 3.特征工程-标准化
# 4.机器学习-模型训练-线性回归
# 5.模型评估
"""

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor
from sklearn.metrics import mean_squared_error


def linear_model1():
    """
    线性回归：正规方程
    :return:
    """

    # 1.获取数据
    boston = load_boston()
    print(boston)

    # 2.数据基本处理
    # 2.1 分割数据
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-模型训练-线性回归
    estimator = LinearRegression()
    estimator.fit(x_train, y_train)

    print("这个模型的偏置是:\n", estimator.intercept_)
    print("这个模型的系数是:\n", estimator.coef_)

    # 5.模型评估
    # 5.1 预测值
    y_pre = estimator.predict(x_test)
    print("预测值是:\n", y_pre)

    # 5.2 均方误差
    ret = mean_squared_error(y_test, y_pre)
    print("均方误差:\n", ret)


linear_model1()

2.2、运行结果：

image.png

3、梯度下降(Gradient Descent)：

3.1、基本思想：
梯度下降法可以类比为一个下山的过程。
假设这样一个场景：一个人被困在山上，需要从山上下来(i.e.找到山的最低点，也就是山谷。但此时山上的浓雾很大，导致可视度很低)。因此，下山的路径就无法确定，以他当前的位置为基准寻找这个位置最陡峭的地方，然后朝着山的高度下降的地方走,然后没走一段距离，都反复采用同一个方法，最后就能成功的抵达山谷。

梯度下降法基本思想.png
梯度下降的基本过程就和下山的场景很类似：
首先，我们有一个可微分的函数，这个函数就代表着一座山。
我们的目标就是找到这个函数的最小值，也就是山底。

根据之前的场景假设，最快的下山方式就是找到当前位置最陡峭的方向，然后沿着此方向向下走，对应到函数中，就是找到给定点的梯度，然后朝着梯度相反的方向，就能让函数值下降的最快！因为梯度的方向就是函数值变化最快的方向。所以，我们重复利用这个方法，反复求取梯度，最后就能到达局部最小值，这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向，也就是场景中测量方向的手段。

3.2、梯度的概念：
梯度是微积分中一个很重要的概念。
在单变量的函数中，梯度其实就是函数的微分，代表着函数在某个给定点的切线的斜率；
在多变量函数中，梯度是一个向量，向量有方向，梯度的方向就指出了函数在给定点的上升最快的方向；
这也就说明了为什么我们需要千方百计地求取梯度！我们需要到达山底，就需要在每一步观测到此时最陡峭的地方，梯度就恰好告诉我们这个方向。梯度的方向是函数在给定点上升最快的方向，那么梯度的反方向就是函数在给定点下降最快的方向，这正是我们所需要的。所以我们只要沿着梯度的方向一直走，就能走到局部的最低点。

3.3、梯度下降举例：
（1）单变量函数的梯度下降：
我们假设有一个单变量的函数：J(θ) = θ^2 (其中；θ^2指的是θ的平方 )

函数的微分：J`(θ) = 2θ。

初始化，起点为： θ^0 = 1

学习率： α = 0.4

我们开始进行梯度下降的迭代计算过程：

θ^0 = 1

θ^1 = θ^0 - α * J`(θ^0) = 1 - 0.4 * 2 = 0.2

θ^2 = θ^1 - α * J`(θ^1) = 0.04

θ^3 = θ^2 - α * J`(θ^2) = 0.008

θ^4 = θ^13- α * J`(θ^3) = 0.0016

如图，经过四次的运算，也就是走了四部，基本就抵达了函数的最低点山底了：

梯度下降过程.png

（2）多变量函数的的梯度下降：
假设有一个目标函数：J(θ) = θ1^2 + θ2^2
现在要通过梯度下降法计算这个函数的最小值，我们通过观察不难发现其实就是(0,0)点。但是接下来，我们从梯度下降算法开始一步步计算到这个最小值！我们假设：
初始的起点为：θ^0 = (1, 3)

初始的学习率为：α = 0.1

函数的梯度为：▽:J(θ) =<2θ1, 2θ2)>

进行多次迭代：

θ^0 = (1, 3)

θ^1 = θ^0 - α▽J(θ) = （1, 3） - 0.1(2, 6) = (0.8, 2.4)

θ^2 = θ^1 - α▽J(θ) = (0.8, 2.4) - 0.1(1.6, 4.8) = (0.64, 1.92)

θ^3 = θ^2 - α▽J(θ) = (0.512, 1.536)

θ^4 = θ^3 - α▽J(θ) = (0.4096, 1.2288000000000001)
.
.
.
θ^10 = (0.10737418240000003, 0.32212254720000005)
.
.
.
θ^50 = (1.1417981541647683e-05, 3.425394462494306e-05)
.
.
.
θ^100 = (1.6296287810675902e-10, 4.888886343202771e-10)

我们发现，已经基本靠近函数的最小值点：

多变量函数的梯度下降.png

3.4、梯度下降公式：

梯度下降公式.png
（1）α 在梯度下降算法中被称作 学习率或者步长，控制每一步走的距离，控制步长很重要，不能太小，也不能太大。

（2）α后面的部分决定了梯度下降的方向。

（3）特点：

• 初始点不同，获得的最小值也不同，因此梯度下降求得的只是局部最小值；
• 越接近最小值时，下降速度越慢；

（4）梯度下降法没办法保证走到最小值，可能只是极小值：

梯度下降法可能走到的值.png

3.5、常见的梯度下降法：
(1)、全梯度下降算法(Full gradient descent)：使用所有样本，整个数据集。
(2)、随机梯度下降算法(Stochastic gradient descent),
(3)、小批量梯度下降算法(Mini-batch gradient descent),
(4)、随机平均梯度下降算法(Stochastic average gradient descent)。
它们都是为了正确地调节权重向量没通过为每个权重计算一个梯度，从而更新权值，是目标函数尽可能最小化。其差别在于样本的使用方式不同。

3.6、梯度下降法代码示范🌰：

# coding:utf-8

"""
# 1.获取数据
# 2.数据基本处理
# 2.1 分割数据
# 3.特征工程-标准化
# 4.机器学习-模型训练-线性回归
# 5.模型评估
"""

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor
from sklearn.metrics import mean_squared_error


def linear_model1():
    """
    线性回归：正规方程
    :return:
    """

    # 1.获取数据
    boston = load_boston()
    print(boston)

    # 2.数据基本处理
    # 2.1 分割数据
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-模型训练-线性回归
    estimator = LinearRegression()
    estimator.fit(x_train, y_train)

    print("这个模型的偏置是:\n", estimator.intercept_)
    print("这个模型的系数是:\n", estimator.coef_)

    # 5.模型评估
    # 5.1 预测值
    y_pre = estimator.predict(x_test)
    print("预测值是:\n", y_pre)

    # 5.2 均方误差
    ret = mean_squared_error(y_test, y_pre)
    print("均方误差:\n", ret)


def linear_model2():
    """
    线性回归：梯度下降法
    :return:
    """

    # 1.获取数据
    boston = load_boston()
    print(boston)

    # 2.数据基本处理
    # 2.1 分割数据
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-模型训练-线性回归
    estimator = SGDRegressor(max_iter=1000)
    estimator.fit(x_train, y_train)

    print("这个模型的偏置是:\n", estimator.intercept_)
    print("这个模型的系数是:\n", estimator.coef_)

    # 5.模型评估
    # 5.1 预测值
    y_pre = estimator.predict(x_test)
    print("预测值是:\n", y_pre)

    # 5.2 均方误差
    ret = mean_squared_error(y_test, y_pre)
    print("均方误差:\n", ret)


# linear_model1()
linear_model2()

3.7、运行结果：

梯度下降法运行结果.png

四、线性回归的改进 - 岭回归(Tikhonov regularization)：

1、岭回归是线性回归的正则化版本，即在原来的线性回归的cost function惩罚函数中添加正则项(regularization term):

正则项.png

以达到在你和数据的同时，使模型权重尽可能小的目的，岭回归代价函数：

岭回归代价函数.png

即：

岭回归代价函数.png

2、岭回归API： sklearn.linear_model.Ridge(alpha=1.0,fit_intercept=True, normalize=False)

• 具有l2正则化的线性回归
• alpha：正则化力度，也叫 λ
  λ取值： 0~1 1~10
• solver：会根据数据自动选择优化方法
  sag：如果数据集、特征都比较大，选择该随机梯度下降优化
• normalize：数据是否进行标准化
  normalize=False：可以在fit之前调用preprocessing.StandardScaler标准化
  数据
  normalize=True：默认对数据标准化进行了封装，会自动进行数据标准化
• Ridge.coef：回归权重
• Ridge.intercept: 回归偏置
  注意：Ridge方法相当于SGDRegressor(penalty='l2', loss="squared_loss"),只不过SGDRegressor实现了一个普通的随机梯度下降学习，推荐使用Ridge(实现了SAG)
• sklearn.linear_model.RidgeCV(BaseRidgeCV, RegressorMixin)
  (1) 具有l2正则化的线性回归，可以进行交叉验证
  (2）coef:回归系数

3、正则化程度的变化对结果的影响：

正则化程度的变化对结果的影响.png

• 正则化力度越大，权重系数会越小
• 正则化力度越小，权重系数会越大

4、岭回归代码演示🌰：

# coding:utf-8

"""
# 1.获取数据
# 2.数据基本处理
# 2.1 分割数据
# 3.特征工程-标准化
# 4.机器学习-模型训练-线性回归
# 5.模型评估
"""

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor, RidgeCV, Ridge
from sklearn.metrics import mean_squared_error


def linear_model1():
    """
    线性回归：正规方程
    :return:
    """

    # 1.获取数据
    boston = load_boston()
    # print(boston)

    # 2.数据基本处理
    # 2.1 分割数据
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-模型训练-线性回归
    estimator = LinearRegression()
    estimator.fit(x_train, y_train)

    print("这个模型的偏置是:\n", estimator.intercept_)
    print("这个模型的系数是:\n", estimator.coef_)

    # 5.模型评估
    # 5.1 预测值
    y_pre = estimator.predict(x_test)
    print("预测值是:\n", y_pre)

    # 5.2 均方误差
    ret = mean_squared_error(y_test, y_pre)
    print("均方误差:\n", ret)


def linear_model2():
    """
    线性回归：梯度下降法
    :return:
    """

    # 1.获取数据
    boston = load_boston()
    # print(boston)

    # 2.数据基本处理
    # 2.1 分割数据
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-模型训练-线性回归
    estimator = SGDRegressor(max_iter=1000)
    estimator.fit(x_train, y_train)

    print("这个模型的偏置是:\n", estimator.intercept_)
    print("这个模型的系数是:\n", estimator.coef_)

    # 5.模型评估
    # 5.1 预测值
    y_pre = estimator.predict(x_test)
    print("预测值是:\n", y_pre)

    # 5.2 均方误差
    ret = mean_squared_error(y_test, y_pre)
    print("均方误差:\n", ret)


def linear_model3():
    """
    线性回归：岭回归
    :return:None
    """

    # 1.获取数据
    boston = load_boston()
    # print(boston)

    # 2.数据基本处理
    # 2.1 分割数据
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-模型训练-线性回归
    # estimator = Ridge(alpha=1.0)
    estimator = RidgeCV(alphas=(0.001, 0.01, 0.1, 1, 10, 100))
    estimator.fit(x_train, y_train)

    print("岭回归这个模型的偏置是:\n", estimator.intercept_)
    print("岭回归这个模型的系数是:\n", estimator.coef_)

    # 5.模型评估
    # 5.1 预测值
    y_pre = estimator.predict(x_test)
    print("岭回归预测值是:\n", y_pre)

    # 5.2 均方误差
    ret = mean_squared_error(y_test, y_pre)
    print("岭回归均方误差:\n", ret)


if __name__ == '__main__':
    linear_model1()
    linear_model2()
    linear_model3()

5、岭回归代码运行结果：

岭回归代码运行结果.png

6、可以释放之前注释的代码，并注释掉多余部分，进行多种方法运行结果的简单对比。