from sklearn.datasets import load_boston
from sklearn.metrics import mean_squared_error
from lightgbm import LGBMRegressor
import numpy as np

导入数据集

boston = load_boston()
X,y = boston.data,boston.target
print(X.shape)
print(y.shape)

定义交叉验证分数

from sklearn.model_selection import KFold, cross_val_score, GridSearchCV

def mse_cv(model=None,X_train=None,y_train=None):
    kf=KFold(n_splits=10,shuffle=True,random_state=42).get_n_splits(X_train)
    return -cross_val_score(model,X_train,y_train,scoring='neg_mean_absolute_error',cv=kf,n_jobs=-1)

定义模型

model = LGBMRegressor()
score = mse_cv(model,X,y)
print('{:.4f}({:.4f})'.format(score.mean(),score.std()))
model.fit(X,y)
print('{:.4f}'.format(mean_squared_error(model.predict(X),y)))

定义候选参数列表

param_dist = {'n_estimators': (10, 250),
        'min_samples_split': (2, 25),
        'max_features': (0.1, 0.999),
        'max_depth': (5, 15)}

1.网格搜索调参

from scipy.stats import randint as sp_randint
from sklearn.model_selection import GridSearchCV
              
grid_search = GridSearchCV(estimator = model, param_grid=param_dist,
                                   scoring="neg_mean_squared_error" ,n_jobs=-1, cv=5)
grid_search.fit(X, y)
print(grid_search.best_estimator_)

2.随机搜索调参

from scipy.stats import randint as sp_randint
from sklearn.model_selection import RandomizedSearchCV
 
random_search = RandomizedSearchCV(estimator = model, param_distributions=param_dist,
                                   n_iter=100, scoring="neg_mean_squared_error" ,n_jobs=-1, cv=5)
random_search.fit(X, y)
print(random_search.best_estimator_)

3.贝叶斯调参

from bayes_opt import BayesianOptimization

def lgb_cv(n_estimators, min_samples_split, max_features, max_depth):
    val = cross_val_score(
        LGBMRegressor(n_estimators=int(n_estimators),
            min_samples_split=int(min_samples_split),
            max_features=min(max_features, 0.999), # float
            max_depth=int(max_depth),
            random_state=2
        ),
        X, y, scoring='neg_mean_absolute_error', cv=5
    ).mean()
    return val

lgb_bo = BayesianOptimization(
        lgb_cv,
        {'n_estimators': (10, 250),
        'min_samples_split': (2, 25),
        'max_features': (0.1, 0.999),
        'max_depth': (5, 15)}
    ) 
lgb_bo.maximize(init_points=21,n_iter=90)
print(lgb_bo.max['params'])

#导入波士顿数据
from sklearn.datasets import load_boston
import pandas as pd
import numpy as np
boston=load_boston()
print(boston.data.shape)
print(boston.target.shape)
#数据集的描述
print(boston.feature_names)
#print(boston.DESCR)
#特征
bostonDf_X = pd.DataFrame(boston.data,columns = boston.feature_names)
bostonDf_X.head()
#标签
bostonDf_y = pd.DataFrame(boston.target,columns=['housePrice'])#【注意加列名要加在[]中】
bostonDf_y.head()
#合并DataFrame
bostonDf = pd.concat([bostonDf_X,bostonDf_y],axis =1)#axis =1 为横向操作，即横向合并
bostonDf.shape#506,14
bostonDf.head()
#RM房间数  MEDV 房价
#创建用于模型的数据集

from sklearn.model_selection import train_test_split #切分训练集与测试集 
#划分训练集与测试集7：3比例
x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.3,random_state=0)
print(len(x_train))
print(len(x_test))
from sklearn.model_selection import train_test_split #切分训练集与测试集
from sklearn.linear_model import LinearRegression  #线性回归模型
LR=LinearRegression()
#特征
bostonDf_X = pd.DataFrame(boston.data,columns = boston.feature_names)
bostonDf_X.head()

#标签
bostonDf_y = pd.DataFrame(boston.target,columns=['housePrice'])#【注意加列名要加在[]中】
bostonDf_y .head()
#合并DataFrame
bostonDf = pd.concat([bostonDf_X,bostonDf_y],axis =1)#axis =1 为横向操作，即横向合并
bostonDf.shape#506,14
bostonDf.head()

#标准化
from sklearn import preprocessing
bostonDf_std=pd.DataFrame(preprocessing.normalize(bostonDf,norm='l2', axis=1, copy=True),columns=bostonDf.columns)
bostonDf_std.head()

from sklearn.model_selection import train_test_split #切分训练集与测试集 
#划分训练集与测试集7：3比例
X_train,X_test,y_train,y_test =\
    train_test_split(bostonDf_std[["CRIM","ZN","INDUS","CHAS","NOX","RM","AGE","DIS","RAD","TAX","PTRATIO","B","LSTAT"]],bostonDf_std[["housePrice"]], test_size = 0.3, random_state=0)
print(len(X_train))
print(len(X_test))
from sklearn.linear_model import LinearRegression  #线性回归模型
LR=LinearRegression()
#用训练集训练模型
LR.fit(X_train,y_train)
#用训练出来的模型去拟合测试数据
y_pred=LR.predict(X_test)
LR.score(X_test,y_test)#【精度得分80.132%】
#【上面改近方向：可用Lasso回归梯度下降加入学习率训练，求得最优参数，和学习率之间的平衡】

#k近邻 网格搜索和GridSearchCV调参来实现多变量线性回归的找到最优参数，测算精确度，看看是不是使回归更优
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import GridSearchCV

knn_reg = KNeighborsRegressor()

param_grid = [
    {
        'weights': ['uniform'],
        'n_neighbors':[i for i in range(1,11)]
    },
    {
        'weights':['distance'],
        'n_neighbors':[i for i in range(1,11)],
        'p':[i for i in range(1,6)]
    }
]

knn_reg = KNeighborsRegressor()

grid_search=GridSearchCV(knn_reg,param_grid,n_jobs=-1,verbose=2)
grid_search.fit(X_train,y_train)

#最优参数
grid_search.best_params_
#{'n_neighbors': 2, 'p': 1, 'weights': 'distance'}

#代入最优参数得到算法精确度
grid_search.best_estimator_.score(X_test,y_test)
#72.49899478974446%

#对比上面LinearRegression看下，网格搜索K近邻 多元线性回归求得的精确度为72%，
#LinearRegression没用学习率和参数调优。80%。