机器学习算法-线性回归

1.K-近邻算法

（略）

2.线性回归

2.1线性回归简介

1.线性回归应用场景

房价预测
销售额度预测
贷款额度预测

2.什么是线性回归

2.1定义与公式

线性回归(Linear regression)是利用回归方程(函数)对一个或多个自变量(特征值)和因变量(目标值)之间关系进行建模的一种分析方法.

特点:只有一个自变量的情况称为单变量回归,多于一个自变量情况叫做多元回归

通用公式:
$h(w)=w_1x_1+w_2x_2+w_3x_3…+b=w^Tx+b$
其中w,x可以理解为矩阵：
$ParseError: KaTeX parse error: Undefined control sequence: \w at position 43: …trix} b\̲w̲_1\w_2 \end…$

线性回归用矩阵表示举例
$ParseError: KaTeX parse error: Undefined control sequence: \ at position 44: …mes x_1 + x_2=2\̲ ̲ 0 \times x_1 +…$
写成矩阵形式:
$ParseError: KaTeX parse error: Undefined control sequence: \0 at position 24: …egin{matrix}1&1\̲0̲&1\2&1\end{matr…$

2.2线性回归api初步使用

code

from sklearn.linear_model import LinearRegression

# 1.获取数据
X = [[80, 86],
     [82, 80],
     [90, 90],
     [85, 78],
     [86, 82],
     [82, 90],
     [78, 80],
     [92, 94]
     ]
y = [84.2, 80.6, 80.1, 90, 83.2, 86.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]]))

# D:\Python\Python311\python.exe D:\work\pyprj\ml\linser_demo.py
# 线性回归的系数是：
#  [0.41212411 0.13044053]
# 输出预测结果：
#  [90.47473664]

2.3数学:求导

1、常见的函数导数

$$
\begin{array} {|c|l|l|}
\hline
n & \text{公式} & \text{例子} \
\hline
1 & (常数)’=0 & (5)’=0 (10)’=0 \
\hline
2 & (x^a)’=ax^{a-1} & (x^3)’=3x^2 \
\hline
3 & (a^x)’=a^xlna & (2^x)’=2^xln2 \
\hline
4 & (e^x)’=e^x & (e^x)’=e^x\
\hline
5 & (log_ax)’= \frac{1}{xlna} & (log_{10}x)’= \frac{1}{xln10}\
\hline
6 & (lnx)’= \frac{1}{x} & (lnx)’= \frac{1}{x}\
\hline
7 & (sinx)’= cosx & (sinx)’= cosx \
\hline
8 & (cosx)’= -sinx & (cosx)’= -sinx\
\hline
\end{array}
$$

2、导数的四则运算

$ParseError: KaTeX parse error: Undefined control sequence: \ at position 46: …n&\text{公式} \̲ ̲ \hline 1&[u(x)…$

3、练习

$ParseError: KaTeX parse error: Undefined control sequence: \ at position 45: …2x^2+sinx,求f(x)\̲ ̲2.& (e^x+4lnx)’…$

答案：

$$
\begin{aligned}
y’ & =(x^3-2x^2+sinx)’\
& =(x^3)’-(2x^2)’+(sinx)’\
& =3x^2-4x+cosx\
\end{aligned}
$$
$$
(e^x+4lnx)’=(e^x)’+(4lnx)’=e^x+\frac {4} {x}
$$
$$
\begin{aligned}
(sinx \cdot lnx)’& =(sinx)’ \cdot lnx + sinx \cdot (lnx)’\& =cosx \cdot lnx + sinx \cdot \frac {1} {x}
\end{aligned}
$$

$$
(\frac {e^x} {cosx})’=\frac {(e^x)’\cdot cosx-e^x \cdot (cosx)’ } {cos^2(x)}\
=\frac {e^x \cdot cosx – e^x \cdot (-sinx)} {cos^2(x)}
$$

5.
$$
(sin2x)’=cos2x \cdot (2x)’ = 2cos2x
$$

4、矩阵（向量）求导【了解】

参考连接：

https://handwiki.org/wiki/Matrix%20calculus#Matrix-by-scalar

2.4线性回归的损失和优化

1、损失函数

总损失函数定义为：
$ParseError: KaTeX parse error: Undefined control sequence: \ at position 70: …+(h(x_m)-y_m)^2\̲ ̲&=\sum_{i=1}^m(…$

$ParseError: KaTeX parse error: Undefined control sequence: \ at position 37: …y_i为第i个训练样本的真实值\̲ ̲. h(x_i)为第i个训练样…$

2、优化算法

如何区求模型当中的 W，使损失最小？（目的是找到最小损失对应的w值）

线性回归经常使用的两种算法
- 正规方程
- 梯度下降法

2.1 正规方程

2.1.1 什么是正规方程
$W=(X^TX)^{-1}X^Ty$
理解：x为特征值矩阵，y为目标值矩阵。直接求到最好的结果

缺点：当特征过多过复杂时，求解速度太慢并且得不到结果

2.1.3 正规方程的推导

推导方式一：
把该损失函数换成矩阵写法：
$ParseError: KaTeX parse error: Undefined control sequence: \ at position 64: ……+(h(x_m)-y_m)2\̲ ̲&=\sum_{i=1}^m …$
其中y是真实值矩阵，X是特征值矩阵，w是权重矩阵

对其求解关于w的最小值，起止y,X均已知二次函数直接求导，导数为零的位置，即为最少值。
求导

$$
\begin{aligned}
2(Xw-y)_X &=0 & \cdots \cdots(1)\
2(Xw-y)_(XX^T) &=0X^T& \cdots \cdots(2)\
2(Xw-y)*(XX^T)(XX^T)^{-1}&=0XT(XX^T)^{-1} & \cdots \cdots(3)\
2(Xw-y) &=0 &\cdots \cdots(4) \
Xw &=y & \cdots \cdots(5)\
X^TXw &= X^Ty & \cdots \cdots(6)\
(X^TX)^{-1}X^TXw &= (X^TX)^{-1}X^Ty & \cdots \cdots(7)\
w &= (X^TX)^{-1}X^Ty & \cdots \cdots(8)\
\end{aligned}
$$

注：式（1）到式（2）推导过程中，X是m行n列的矩阵，并不能保证其有逆矩阵，但是右乘X转置矩阵把其变为一个方阵。

推导方式二：

2.2 梯度下降（Gradient Descent）

2.2.1 什么是梯度下降

2.2.2 梯度的概念

梯度是微积分中一个很重要的概念

在单变量函数中，梯度其实就是函数的微分，代表函数在某个给定点的斜率

在多变量函数中，梯度是一个向量，向量有方向，梯度的方向指出了函数在给定点的上升最快的方向，梯度的反方向是函数在给定点下降最快的方向。

2.2.4 梯度下降（Gradient Descent）公式
$\theta_{i+1}=\theta_i – a \frac{\vartheta}{\vartheta\theta_i}J(\theta)$

a 是什么含义？
a在梯度下降算法中称作为学习率或者步长，意味着我们可以通过a来控制每一步走的距离，以保证不要步子太大，错过了最低点。同时也要保证不要走得太慢，导致迟迟不能到最低点。
为什么梯度要乘以一个负号

梯度前加一个负号，就意味朝着梯度相反的方向前进。
梯度下降和正规方程的对比

梯度下降	正规方程
需要选择学习率bu	不需要
需要迭代求解	一次运算得出
特征数量较大可以使用	需要计算方程，时间复杂度高O(n3)

3.1 算法选择依据

最小规模数据
- 正规方程：LinearRegression（不能解决拟合问题）
- 岭回归
大规模数据：
- 梯度下降法：SGDRegressor

4、小结

损失函数【知道】
- 最小二乘法
线性回归优化方法【知道】
- 正规方法
- 梯度下降法
正规方程–一蹴而就
- 利用矩阵的逆，转置进行一步求解
- 知识适合样本和特征比较少的情况
梯度下降法–循序渐进
- 梯度的概念
- 单变量-切线
- 多变量-向量
- 梯度下降法中关注的两个参数
- a-步长
- 为何要加负号

2.5 梯度下降方法介绍

1、详解梯度下降算法

1.1 梯度下降的相关概念复习

步长（Learning rate）
特征（feature）
假设函数（hypothesis function)
损失函数（loss function)
- 为了评估模型拟合的好坏，通常用损失函数来度量拟合的程度。损失函数极小化，意味着拟合程度最好，对应的模型参数即为最优参数。
- 在线性回归中，损失函数通常为样本输出和假设函数的差的平方。比如对于m个样本（xi，yi）（i=1,2,…m),采用线性回归，损失函数为:
  $J(\theta_0,\theta_1)=\sum_{i=1}^{m}(h_\theta(x_i)-y_i)^2$
$$

$$

$$
其中x_i表示第i个样本特征，y_i表示第i个样本对应的输出，h\theta(x_i)为假设函数.
$$

1.2 梯度下降法的推导流程

1）先决条件：确认优化模型的假设函数和损失函数

2）算法相关参数初始化

3）算法过程

4）更新所有theta

2、梯度下降法大家族

全梯度下降算法（Full gradient descent）
随即梯度下降算法（Stochastic gradient descent）
小批量梯度下降算啊（Mini-batch gradient descent）
随机平均梯度下降算法（Stochastic average gradient descent）

2.6 线性回归api再介绍

sklearn.linear_model.LinearRegression(fit_intercept=True)
- 通过正规方程优化
- 参数
- fit_intercept:是否计算偏差（截距）
- 属性
- LinearRegression.coef_:回归系数
- LinearRegression。intercept_:偏差（截距）
sklearn.linear_model.SGDRegressor(loss=”squared_loss”,fit_intercept=True,learning_rate=’invscaling’,eta0=0.01)
- SDGRegressor类实现了随即梯度下降学习，它支持不同的loss函数和正则化惩罚项来拟合线性回归模型
- 参数：
- loss:损失类型
  - loss=“squared_loss”:普通最小二乘法
- fit——intercept：是否计算偏差
- learning_rate:string,optional
  - 学习率填充
  - ‘constant’:eta=eta0
  - ‘optimal’:eta=1.0/(alpha*(t+t0) ) [default]
  - power_t=0.25:存在父类当中
  - 对于一个常数值的学习率来说，可以使用learning_rate=’constant’,并使用eta0来指定学习率
- 属性：
  - SDGRegressor.coef_:回归系数
  - SDGRegressor.intercept_: 偏差

2.7 案例：波士顿房价预测

3、回归性能评估

均方误差（Mean Squared Error)（MSE)评价机制：
$ParseError: KaTeX parse error: Undefined control sequence: \ at position 50: …\overline y )^2\̲ ̲注：y^i为预测值，\over…$

sklearn.metrics.mean_squared_error(y_true,y_pred)
- 均方差回归损失
- y_true:真实值
- y_pred:预测值
- return:浮点数结果

4、代码实现

4.1正规方程

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

# def load_boston():
import pandas as pd
import numpy as np

data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]
# boston = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :3]])
# print(d.shape)
# return (data,target)

#导入波士顿数据集
# from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error

# 1、获取数据
def linear_model():
     # 1、获取数据
     # boston = load_boston()
     # print(boston)

     # 2、数据基本处理
     # 2.1 分割数据
     x_train, x_test, y_train, y_test = train_test_split(data, 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)


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

linear_model()

4.2梯度下降法

# 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.linear_model import LinearRegression
from sklearn.linear_model import SGDRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error


# def load_boston():
import pandas as pd
import numpy as np

data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]
# boston = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :3]])
# print(d.shape)
# return (data,target)

#正规方程
def linear_model1():
     # 1、获取数据
     # boston = load_boston()
     # print(boston)

     # 2、数据基本处理
     # 2.1 分割数据
     x_train, x_test, y_train, y_test = train_test_split(data, 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():
     # 1、获取数据
     # boston = load_boston()
     # print(boston)

     # 2、数据基本处理
     # 2.1 分割数据
     x_train, x_test, y_train, y_test = train_test_split(data, 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 = 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()

我们尝试修改学习率

     estimator   = SGDRegressor(max_iter=1000, learning_rate="constant", eta0=0.001)

此时我们可以通过调整参数，找到学习率更好的值。

2.8 欠拟合和过拟合

1、定义

过拟合：一个假设在训练数据上能够获得比其他假设更好的拟合，但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象.(模型过于复杂)
欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象.(模型过于简单)

2、原因以及解决办法

欠拟合原因以及解决办法
- 原因：学习到数据的特征过少
- 解决办法：
- 1）添加其他特征项
- 2）添加多项式特征
过拟合原因以及解决办法
- 原因：原因特征过多，存在一些嘈杂特征，模型过于复杂是因为模型尝试去兼顾各个测试数据点
- 解决办法：
- 1）重新清洗数据，导致过拟合的一个原因也有可能是数据不纯导致
- 2）增大数据的训练量，还有一个原因是训练的数量太少，训练数据占总数的比例过少
- 3）正则化
- 4）减少特征维度，放置维灾难

3、正则化

3.1 什么是正则化

在解决回归过拟合中，我们选择正则化。但是对于机器学习算法如分类算法来说也会出现这样的问题，除了一些算法本身之外（决策树、神经网络），我们更多的也是去自己做特征选择，包括之前说的删除、合并一些特征。

3.2 正则化类别

L2正则化
- 作用：可以使其中一些W的值都很少，都接近于0，削弱某个特征的影像
- 优点：越少的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象
- Ridge回归
L1正则化
- 作用：可以使得其中一些w的值直接维0，删除这个特征的影像
- LASSO回归

2.9 正则化线性模型

1、Ridge Regression（岭回归，又名Tikhonov regularization)

岭回归是线性回归的正则版本，即在原来的线性回归的cost function中添加正则项（regularization term）
$a\sum_{i=1}^n\theta_i^2$
已达到在拟合数据的同时，使模型权重尽可能小的目的，岭回归代价函数：
$J(\theta)=MSE(\theta)+a\sum_{i=1}^n\theta_i^2$
即
$J(\theta)=\frac{1}{m}\sum_{i=1}^m(\theta^T \cdot x^{(i)}-y^{i})^2+a\sum_{i=1}^n\theta_i^2$

a=0: 岭回归退化为线性回归

2、Lasso Regression(Lasso 回归)

Lasso 回归是线性回归的另一种正则化版本，正则项为权值向量的1范数。

Lasso回归的代价函数：
$J(\theta)=MSE(\theta)+a\sum_{i=1}^n|\theta_i|$

$ParseError: KaTeX parse error: Undefined control sequence: \ at position 24: …array}{l} [注意] \̲ ̲. Lasso\ Regres…$

\end {array}

$ParseError: KaTeX parse error: Undefined control sequence: \ at position 85: …\sign(\theta_2)\̲ ̲\vdots\ sign(\t…$

Lasso Regression 有一个重要的性质是：倾向于完全消除不重要的权重。

3、Elastic Net(弹性网络)

弹性网络在岭回归中进行了折中，通过混合比（mix ratio)r进行控制：

r=0：弹性网络变为岭回归
r=1：弹性网络变为Lasso回归

弹性网络的代价函数：
$J(\theta)=MSE(\theta)+ra\sum_{i=1}^n|\theta_i|+\frac{1-r}{2}a\sum_{i=1}^n\theta_i^2$
一般来说，我们应该避免使用朴素线性回归，而应对模型进行一定的正则化处理。

小结：

常用：岭回归
假设只有少部分特征有用的：
- 弹性网络
- Lasso
- 一般来说，弹性网络的使用更为广泛。因为在特征维度高于训练样本数，或者特征是强相关的情况下，Lasso回归的表现不太稳定。
api：

from sklearn.linear_model impmort Ridge, ElasticNet,Lasso

4、Early Stopping

Earling Stopping也是正则化迭代学习的方法之一。

其做法为：在验证错误率达到最小值的时候停止训练。

2.10 线性回归的改进-岭回归

波士顿房价预测实例

code

# 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.linear_model import LinearRegression
from sklearn.linear_model import SGDRegressor,Ridge
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error


# def load_boston():
import pandas as pd
import numpy as np

data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]
# boston = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :3]])
# print(d.shape)
# return (data,target)

#正规方程
def linear_model1():
     # 1、获取数据
     # boston = load_boston()
     # print(boston)

     # 2、数据基本处理
     # 2.1 分割数据
     x_train, x_test, y_train, y_test = train_test_split(data, 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():
     # 1、获取数据
     # boston = load_boston()
     # print(boston)

     # 2、数据基本处理
     # 2.1 分割数据
     x_train, x_test, y_train, y_test = train_test_split(data, 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 = SGDRegressor(max_iter=1000)
     estimator   = SGDRegressor(max_iter=1000, learning_rate="constant", eta0=0.001)
     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():
     # 1、获取数据
     # boston = load_boston()
     # print(boston)

     # 2、数据基本处理
     # 2.1 分割数据
     x_train, x_test, y_train, y_test = train_test_split(data, 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 = SGDRegressor(max_iter=1000)
     # estimator   = SGDRegressor(max_iter=1000, learning_rate="constant", eta0=0.001)
     estimator = Ridge(alpha=1)
     #estimator=RidgeCV(alphas=(0.1,1,10)
     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()
linear_model3()

2.11 模型的保存和加载

code

# coding:utf-8
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import SGDRegressor,Ridge
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error
# from sklearn.externals import joblib
from sklearn.utils import _joblib


import pandas as pd
import numpy as np

data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]

#岭回归
def dump_load():
     # 2、数据基本处理
     # 2.1 分割数据
     x_train, x_test, y_train, y_test = train_test_split(data, target,random_state=10, 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 = SGDRegressor(max_iter=1000)
     # estimator   = SGDRegressor(max_iter=1000, learning_rate="constant", eta0=0.001)
     #
     # estimator = Ridge(alpha=1)
     # #estimator=RidgeCV(alphas=(0.1,1,10)
     # estimator.fit(x_train, y_train)

     # 4.2 模型保存
     # _joblib.dump(estimator,"./test.pkl")

     # # 4.3 模型训练
     estimator = _joblib.load("./test.pkl")

     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()
dump_load()

1.K-近邻算法

2.线性回归

2.1线性回归简介

1.线性回归应用场景

2.什么是线性回归

2.1定义与公式

2.2线性回归api初步使用

code

2.3数学:求导

1、常见的函数导数

2、导数的四则运算

3、练习

4、矩阵（向量）求导【了解】

2.4线性回归的损失和优化

1、损失函数

2、优化算法

2.1 正规方程

2.2 梯度下降（Gradient Descent）

2.5 梯度下降方法介绍

1、详解梯度下降算法

2、梯度下降法大家族

2.6 线性回归api再介绍

2.7 案例：波士顿房价预测

3、回归性能评估

4、代码实现

4.1正规方程

4.2梯度下降法

2.8 欠拟合和过拟合

1、定义

2、原因以及解决办法

3、正则化

3.1 什么是正则化

3.2 正则化类别

2.9 正则化线性模型

1、Ridge Regression（岭回归，又名Tikhonov regularization)

2、Lasso Regression(Lasso 回归)

3、Elastic Net(弹性网络)

4、Early Stopping

2.10 线性回归的改进-岭回归

2.11 模型的保存和加载

发表评论 取消回复

发表评论取消回复