机器学习 | 多项式回归处理非线性问题

sklearn.preprocessing.PolynomialFeatures (degree=2, interaction_only=False, include_bias=True)

>>> from sklearn.preprocessing import PolynomialFeatures
>>> import numpy as np
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> poly = PolynomialFeatures(degree=2)
>>> poly.get_feature_names()
['1', 'x0', 'x1', 'x0^2', 'x0 x1', 'x1^2']
>>> poly.fit_transform(X)
array([[ 1.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  2.,  3.,  4.,  6.,  9.],
       [ 1.,  4.,  5., 16., 20., 25.]])

>>> # 转换成DataFrame
>>> poly2 = PolynomialFeatures(degree=3)
>>> X_2 = poly2.fit_transform(X)
>>> pd.DataFrame(data = X_2 ,columns=poly2.get_feature_names())

>>> poly3 = PolynomialFeatures(degree=3, interaction_only=True)
>>> X_3= poly3.fit_transform(X)
>>> pd.DataFrame(X_3, columns=poly3.get_feature_names()) 

from sklearn.preprocessing import PolynomialFeatures as PF
from sklearn.linear_model import LinearRegression
import numpy as np
import matplotlib.pyplot as plt
rnd = np.random.RandomState(42) #设置随机数种子 
X = rnd.uniform(-3, 3, size=100)
y = np.sin(X) + rnd.normal(size=len(X)) / 3
#将X升维，准备好放入sklearn中 
X = X.reshape(-1,1)
#多项式拟合，设定高次项
d=5
#原始特征矩阵的拟合结果
LinearR = LinearRegression().fit(X, y)
#进行高此项转换
X_ = PF(degree=d).fit_transform(X)
LinearR_ = LinearRegression().fit(X_, y)
line = np.linspace(-3, 3, 1000, endpoint=False).reshape(-1, 1) 
line_ = PF(degree=d).fit_transform(line)
#放置画布
fig, ax1 = plt.subplots(1)
#将测试数据带入predict接口，获得模型的拟合效果并进行绘制
ax1.plot(line, LinearR.predict(line), linewidth=2, color='green'
         ,label="linear regression")
ax1.plot(line, LinearR_.predict(line_), linewidth=2, color='orange'
,label="Polynomial regression") #将原数据上的拟合绘制在图像上
ax1.plot(X[:, 0], y, 'o', c='k')
#其他图形选项
ax1.legend(loc="best")
ax1.set_ylabel("Regression output") 
ax1.set_xlabel("Input feature") 
ax1.set_title("Linear Regression ordinary vs poly") 
ax1.text(0.8,-1,f"LinearRegression score:\n{LinearR.score(X,y)}",fontsize=15)
ax1.text(0.8,-1.3,f"LinearRegression score after poly :\n{LinearR_.score(X_,y)}",fontsize=15)

plt.tight_layout()
plt.show()

# 生产数据函数
def uniform(size):
    x = np.linspace(0,1,size)
    return x.reshape(size,1)

def create_data(size):
    x = uniform(size)
    np.random.seed(42) #设置随机数种子 
    y = sin_fun(x)+np.random.normal(scale=0.25, size=x.shape)
    return x,y

def sin_fun(x):
    return np.sin(2*np.pi*x)

X_train,y_train = create_data(20)
X_test = uniform(200)
y_test = sin_fun(X_test)
fig = plt.figure(figsize=(12,8))
for i,degree in enumerate([0,1,3,6,9,12]):  
    plt.subplot(2,2,i+1)

    poly = PolynomialFeatures(degree)
    X_train_ploy = poly.fit_transform(X_train)
    X_test_ploy = poly.fit_transform(X_test)
    
    lr = LinearRegression()
    lr.fit(X_train_ploy,y_train)
    y_pred = lr.predict(X_test_ploy)

    plt.scatter(X_train,y_train,facecolor="none", edgecolor="g", s=25, label="training data")
    plt.plot(X_test,y_pred,c="orange",label="fitting")
    plt.plot(X_test,y_test,c="k",label="$\sin(2\pi x)$")
    plt.title("N={}".format(order))
    plt.legend(loc="best")
    plt.ylabel("Regression output") 
#     plt.xlabel("Input feature") 
    plt.legend()
plt.show()

from sklearn.pipeline import Pipeline # 一种具有最终估计器的转换管道。文末有介绍
from sklearn.metrics import mean_squared_error
import math
import seaborn as sns
import matplotlib.patches as mpatches
# 数据还是上面例子的数据
mse1 = []
mse2 = []
plt.figure(figsize=(12,6))
degrees = [0,1,3,6,9,12]
for degree in degrees:
    pipe = Pipeline([("poly", PolynomialFeatures(degree=degree)),
                     ("lin_reg", LinearRegression())])
    pipe.fit(X_train,y_train)
    pred1 = pipe.predict(X_train)
    train_mse = mean_squared_error(y_train,pred1)
    
    pred2 = pipe.predict(X_test)
    test_mse = mean_squared_error(y_test,pred2)   
    
    mse1.append(train_mse)
    mse2.append(test_mse)
# 可视化
sns.pointplot(degrees,mse1,color='orange',label='Train')
sns.pointplot(degrees,mse2,color='k',label='Test')
orange_patch = mpatches.Patch(color='orange', label='Train MSE')
black_patch = mpatches.Patch(color='k', label='Test MSE')
plt.legend(handles = [red_patch,blue_patch])
plt.show()

from sklearn.datasets import fetch_california_housing as fch
import pandas as pd
housevalue = fch()
X = pd.DataFrame(housevalue.data)
y = housevalue.target
housevalue.feature_names
X.columns = ["住户收入中位数","房屋使用年代中位数","平均房间数目" ,"平均卧室数目","街区人口","平均入住率","街区的纬度","街区的经度"]
poly = PolynomialFeatures(degree=2).fit(X,y)
poly.get_feature_names(X.columns)
X_poly = poly.transform(X) 
reg = LinearRegression().fit(X_poly,y)
coef = reg.coef_
[*zip(poly.get_feature_names(X.columns),reg.coef_)]
#放到dataframe中进行排序
coeff = pd.DataFrame([poly.get_feature_names(X.columns),reg.coef_.tolist()]).T 
coeff.columns = ["feature","coef"]
coeff.sort_values(by="coef").head(10)

X,y = create_data(200) # 利用上面的生产数据函数
degree = 6
# 利用Pipeline将三个模型封装起来串联操作n
poly_reg = Pipeline([
                    ("poly", PolynomialFeatures(degree=degree)),
                    ("std_scaler", StandardScaler()),
                    ("lin_reg", LinearRegression())
                    ])
fig = plt.figure(figsize=(10,6)) 
poly = PolynomialFeatures(order)
poly_reg.fit(X, y)
y_pred = poly_reg.predict(X)
# 可视化结果
plt.scatter(X,y,facecolor="none", edgecolor="g", s=25, label="training data")
plt.plot(X,y_pred,c="orange",label="fitting")
# plt.plot(X,y,c="k",label="$\sin(2\pi x)$")
plt.title("degree={}".format(degree))
plt.legend(loc="best")
plt.ylabel("Regression output") 
plt.xlabel("Input feature") 
plt.legend()
plt.show()

>>> poly_reg.named_steps['lin_reg'].coef_
array([[  0.        ,  -0.14987173,  16.4142791 , -65.75198762,
         87.4087241 , -45.6444121 ,   7.36587511]])

>>> poly_reg.named_steps['poly'].get_feature_names()
['1', 'x0', 'x0^2', 'x0^3', 'x0^4', 'x0^5', 'x0^6']