Python -10

多项式回归

多项式回归

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

#原始数据

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

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

#线性回归拟合,拟合效果不好

reg = LinearRegression()
reg.fit(X,y)
y_predict = reg.predict(X)
plt.scatter(x,y)
plt.plot(x,y_predict,color=‘r’)
plt.show()

#手工实现多项式回归，效果好

X2 = np.hstack((X,X ** 2))
reg2 = LinearRegression()
reg2.fit(X2,y)
y_predict2 = reg2.predict(X2)
plt.scatter(x,y)
plt.plot(np.sort(x),y_predict2[np.argsort(x)],color=‘r’)
plt.show()

​ scikit-learn实现多项式回归
扩展：样本中含有多个特征的多项式回归
Pipeline
作用：将多个 *** 作构建为一个“工作流”
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()

过拟合与欠拟合
过拟合(overfitting)：算法所训练的模型过多地表达了数据间的噪音关系
欠拟合(underfitting)：算法所训练的模型不能完整表述数据关系

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler

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(size=100)

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

#观察使用线性回归的MSE

lin_reg = LinearRegression()
lin_reg.fit(X, y)
lin_reg.score(X, y) # 预测准确率

y_predict = lin_reg.predict(X)
plt.scatter(x, y)
plt.plot(x, y_predict, color=‘r’)
plt.show()
mean_squared_error(y, y_predict) # 查看MSE

#观察使用多项式回归的MSE

poly_reg =
Pipeline([
(“poly”, PolynomialFeatures(degree=2)),
(“std_scaler”, StandardScaler()),
(“lin_reg”, LinearRegression())
])
poly_reg.fit(X, y)
y_predict2 = poly_reg.predict(X)
mean_squared_error(y, y_predict2)

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

#PolynomialFeatures的degree参数值设置为更大的值(过分拟合）

poly_reg100 = Pipeline([
(“poly”, PolynomialFeatures(degree=100)),
(“std_scaler”, StandardScaler()),
(“lin_reg”, LinearRegression())
])

poly_reg100.fit(X, y)
y_predict100 = poly_reg100.predict(X)
mean_squared_error(y, y_predict100)
plt.scatter(x, y)
plt.plot(np.sort(x), y_predict100[np.argsort(x)], color=‘r’)
plt.show()

#欠拟合

pipe_line = polynomial_regression(1) # 多项式的最高次数为1
pipe_line.fit(X,y)
y_predict = pipe_line.predict(X)
plt.scatter(x,y)
plt.plot(np.sort(x),y_predict[np.argsort(x)],color=‘r’)
plt.show()

模型的泛化

模型越复杂，测试集的准确率越低

交叉验证与模型正则化

交叉验证
交叉验证是一种模型选择方法，它随机地将数据集切分成三部分，分别为训练集(training set)、验证集(validation set)和测试集(test set)。训练集用来训练模型，验证集用于模型的选择，测试集用于最终对学习方法的评估。

K折交叉验证：
首先随机地将已给数据切分为k个互不相交的大小相同的子集；然后利用K-1个子集的数据训练模型，利用余下的子集测试模型；将这一过程对可能的K种选择重复进行；最后选出K次评测中平均测试误差最小的模型。

留一交叉验证；
K折交叉验证的特殊情形是K=N，这里N是给定数据集的容量。

留一法不受随机样本划分方式的影响，最接近模型真正的性能指标。因为N个样本只有唯一的方式划分为N个子集——每个子集包含一个样本。
缺点：计算量巨大import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

digits = datasets.load_digits()
X = digits.data
y = digits.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=666)

knn = KNeighborsClassifier()
cross_val_score(knn,X_train,y_train) # 返回k个模型的分数

#交叉验证搜索最佳超参数组合

best_score,best_k,best_p = 0,0,0
for k in range(1,11): # 搜索KNN中的K个数
for p in range(1,6): # 搜索p参数
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_score,best_k,best_p = score,k,p

print(“best_k=”,best_k)
print(“best_p=”,best_p)
print(“best_score=”,best_score)

#测试数据集进行模型性能的评估

kcf = KNeighborsClassifier(weights=“distance”,n_neighbors=5,p=3)
kcf.fit(X_train,y_train)
kcf.score(X_test,y_test) # 测试数据集终于上场了，它用来对模型最终评估

knn2 = KNeighborsClassifier()
cross_val_score(knn2,X_train,y_train,cv=5) # 返回k个模型的分数,k由参数cv决定，默认为3

模型正则化
模型选择的另一种典型方法。是在经验风险上加一个正则化项或罚项。目的是通过限制参数的大小，以选择合适的模型。

方法：岭回归

LASSO回归

岭回归与LASSO回归

偏差与方差的权衡
模型误差=偏差+方差+无法避免的误差
高偏差的表现：模型不能有效预测结果

导致高偏差的主要原因：
对问题本身的假设不正确.eg:非线性数据使用了线性回归；欠拟合；使用无关特征
高方差的表现：数据的轻微扰动都会较大地影响模型。即：模型学习了很多噪音，而不是核心实质
导致高方差的主要原因：
使用的模型过于复杂
如何解决过拟合问题(也就是模型具有高方差的问题)？

1. 降低模型的复杂度；
2. 降低“噪音”
3. 增加样本数
4. 使用验证集
5. 模型正则化

岭回归

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)

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

from sklearn.pipeline import Pipeline
from sklearn.linear_model import Ridge
from sklearn.preprocessing import StandardScaler,PolynomialFeatures

def RidgeRegression(degree, alpha):
return Pipeline([
(“poly”, PolynomialFeatures(degree=degree)),
(“std_scaler”, StandardScaler()),
(“ridge_reg”, Ridge(alpha=alpha))
])

pipe_line = ridge_regression(20,0.1)
pipe_line.fit(X,y)
y_predict = pipe_line.predict(X)
plt.scatter(x, y)
plt.plot(np.sort(x),y_predict[np.argsort(x)],color=‘r’)
plt.show()

LASSO回归
Least Absolute Shrinkage and Selection Operator Regression，最小绝对值收缩和选择算子回归
LASSO趋向于使得一部分theta值变为0，所以可以作为特征选择用

from sklearn.pipeline import Pipeline
from sklearn.linear_model import Lasso
from sklearn.preprocessing import StandardScaler,PolynomialFeatures

def lasso_regression(degree,alpha):
return Pipeline([
(“poly”,PolynomialFeatures(degree=degree)),
(“std”,StandardScaler()),
(“ridge”,Lasso(alpha=alpha))
])

pipe_line = lasso_regression(20,0.1)
pipe_line.fit(X,y)
y_predict = pipe_line.predict(X)
plt.scatter(x, y)
plt.plot(np.sort(x),y_predict[np.argsort(x)],color=‘r’)
plt.show()