05机器学习--多项式回归与模型泛化及python实现

目录

①什么是多项式回归

②scikit-learn中的多项式回归和Pipelin

③过拟合与欠拟合

④验证数据集与交叉验证

⑤回顾网格搜索

⑥偏差方差权衡

⑦解决过拟合问题--模型正则化1--岭回归

⑧解决过拟合问题--模型正则化2--LASSO回归 

---

①什么是多项式回归

我们把看做是这个式子的一个特征，x为另外一个特征，从这个角度来看，这个式子其实还是一个线性回归；但是单从x的角度来说，这是一个非线性方程，这就是多项式回归；相当于我们为我们的样本多增加了特征，但是这个特征就是我们样本原来样本的多项式项 ，用线性回归的思路更好的拟合原来的数据，但是本质上求出来的是非线性曲线，对数据集升维

import numpy as np
import matplotlib.pyplot as plt

x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, 100)

plt.scatter(x, y)
plt.show()

结果输出：

首先用线性回归拟合一下

import numpy as np
import matplotlib.pyplot as plt

x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, 100)

# plt.scatter(x, y)
# plt.show()

from sklearn.linear_model import LinearRegression

lin_reg = LinearRegression()
lin_reg.fit(X, y)
y_predict = lin_reg.predict(X)

plt.scatter(x, y)
plt.plot(x, y_predict, color='r')
plt.show()

结果输出：

 改进一下，多项式回归（添加一个特征）

import numpy as np
import matplotlib.pyplot as plt

x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, 100)

# plt.scatter(x, y)
# plt.show()

from sklearn.linear_model import LinearRegression

lin_reg = LinearRegression()
lin_reg.fit(X, y)
y_predict = lin_reg.predict(X)

# plt.scatter(x, y)
# plt.plot(x, y_predict, color='r')
# plt.show()

X2 = np.hstack([X, X**2])

lin_reg2 = LinearRegression()
lin_reg2.fit(X2, y)
y_predict2 = lin_reg2.predict(X2)

plt.scatter(x, y)
plt.plot(np.sort(x), y_predict2[np.argsort(x)], color='r')
plt.show()

结果输出：

②scikit-learn中的多项式回归和Pipelin

import numpy as np
import matplotlib.pyplot as plt

x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, 100)

from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=2)  # 为原本的数据集添加最多几次幂的特征
poly.fit(X)
X2 = poly.transform(X)  # 转换为多项式特征，有三列，从0次幂一直到2次幂

from sklearn.linear_model import LinearRegression
lin_reg2 = LinearRegression()
lin_reg2.fit(X2, y)
y_predict2 = lin_reg2.predict(X2)

plt.scatter(x, y)
plt.plot(np.sort(x), y_predict2[np.argsort(x)], color='r')
plt.show()

结果输出：

关于PolynomialFeatures

本身有两个特征，升维到3个特征时

PolynomialFeatures(degree=3)时，最终会生成十列（0次幂、1次幂、2次幂、3次幂）

Pipeline方法：（没有专门的多项式回归类，用这个方法可以简单的创建自己的多项式回归类）

import numpy as np
import matplotlib.pyplot as plt

x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, 100)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

poly_reg = Pipeline([                        # 按着每一个步骤依次进行
    ("poly", PolynomialFeatures(degree=2)),  # 多项式特征
    ("std_scaler", StandardScaler()),  # 数据归一化
    ("lin_reg", LinearRegression())  # 回归
])

poly_reg.fit(X, y)
y_predict = poly_reg.predict(X)

plt.scatter(x, y)
plt.plot(np.sort(x), y_predict[np.argsort(x)], color='r')
plt.show()

结果输出：

③过拟合与欠拟合

看一个夸张的例子，给上面的数据增加特征到100个

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error

np.random.seed(666)
x = np.random.uniform(-3.0, 3.0, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, size=100)

# 使用多项式回归
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

def PolynomialRegression(degree):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("lin_reg", LinearRegression())
    ])

poly100_reg = PolynomialRegression(degree=100)
poly100_reg.fit(X, y)

y100_predict = poly100_reg.predict(X)
mean_squared_error(y, y100_predict)

plt.scatter(x, y)
plt.plot(np.sort(x), y100_predict[np.argsort(x)], color='r')
plt.show()

结果输出：（过拟合，个人理解：他在你给定的数据集上拟合很完美，但是预测的效果会差很多）

欠拟合：算法所训练的模型不能完整的表述数据关系

过拟合：算法所训练的模型过多的表达了数据间的噪音关系

泛化能力：根据训练数据得到上面的曲线，但是他在预测新的数据的时候，其实准确率很差，也说他泛化能力很差。

我们真正需要的是模型的泛化能力很好。

训练数据集与测试数据集的目的就是为了解决泛化能力不强的问题

④验证数据集与交叉验证

问题：对测试数据集过拟合了怎么办？我们一直都在针对测试集进行调参

解决方法：

数据集分为训练集、验证集（测试模型效果）、测试集（不参与模型的创建过程、模拟未知数据）

测试数据集衡量模型最终效能，验证集用来调参

问题：过拟合验证集怎么办？

解决方法：

交叉验证，把训练集分成k份，让k份数据分别去做验证集，剩下的就当做训练集，每一种组合都可以得到一个模型，把所有模型的性能平均值作为最终的新能结果，之后在判断是否调参

import numpy as np
from sklearn import datasets
# 手写识别数据集
digits = datasets.load_digits()
X = digits.data
y = digits.target
# 划分训练集测试集的方法
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=666)
# 观察kNN的效果
from sklearn.neighbors import KNeighborsClassifier

best_k, best_p, best_score = 0, 0, 0
for k in range(2, 11):
    for p in range(1, 6):
        knn_clf = KNeighborsClassifier(weights="distance", n_neighbors=k, p=p)
        knn_clf.fit(X_train, y_train)
        score = knn_clf.score(X_test, y_test)
        if score > best_score:
            best_k, best_p, best_score = k, p, score
print("训练集与测试集的效果：")
print("Best K =", best_k)
print("Best P =", best_p)
print("Best Score =", best_score)

# 交叉验证的方法
from sklearn.model_selection import cross_val_score  # 默认分成五份交叉验证  
                                            # 手动限制的话可以添加参数cv比如cv=5分成五份

knn_clf = KNeighborsClassifier()
cross_val_score(knn_clf, X_train, y_train)
# 观察kNN的效果
best_k, best_p, best_score = 0, 0, 0
for k in range(2, 11):
    for p in range(1, 6):
        knn_clf = KNeighborsClassifier(weights="distance", n_neighbors=k, p=p)
        scores = cross_val_score(knn_clf, X_train, y_train)  # 每一次的分数
        score = np.mean(scores)  # 取均值
        if score > best_score:
            best_k, best_p, best_score = k, p, score
print("交叉验证的效果：")
print("Best K =", best_k)
print("Best P =", best_p)
print("Best Score =", best_score)

结果输出：

两个方法的结果有区别，但是我们更相信交叉验证的结果，交叉验证通常不会过拟合某一组数据，所以平均来讲分数会低一些 

⑤回顾网格搜索

网格搜索的本质就是交叉验证调参

import numpy as np
from sklearn import datasets
# 手写识别数据集
digits = datasets.load_digits()
X = digits.data
y = digits.target
# 划分训练集测试集的方法
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=666)

from sklearn.neighbors import KNeighborsClassifier

# 交叉验证的方法
from sklearn.model_selection import cross_val_score

knn_clf = KNeighborsClassifier()
cross_val_score(knn_clf, X_train, y_train)
# 网格搜索
from sklearn.model_selection import GridSearchCV  # CV就是交叉验证的意思

param_grid = [
    {
        'weights': ['distance'],
        'n_neighbors': [i for i in range(2, 11)],
        'p': [i for i in range(1, 6)]               # 5 * 9 = 45组参数，每组分成5份
    }
]

grid_search = GridSearchCV(knn_clf, param_grid, verbose=1)
grid_search.fit(X_train, y_train)

print(grid_search.best_score_)  # 最佳分数
print(grid_search.best_params_)  # 最佳参数

best_knn_clf = grid_search.best_estimator_  # 最佳参数对应的最佳分类器
print(best_knn_clf.score(X_test, y_test))

结果输出：

交叉验证的缺点是比较慢，但是最终找到的参数比较信赖，极端情况：留一法（LOO-CV），训练数据集有几个样本就分成几份，训练m-1份，留1份进行验证，缺点是计算量巨大（一般不使用） 

⑥偏差方差权衡

左下角就是偏差，右上角就是方差，上面一组就是低偏差，下面一组就是高偏差，左边一组就是低方差，右边一组就是高方差

模型误差：偏差+方差+不可避免的误差（不可避免）

高偏差：比如欠拟合 

高方差：比如模型太过复杂，kNN天生就是高方差（对数据特别敏感），参数学习一般都是高方差，一般可以减少数据维度，降噪，增加数据规模解决

两者一般是相互矛盾的，需要取一个权衡

⑦解决过拟合问题--模型正则化1--岭回归

思路：限制系数的大小（像上面过拟合的那个例子，会发现拟合的曲线非常弯曲，所以每一个特征的系数都会很大）

解决方法：改变损失函数

优化后，需要考虑让每theta尽可能小 ，阿尔法表示权重，不同的数据取值不同

岭回归实现

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(42)
x = np.random.uniform(-3.0, 3.0, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x + 3 + np.random.normal(0, 1, size=100)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression


def PolynomialRegression(degree):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("lin_reg", LinearRegression())
    ])


from sklearn.model_selection import train_test_split

np.random.seed(666)
X_train, X_test, y_train, y_test = train_test_split(X, y)

from sklearn.metrics import mean_squared_error

poly_reg = PolynomialRegression(degree=20)
poly_reg.fit(X_train, y_train)

y_poly_predict = poly_reg.predict(X_test)
print('均方误差')
print(mean_squared_error(y_test, y_poly_predict))  # 均方误差，显然过拟合了

X_plot = np.linspace(-3, 3, 100).reshape(100, 1)
y_plot = poly_reg.predict(X_plot)


# 封装绘制函数
def plot_model(model):
    X_plot = np.linspace(-3, 3, 100).reshape(100, 1)
    y_plot = model.predict(X_plot)

    plt.scatter(x, y)
    plt.plot(X_plot[:, 0], y_plot, color='r')
    plt.axis([-3, 3, 0, 6])
    plt.show()


plot_model(poly_reg)

# 岭回归
from sklearn.linear_model import Ridge


def RidgeRegression(degree, alpha):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("ridge_reg", Ridge(alpha=alpha))  # 比重
    ])


ridge1_reg = RidgeRegression(20, 0.0001)
ridge1_reg.fit(X_train, y_train)

y1_predict = ridge1_reg.predict(X_test)
print('岭回归均方误差')
print(mean_squared_error(y_test, y1_predict))

plot_model(ridge1_reg)

# 调整alpha
ridge2_reg = RidgeRegression(20, 1)
ridge2_reg.fit(X_train, y_train)

y2_predict = ridge2_reg.predict(X_test)
print('岭回归均方误差')
print(mean_squared_error(y_test, y2_predict))

plot_model(ridge2_reg)
# 再调整alpha
ridge3_reg = RidgeRegression(20, 100)
ridge3_reg.fit(X_train, y_train)

y3_predict = ridge3_reg.predict(X_test)
print('岭回归均方误差')
print(mean_squared_error(y_test, y3_predict))

plot_model(ridge3_reg)

结果输出：

过拟合情况

岭回归

提高比重

 在提高比重

⑧解决过拟合问题--模型正则化2--LASSO回归 

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(42)
x = np.random.uniform(-3.0, 3.0, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x + 3 + np.random.normal(0, 1, size=100)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression


def PolynomialRegression(degree):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("lin_reg", LinearRegression())
    ])


from sklearn.model_selection import train_test_split

np.random.seed(666)
X_train, X_test, y_train, y_test = train_test_split(X, y)

from sklearn.metrics import mean_squared_error

poly_reg = PolynomialRegression(degree=20)
poly_reg.fit(X_train, y_train)

y_poly_predict = poly_reg.predict(X_test)
print('均方误差')
print(mean_squared_error(y_test, y_poly_predict))  # 均方误差，显然过拟合了

X_plot = np.linspace(-3, 3, 100).reshape(100, 1)
y_plot = poly_reg.predict(X_plot)


# 封装绘制函数
def plot_model(model):
    X_plot = np.linspace(-3, 3, 100).reshape(100, 1)
    y_plot = model.predict(X_plot)

    plt.scatter(x, y)
    plt.plot(X_plot[:, 0], y_plot, color='r')
    plt.axis([-3, 3, 0, 6])
    plt.show()


plot_model(poly_reg)

# LASSO回归
from sklearn.linear_model import Lasso

def LassoRegression(degree, alpha):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("lasso_reg", Lasso(alpha=alpha))
    ])

lasso1_reg = LassoRegression(20, 0.01)
lasso1_reg.fit(X_train, y_train)

y1_predict = lasso1_reg.predict(X_test)
print('LASSO回归均方误差')
print(mean_squared_error(y_test, y1_predict))

plot_model(lasso1_reg)

 LASSO回归输出：

了解：LASSO回归趋向于使一部分theta为0（相当于选择了一些特征），可以当做特征选择用， 可能错误的忽略掉一些有用的特征，还是岭回归更可靠一些

 扩展：

 L0正则：希望theta的个数尽量小

d性网：