【机器学习（13）】参数搜索相关概念及sklearn中代码实现

小咪咪 2023-07-11 15:07 23阅读 0赞

## 1. 参数相关概念 ##

**1） 参数类型**  
        一般参数：模型通过最小化损失函数自动求解的参数  
        超参数：不能通过模型对数据进行学习而求解的参数，比如神经网络的层数、正则系数的alpha值等

**2） 参数搜索：**  
        超参数的搜索：提前设置好参数可以选择的候选值，然后根据不同参数组合对于模型泛化能力的贡献，选取最佳的超参数组合。（是针对于超参数的搜索）

**3） 参数搜索的方法：**

**GridSearchCV**，基于交叉验证的网格搜索法：将要搜索的参数候选值输入搜索器内，搜索器遍历每一种参数组合，使用交叉验证法对比每种参数组合下模型的表现，返回表现最好模型的参数值

优点：自动调参，参数准确性高  
        缺点：需要耗费巨大的算例和计算时间（比如：搜索100颗树的随机森森模型的两种参数各三个候选值，选择k等于10的交叉验证，则需要训练验证9000颗决策树才能返回最佳参数）

**RandomizedSearchCV**，基于交叉验证的随机搜索法：基本原理与GridSearchCV一致，但为了提高搜索效率，搜索器会从参数组合中随机搜索一些参数进行训练和验证，返回其中表现最好的参数值

优点：运行效率高，适合大数据量样本  
        缺点：参数的准确性有所牺牲

## 2. 代码实现 ##

#### 2.1 数据加载 ####

还是和之前一样，直接copy过来，可以将警报处理放在最开始的地方

import pandas as pd
    import matplotlib.pyplot as plt
    import os
    os.chdir(r'C:\Users\86177\Desktop')
    import warnings
    warnings.filterwarnings('ignore')
    # 样例数据读取
    df = pd.read_excel('realestate_sample_preprocessed.xlsx')
    # 根据共线性矩阵，保留与房价相关性最高的日间人口，将夜间人口和20-39岁夜间人口进行比例处理
    def age_percent(row):
        if row['nightpop'] == 0:
            return 0
        else:
            return row['night20-39']/row['nightpop']
    df['per_a20_39'] = df.apply(age_percent,axis=1)
    df = df.drop(columns=['nightpop','night20-39'])
    # 制作标签变量
    price_median = df['average_price'].median()
    print(price_median)
    df['is_high'] = df['average_price'].map(lambda x: True if x>= price_median else False)
    print(df['is_high'].value_counts())
    # 数据集基本情况查看
    print(df.shape)
    print(df.dtypes)
    print(df.isnull().sum())

–> 输出的结果为：

30273.0
    
    True     449
    False    449
    Name: is_high, dtype: int64
    
    (898, 10)
    
    id                 int64
    complete_year      int64
    average_price    float64
    area             float64
    daypop           float64
    sub_kde          float64
    bus_kde          float64
    kind_kde         float64
    per_a20_39       float64
    is_high             bool
    dtype: object
    
    id               0
    complete_year    0
    average_price    0
    area             0
    daypop           0
    sub_kde          0
    bus_kde          0
    kind_kde         0
    per_a20_39       0
    is_high          0
    dtype: int64

#### 2.2 使用留出法划分数据集 ####

这个也是和之前的一样

from sklearn.model_selection import train_test_split
    # 将数据集划分成训练集和验证集：划分比例0.75训练，0.25验证
    training, testing = train_test_split(df,test_size=0.25, random_state=1)
    # 提取训练集中的x与y
    x_train = training.copy()[['complete_year','area', 'daypop', 'sub_kde',
           'bus_kde', 'kind_kde','per_a20_39']]
    y_train = training.copy()['is_high']
    # 提取验证集中的x与y
    x_test = testing.copy()[['complete_year','area', 'daypop', 'sub_kde',
           'bus_kde', 'kind_kde','per_a20_39']]
    y_test = testing.copy()['is_high']
    print(f'the shape of training set is: {x_train.shape}')
    print(f'the shape of testing set is: {x_test.shape}')

–> 输出的结果为：

the shape of training set is: (673, 7)
    the shape of testing set is: (225, 7)

#### 2.3 使用Pipeline创建工作流，构造模型 ####

模型选择随机森林，核心内容讲解，

关于`max_features`（最大特征数量），里面是有四个类型  
‘auto’：特征总数量的开方；  
5代表整数型，选取5个特征进行训练；  
0.8代表浮点数型，选取80%的特征进行训练；  
None就是没有限制

关于 `'max_depth'`（最大深度），里面有三个  
None：每棵树的深度没有限制；  
3： 代表每棵树的深度为3，较为严格；  
9：代表每棵树的深度为9，较为宽松

`GridSearchCV`（参数搜索器）中参数的讲解  
第一个参数：搜索的模型  
第二个参数：要搜索的参数矩阵，也就是上面的内容  
第三个参数：设置的线程数，进行同步搜索  
第四个参数：★★★★★交叉验证机制，这里和之前的不一样，不是用来做输出的，这是用来划分数据的，用来找到最佳的参数，分类使用选择的验证机制的模块是StratifiedKFold（不要搞错了），找到最佳参数后，还是使用留出法划分的数据进行预测的，不要和之前的内容搞混了  
第五个参数：评价标准，在之前分类模型的评价指标中也有提到  
第六个参数：就是提醒，可以在最后的输出中看到  
第七个参数：当为True的时候，在找到最佳参数后会用最佳参数组重新训练一个模型，这样就可以直接使用GridSearchCV对象进行模型训练与预测

from sklearn.preprocessing import PowerTransformer, StandardScaler, PolynomialFeatures
    from sklearn.pipeline import Pipeline
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.model_selection import  StratifiedKFold,GridSearchCV
    # 如果是选择随机网格搜索则：
    from sklearn.model_selection import RandomizedSearchCV 
    # 定义随机森林模型
    rf_model = RandomForestClassifier(criterion='gini',
                                      n_jobs=16,
                                      n_estimators = 100,
                                      random_state=133)
    # 定义需要搜索的参数矩阵
    parameters = { 'max_features': ['auto',5, 0.8, None],
                  'max_depth': [None, 3, 9]}
    # 定义交叉验证机制 
    cv = StratifiedKFold(n_splits=3, shuffle=True)
    # 定义参数搜索器
    rf_gridsearch = GridSearchCV(rf_model, parameters, n_jobs=16, cv=cv, scoring='roc_auc',
                                          verbose=2, refit=True)
    # pipline 模型封装
    pipe_clf = Pipeline([
            ('sc',StandardScaler()),
            ('power_trans',PowerTransformer()),
            ('polynom_trans',PolynomialFeatures(degree=2)),
            ('rf_clf',rf_gridsearch)
            ])
    print(pipe_clf)

–> 输出的结果为：

Pipeline(memory=None,
             steps=[('sc',
                     StandardScaler(copy=True, with_mean=True, with_std=True)),
                    ('power_trans',
                     PowerTransformer(copy=True, method='yeo-johnson',
                                      standardize=True)),
                    ('polynom_trans',
                     PolynomialFeatures(degree=2, include_bias=True,
                                        interaction_only=False, order='C')),
                    ('rf_clf',
                     GridSearchCV(cv=StratifiedKFold(n_splits=3, random_state=None, shuffle=T...
                                                                   min_samples_leaf=1,
                                                                   min_samples_split=2,
                                                                   min_weight_fraction_leaf=0.0,
                                                                   n_estimators=100,
                                                                   n_jobs=16,
                                                                   oob_score=False,
                                                                   random_state=133,
                                                                   verbose=0,
                                                                   warm_start=False),
                                  iid='warn', n_jobs=16,
                                  param_grid={ 'max_depth': [None, 3, 9],
                                              'max_features': ['auto', 5, 0.8,
                                                               None]},
                                  pre_dispatch='2*n_jobs', refit=True,
                                  return_train_score=False, scoring='roc_auc',
                                  verbose=2))],
             verbose=False)

#### 2.4 留出法在验证集上模型的表现 ####

from sklearn.metrics import accuracy_score, precision_score, recall_score, roc_auc_score
    pipe_clf.fit(x_train,y_train)
    y_predict = pipe_clf.predict(x_test)
    print(f'accuracy score is: {accuracy_score(y_test,y_predict)}')
    print(f'precision score is: {precision_score(y_test,y_predict)}')
    print(f'recall score is: {recall_score(y_test,y_predict)}')
    print(f'auc: {roc_auc_score(y_test,y_predict)}')

–> 输出的结果为：

Fitting 3 folds for each of 12 candidates, totalling 36 fits
    
    [Parallel(n_jobs=16)]: Using backend LokyBackend with 16 concurrent workers.
    [Parallel(n_jobs=16)]: Done  24 out of  36 | elapsed:    5.0s remaining:    2.5s
    [Parallel(n_jobs=16)]: Done  36 out of  36 | elapsed:    5.4s finished
    
    accuracy score is: 0.8622222222222222
    precision score is: 0.8695652173913043
    recall score is: 0.8620689655172413
    auc: 0.8622271433090793

#### 2.5 如何查看最佳参数 ####

print(pipe_clf.named_steps['rf_clf'].best_params_)

–> 输出的结果为：（运行的结果会有不同的）

{ 'max_depth': 9, 'max_features': 'auto'}