精华内容
下载资源
问答
  • 网格调参
    千次阅读
    2019-06-01 15:49:04

    介绍SVM算法
    SVM理解与参数选择(kernel和C)

    SVM参数调节
    Python机器学习包的sklearn中的Gridsearch简单使用

    【算法_调参】sklearn_GridSearchCV,CV调节超参使用方法

    sklearn-GridSearchCV 网格搜索 调参数

    python调用libsvm
    如何利用python使用libsvm

    Python 之 LIBSVM 使用小结

    生成libSVM的数据格式及使用方法总结

    将一般的数据格式转为libsvm格式

    python实现CSV特征文件转化为libsvm特征文件

    5)python接口的说明
    在libsvm-3.16的python文件夹下主要包括了两个文件svm.py和svmutil.py
    svmutil.py接口主要包括了high-level的函数,这些函数的使用和LIBSVM的MATLAB接口大体类似
    svmutil中主要包含了以下几个函数:
    svm_train() : train an SVM model
    svm_predict() : predict testing data
    svm_read_problem() : read the data from a LIBSVM-format file.
    svm_load_model() : load a LIBSVM model.
    svm_save_model() : save model to a file.
    evaluations() : evaluate prediction results.
    svm.py接口主要包括了一些low-level的应用。在svm.py中采用了python内置的ctypes库,由此python可以直接访问svm.h中定义的C结构和接口函数。svm.py主要运用了四个数据结构svm_node, svm_problem, svm_parameter和svm_model。

    更多相关内容
  • 基于随机森林机器学习算法,通过sklearn库,实现网格调参方法,完整代码过程
  • XGboost-网格调参法(转载与测试)

    千次阅读 2019-11-13 17:14:33
    二、网格调参 用xgboost既可以用来做二分类、多分类,也可以用来做回归预测数值,除了特征之外,影响模型的是如何调参了,一般是按一定的步骤、网格搜索最优参数,如下两篇文章一个是用来分类,一个是用来预测数值的...

    一、原理

    一篇好文:
    https://www.jianshu.com/p/7467e616f227

    二、网格调参
    用xgboost既可以用来做二分类、多分类,也可以用来做回归预测数值,除了特征之外,影响模型的是如何调参了,一般是按一定的步骤、网格搜索最优参数,如下两篇文章一个是用来分类,一个是用来预测数值的案例,并且详细给出了调参的步骤和代码:
    https://blog.csdn.net/han_xiaoyang/article/details/52665396 (用来分类XGBClassifier)
    https://segmentfault.com/a/1190000014040317 (用来预测数字,XGBRegressor)

    三、实践
    参考以上的博客,用iris经典数据集进行多分类的预测(三个类别)。

    • 载入库
    import pandas as pd
    import numpy as np
    import xgboost as xgb
    from sklearn.model_selection import GridSearchCV
    from xgboost.sklearn import XGBClassifier
    from sklearn import metrics
    import matplotlib.pyplot as plt
    
    • 数据集
    from sklearn.datasets import load_iris
    iris = load_iris()
    X,y = iris.data,iris.target
    
    • 用Early Stop检查过拟合
    model = XGBClassifier()
    eval_set =[(X_test,y_test)]
    model.fit(X_train,y_train,eval_metric="mlogloss",eval_set=eval_set,verbose=True)
    

    eval_set=[(x_test,y_test)] 评估数据集,list类型
    eval_metric=“mlogloss” 评估标准(多分类问题,使用mlogloss作为损失函数)
    fit函数参数:early_stopping_rounds= 10 如果模型的loss十次内没有减小,则提前结束模型训练
    verbose = True True显示,False不显示

    • 预测
    y_pred = model.predict(X_test)
    
    • 两种评分
    from sklearn.metrics import accuracy_score
    from sklearn.metrics import mean_absolute_error
    err1 = accuracy_score(y_test,y_pred)
    err2 = mean_absolute_error(y_test,y_pred)
    print("accuracy1 is {0}%".format(err1*100.0))
    print("accuracy2 is {0}%".format(err2*100.0))
    
    accuracy1 is 97.77777777777777%
    accuracy2 is 2.2222222222222223% #这个部分再看看吧,每个类型的含义
    
    • 接下来,可视化训练过程
    results = model.evals_result()
    epochs = len(results['validation_0']['merror'])
    x_axis = range(0,epochs)
    fig, ax =plt.subplots(1,2,figsize=(10,5))
    ax[0].plot(x_axis, results['validation_0']['mlogloss'], label='Train')
    ax[0].plot(x_axis, results['validation_1']['mlogloss'], label='Test')
    ax[0].legend()
    ax[0].set_title('XGBoost Log Loss')
    ax[0].set_ylabel('Log Loss')
    ax[0].set_xlabel('epochs')
    
    ax[1].plot(x_axis, results['validation_0']['merror'], label='Train')
    ax[1].plot(x_axis, results['validation_1']['merror'], label='Test')
    ax[1].legend()
    ax[1].set_title('XGBoost Classification Error')
    ax[1].set_ylabel('Classification Error')
    ax[1].set_xlabel('epochs')
    plt.show()
    

    在这里插入图片描述
    运行结果在这里插入图片描述
    从图上看出,运行到74步的时候停止,最好的效果在64次。
    ps:根据许多大牛的实践经验,选择early_stopping_rounds=10%*n_estimators。

    一开始可以选择较大的迭代

    model = XGBClassifier(n_estimators=1000)
    
    展开全文
  • XGboost-网格调参

    万次阅读 多人点赞 2018-08-23 14:56:16
    二、网格调参 用xgboost既可以用来做二分类、多分类,也可以用来做回归预测数值,除了特征之外,影响模型的是如何调参了,一般是按一定的步骤、网格搜索最优参数,如下两篇文章一个是用来分类,一个是用来预测数值...

    一、原理

    个人认为写的通俗易懂的一篇好文:
    https://www.jianshu.com/p/7467e616f227

    二、网格调参

    用xgboost既可以用来做二分类、多分类,也可以用来做回归预测数值,除了特征之外,影响模型的是如何调参了,一般是按一定的步骤、网格搜索最优参数,如下两篇文章一个是用来分类,一个是用来预测数值的案例,并且详细给出了调参的步骤和代码:
    https://blog.csdn.net/han_xiaoyang/article/details/52665396 (用来分类XGBClassifier)
    https://segmentfault.com/a/1190000014040317 (用来预测数字,XGBRegressor)

    三、实践

    参考以上的博客,用iris经典数据集进行多分类的预测(三个类别):

    import pandas as pd
    import numpy as np
    import xgboost as xgb
    from xgboost.sklearn import XGBClassifier
    from sklearn import model_selection, metrics   
    from sklearn.grid_search import GridSearchCV   #Perforing grid search
    
    import matplotlib.pylab as plt
    %matplotlib inline
    
    
    import warnings
    warnings.filterwarnings(module='sklearn*', action='ignore', category=DeprecationWarning)
    
    from sklearn import datasets
    data=iris.data
    label=iris.target
    from sklearn.cross_validation import train_test_split
    train_x, test_x, train_y, test_y = train_test_split(data, label,test_size=0.3, random_state=0)
    
    dtrain=xgb.DMatrix(train_x,label=train_y)
    dtest=xgb.DMatrix(test_x,label=test_y)
    cv_params = {'n_estimators': [1,2,3,4,5,6]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 500, 'max_depth': 5, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 6 candidates, totalling 30 fits
    参数的最佳取值:{'n_estimators': 4}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done  30 out of  30 | elapsed:    8.9s finished
    
    cv_params = {'max_depth': [3, 4, 5, 6, 7, 8, 9, 10], 'min_child_weight': [1, 2, 3, 4, 5, 6]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 4, 'max_depth': 5, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 48 candidates, totalling 240 fits
    参数的最佳取值:{'max_depth': 4, 'min_child_weight': 1}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done 240 out of 240 | elapsed:    8.7s finished
    
    cv_params = {'gamma': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 4, 'max_depth': 4, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 6 candidates, totalling 30 fits
    参数的最佳取值:{'gamma': 0.1}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done  30 out of  30 | elapsed:    8.6s finished
    
    cv_params = {'subsample': [0.6, 0.7, 0.8, 0.9], 'colsample_bytree': [0.6, 0.7, 0.8, 0.9]}
    other_params = {'learning_rate': 0.1, 'n_estimators':4, 'max_depth': 4, 'min_child_weight':1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0.1, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 16 candidates, totalling 80 fits
    参数的最佳取值:{'colsample_bytree': 0.8, 'subsample': 0.8}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done  80 out of  80 | elapsed:    9.5s finished
    
    cv_params = {'reg_alpha': [0.05, 0.1, 1, 2, 3], 'reg_lambda': [0.05, 0.1, 1, 2, 3]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 4, 'max_depth': 4, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0.1, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 25 candidates, totalling 125 fits
    参数的最佳取值:{'reg_alpha': 0.05, 'reg_lambda': 0.05}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done 125 out of 125 | elapsed:    8.6s finished
    
    cv_params = {'learning_rate': [0.01, 0.05, 0.07, 0.1, 0.2]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 4, 'max_depth': 4, 'min_child_weight': 1, 'seed': 0,
                        'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0.1, 'reg_alpha': 0.05, 'reg_lambda': 0.05}
    model = xgb.XGBClassifier(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='accuracy', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(train_x, train_y)
    evalute_result = optimized_GBM.grid_scores_
    #print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值:{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))
    Fitting 5 folds for each of 5 candidates, totalling 25 fits
    参数的最佳取值:{'learning_rate': 0.1}
    最佳模型得分:0.9619047619047619
    
    
    [Parallel(n_jobs=4)]: Done  25 out of  25 | elapsed:    8.7s finished
    
    
    
    params={
            'booster':'gbtree',
            'objective': 'multi:softmax', #指明是分类问题
           # 'eval_metric': 'auc',
            'num_class':3, # 类数,与 multisoftmax 并用
            'gamma':0.1,  # 用于控制是否后剪枝的参数,越大越保守,一般0.1、0.2这样子。
            'max_depth':4, # 构建树的深度,越大越容易过拟合
            'lambda':0.05,  #控制模型复杂度的权重值的L2正则化项参数,参数越大,模型越不容易过拟合。
            'subsample':0.8, # 采样训练数据,设置为0.5,随机选择一般的数据实例 (0:1]
            'colsample_bytree':0.8, # 构建树树时的采样比率 (0:1]
            'min_child_weight':1, # 节点的最少特征数
            'silent':1 ,# 设置成1则没有运行信息输出,最好是设置为0.
            'eta': 0.1, # 如同学习率
            'seed':710,
            'alpha':0.05,
            'nthread':4,# cpu 线程数,根据自己U的个数适当调整
    }
    plst = list(params.items())
    num_rounds=100
    watchlist = [(dtrain,'train'),(dtest,'eval')]
    model=xgb.train(plst,dtrain,num_rounds,evals=watchlist)
    [0] train-merror:0.038095   eval-merror:0.088889
    [1] train-merror:0.019048   eval-merror:0.022222
    [2] train-merror:0.028571   eval-merror:0.022222
    [3] train-merror:0.019048   eval-merror:0.022222
    [4] train-merror:0.019048   eval-merror:0.022222
    [5] train-merror:0.019048   eval-merror:0.022222
    [6] train-merror:0.019048   eval-merror:0.022222
    [7] train-merror:0.019048   eval-merror:0.022222
    [8] train-merror:0.019048   eval-merror:0.022222
    [9] train-merror:0.019048   eval-merror:0.022222
    [10]    train-merror:0.019048   eval-merror:0.022222
    [11]    train-merror:0.019048   eval-merror:0.022222
    [12]    train-merror:0.019048   eval-merror:0.022222
    [13]    train-merror:0.019048   eval-merror:0.022222
    [14]    train-merror:0.019048   eval-merror:0.022222
    [15]    train-merror:0.019048   eval-merror:0.022222
    [16]    train-merror:0.019048   eval-merror:0.022222
    [17]    train-merror:0.019048   eval-merror:0.022222
    [18]    train-merror:0.019048   eval-merror:0.022222
    [19]    train-merror:0.009524   eval-merror:0.022222
    [20]    train-merror:0.019048   eval-merror:0.022222
    [21]    train-merror:0.009524   eval-merror:0.022222
    [22]    train-merror:0.009524   eval-merror:0.022222
    [23]    train-merror:0  eval-merror:0.022222
    [24]    train-merror:0  eval-merror:0.022222
    [25]    train-merror:0  eval-merror:0.022222
    [26]    train-merror:0.009524   eval-merror:0.022222
    [27]    train-merror:0  eval-merror:0.022222
    [28]    train-merror:0.009524   eval-merror:0.022222
    [29]    train-merror:0  eval-merror:0.022222
    [30]    train-merror:0  eval-merror:0.022222
    [31]    train-merror:0  eval-merror:0.022222
    [32]    train-merror:0  eval-merror:0.022222
    [33]    train-merror:0  eval-merror:0.022222
    [34]    train-merror:0  eval-merror:0.022222
    [35]    train-merror:0  eval-merror:0.022222
    [36]    train-merror:0  eval-merror:0.022222
    [37]    train-merror:0  eval-merror:0.022222
    [38]    train-merror:0  eval-merror:0.022222
    [39]    train-merror:0  eval-merror:0.022222
    [40]    train-merror:0  eval-merror:0.022222
    [41]    train-merror:0  eval-merror:0.022222
    [42]    train-merror:0  eval-merror:0.022222
    [43]    train-merror:0  eval-merror:0.022222
    [44]    train-merror:0  eval-merror:0.022222
    [45]    train-merror:0  eval-merror:0.022222
    [46]    train-merror:0  eval-merror:0.022222
    [47]    train-merror:0  eval-merror:0.022222
    [48]    train-merror:0  eval-merror:0.022222
    [49]    train-merror:0  eval-merror:0.022222
    [50]    train-merror:0  eval-merror:0.022222
    [51]    train-merror:0  eval-merror:0.022222
    [52]    train-merror:0  eval-merror:0.022222
    [53]    train-merror:0  eval-merror:0.022222
    [54]    train-merror:0  eval-merror:0.022222
    [55]    train-merror:0  eval-merror:0.022222
    [56]    train-merror:0  eval-merror:0.022222
    [57]    train-merror:0  eval-merror:0.022222
    [58]    train-merror:0  eval-merror:0.022222
    [59]    train-merror:0  eval-merror:0.022222
    [60]    train-merror:0  eval-merror:0.022222
    [61]    train-merror:0  eval-merror:0.022222
    [62]    train-merror:0  eval-merror:0.022222
    [63]    train-merror:0  eval-merror:0.022222
    [64]    train-merror:0  eval-merror:0.022222
    [65]    train-merror:0  eval-merror:0.022222
    [66]    train-merror:0  eval-merror:0.022222
    [67]    train-merror:0  eval-merror:0.022222
    [68]    train-merror:0  eval-merror:0.022222
    [69]    train-merror:0  eval-merror:0.022222
    [70]    train-merror:0  eval-merror:0.022222
    [71]    train-merror:0  eval-merror:0.022222
    [72]    train-merror:0  eval-merror:0.022222
    [73]    train-merror:0  eval-merror:0.022222
    [74]    train-merror:0  eval-merror:0.022222
    [75]    train-merror:0  eval-merror:0.022222
    [76]    train-merror:0  eval-merror:0.022222
    [77]    train-merror:0  eval-merror:0.022222
    [78]    train-merror:0  eval-merror:0.022222
    [79]    train-merror:0  eval-merror:0.022222
    [80]    train-merror:0  eval-merror:0.022222
    [81]    train-merror:0  eval-merror:0.022222
    [82]    train-merror:0  eval-merror:0.022222
    [83]    train-merror:0  eval-merror:0.022222
    [84]    train-merror:0  eval-merror:0.022222
    [85]    train-merror:0  eval-merror:0.022222
    [86]    train-merror:0  eval-merror:0.022222
    [87]    train-merror:0  eval-merror:0.022222
    [88]    train-merror:0  eval-merror:0.022222
    [89]    train-merror:0  eval-merror:0.022222
    [90]    train-merror:0  eval-merror:0.022222
    [91]    train-merror:0  eval-merror:0.022222
    [92]    train-merror:0  eval-merror:0.022222
    [93]    train-merror:0  eval-merror:0.022222
    [94]    train-merror:0  eval-merror:0.022222
    [95]    train-merror:0  eval-merror:0.022222
    [96]    train-merror:0  eval-merror:0.022222
    [97]    train-merror:0  eval-merror:0.022222
    [98]    train-merror:0  eval-merror:0.022222
    [99]    train-merror:0  eval-merror:0.022222
    
    ypred=model.predict(dtest)
    #计算准确率
    cnt1=0
    cnt2=0
    for i in range(len(test_y)):
        if ypred[i]==test_y[i]:
            cnt1+=1
        else:
            cnt2+=1
    print ('准确率:%.2f %%' % (100*cnt1/(cnt1+cnt2))) //用自定义的方式来计算准确率
    print(metrics.accuracy_score(test_y, ypred)) //直接用已定义的函数来计算
    准确率:97.78 %
    0.9777777777777777
    

    以上是通过网格参数取得了最佳参数后,代入xgb.train()得出的结果,和用XGBClassifier其实是一样的,只不过两者的参数命名略有不同:

    xgb1 = XGBClassifier(
         learning_rate=0.1, 
         n_estimators=4, 
         max_depth=4,
         min_child_weight=1,
         seed=0,
         subsample=0.8, 
         colsample_bytree=0.8, 
         gamma=0.1, 
         reg_alpha=0.05, 
         reg_lambda=0.05)
    xgb1.fit(train_x,train_y)
    ypred1=xgb1.predict(test_x)
    print(metrics.accuracy_score(test_y, ypred1))
    0.9777777777777777
    
    展开全文
  • 数据挖掘—网格调参GridSearchCV

    千次阅读 2020-11-02 14:53:37
    数据挖掘—网格调参GridSearchCV1、参数2、属性3、常用方法4、实例 带 交 叉 验 证 的 网 格 搜 索 是 一 种 常 用 的 调 参 方 法, 因 此 scikit-learn 提 供 了GridSearchCV 类,它以估计器(estimator)的形式...

    数据挖掘—网格调参GridSearchCV

    带 交 叉 验 证 的 网 格 搜 索 是 一 种 常 用 的 调 参 方 法, 因 此 scikit-learn 提 供 了GridSearchCV 类,它以估计器(estimator)的形式实现了这种方法。要使用 GridSearchCV类,你首先需要用一个字典指定要搜索的参数。然后 GridSearchCV 会执行所有必要的模型拟合。字典的键是我们要调节的参数名称(在构建模型时给出,在这个例子中是 C 和gamma ),字典的值是我们想要尝试的参数设置。

    sklearn.model_selection.GridSearchCV(estimator, param_grid, *, scoring=None, n_jobs=None, iid='deprecated', refit=True, cv=None, verbose=0, pre_dispatch='2*n_jobs', error_score=nan, return_train_score=False)
    

    https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV

    1、参数

    estimator:estimator object.
    选择使用的分类器,并且传入除需要确定最佳的参数之外的其他参数。每一个分类器都需要一个scoring参数,或者score方法

    param_grid:dict or list of dictionaries
    需要最优化的参数的取值,值为字典或者列表

    scoring:str, callable, list/tuple or dict, default=None
    模型评价标准,默认为None,这时需要使用score函数;或者如scoring = ‘roc_auc’,根据所选模型不同,评价准则不同,字符串(函数名),或是可调用对象,需要其函数签名,形如:scorer(estimator,X,y);如果是None,则使用estimator的误差估计函数。

    n_jobs:int, default=None
    要并行运行的作业数量.-1:所有CPU核数,1:默认值

    pre_dispatch:int, or str, default=n_jobs
    指定总共发的并行任务数,当n_jobs大于1时候,数据将在每个运行点进行复制,这可能导致OOM,而设置pre_dispatch参数,则可以预先划分总共的job数量,使数据最多被复制pre_dispatch次。

    iid:bool, default=False
    iid:默认为True,为True时,默认为各个样本fold概率分布一致,误差估计为所有样本之和,而非各个fold的平均。

    cv:交叉验证参数,默认None,使用三折交叉验证。指定fold数量,默认为3,也可以是yield训练/测试数据的生成器。

    refit:bool, str, or callable, default=True
    默认为True,程序将会以交叉验证训练集得到的最佳参数,重新对所有可能的训练集与开发集进行,作为最终用于性能评估的最佳模型参数。即在搜索参数结束后,用最佳参数结果再次fit一遍全部数据集。

    verbose:integer
    日志冗长度,int:冗长度,0:不输出训练过程,1:偶尔输出,>1:对每个子模型都输出。

    error_score:‘raise’ or numeric, default=np.nan
    在估计量拟合中出现错误时分配给分数的值。如果设置为“raise”,则会引发错误。如果给定数值,则会发出FitFailedWarning。此参数不会影响refit步骤,因为它总是会引发错误。

    return_train_score:bool, default=False
    如果为False,则cv_results_属性将不包含训练分数。计算训练分数是用来了解不同的参数设置如何影响过拟合/不拟合的权衡。然而,计算训练集上的分数可能会有很高的计算成本,并且不需要严格地选择能产生最佳泛化性能的参数。

    2、属性

    (1) cv_results_ : dict of numpy (masked) ndarrays
    具有键作为列标题和值作为列的dict,可以导入到DataFrame中。注意,“params”键用于存储所有参数候选项的参数设置列表。

    (2) best_estimator_ : estimator
    访问最佳参数对应的模型,它是在整个训练集上训练得到的

    (3)best_score_ :float best_estimator的分数
    (4)best_parmas_ : 最佳模型的参数
    (5) best_index_ : int 对应于最佳候选参数设置的索引(cv_results_数组)
    search.cv_results _ [‘params’] [search.best_index_]中的dict给出了最佳模型的参数设置,给出了最高的平均分数(search.best_score_)。
    (6)scorer_ : Scorer function 用于为模型选择最佳的参数。
    (7)n_splits_ : 交叉验证拆分(折叠/迭代)的次数。

    3、常用方法

    fit(X[, y, groups])

    get_params([deep])
    Get parameters for this estimator.

    predict(X)
    Call predict on the estimator with the best found parameters.

    predict_log_proba(X)
    Call predict_log_proba on the estimator with the best found parameters.

    predict_proba(X)
    Call predict_proba on the estimator with the best found parameters.

    score(X[, y])
    Returns the score on the given data, if the estimator has been refit.

    **set_params(params)
    Set the parameters of this estimator.

    transform(X)
    Call transform on the estimator with the best found parameters.

    4、实例

    我们创建的 grid_search 对象的行为就像是一个分类器,我们可以对它调用标准的 fit 、predict 和 score 方法。但我们在调用 fit 时,它会对 param_grid 指定的每种参数组合都运行交叉验证:

    from sklearn.datasets import load_iris
    from sklearn.model_selection import GridSearchCV
    from sklearn.model_selection import train_test_split
    from sklearn.svm import SVC
    iris=load_iris()
    param_grid={'C':[0.001,0.01,0.1,1,10,100],
               'gamma':[0.001,0.01,0.1,1,10,100]}
    grid_search=GridSearchCV(SVC(),param_grid,cv=5)
    X_train,X_test,y_train,y_test=train_test_split(iris.data,iris.target,random_state=0)
    grid_search.fit(X_train,y_train)
    print(grid_search.score(X_test,y_test))
    

    0.9736842105263158

    grid_search.cv_results_.keys()
    

    dict_keys([‘mean_fit_time’, ‘std_fit_time’, ‘mean_score_time’, ‘std_score_time’, ‘param_C’, ‘param_gamma’, ‘params’, ‘split0_test_score’, ‘split1_test_score’, ‘split2_test_score’, ‘split3_test_score’, ‘split4_test_score’, ‘mean_test_score’, ‘std_test_score’, ‘rank_test_score’, ‘split0_train_score’, ‘split1_train_score’, ‘split2_train_score’, ‘split3_train_score’, ‘split4_train_score’, ‘mean_train_score’, ‘std_train_score’])

    print(grid_search.best_estimator_)
    print(grid_search.best_params_)
    print(grid_search.best_score_)
    

    SVC(C=100, cache_size=200, class_weight=None, coef0=0.0,decision_function_shape=‘ovr’, degree=3, gamma=0.01, kernel=‘rbf’, max_iter=-1, probability=False, random_state=None, shrinking=True, tol=0.001, verbose=False)

    {‘C’: 100, ‘gamma’: 0.01}

    0.9732142857142857

    print(grid_search.best_index_)
    print(grid_search.n_splits_)
    

    31
    5

    grid_search.scorer_
    

    <function sklearn.metrics.scorer._passthrough_scorer(estimator, *args, **kwargs)>

    grid_search.get_params
    

    <bound method BaseEstimator.get_params of GridSearchCV(cv=5, error_score=‘raise-deprecating’,
    estimator=SVC(C=1.0,cache_size=200,class_weight=None,coef0=0.0,decision_function_shape=‘ovr’,degree=3,gamma=‘auto_deprecated’,kernel=‘rbf’,max_iter=-1,probability=False,random_state=None,shrinking=True, tol=0.001, verbose=False),
    fit_params=None, iid=‘warn’, n_jobs=None,
    param_grid={‘C’: [0.001, 0.01, 0.1, 1, 10, 100], ‘gamma’: [0.001, 0.01, 0.1, 1, 10, 100]},
    pre_dispatch=‘2*n_jobs’, refit=True, return_train_score=‘warn’,
    scoring=None, verbose=0)>

    展开全文
  • 在Xgboost调参过程中,可以使用GridSearchCV()进行网格调参,不用很麻烦的进行手动调参。 下面这个例子是使用Xgboost进行回归任务时使用GridSearchCV(). import pandas as pd import numpy as np from sklearn....
  • 网格搜索调参 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_...
  • 随机森林实现,一个随机森林的Python简单代码,使用网格搜索调参
  • report(y_true, y_pred)) # 混淆矩阵 print() 网格搜索clf.cv_results_解读: 字典 %s {'mean_fit_time': array([0.31090269, 0.15191479, 0.25862093]), 'std_fit_time': array([0.47454571, 0.01327594, 0.0244417...
  • 调参总结 随机森林的参数 # 当n足够大时,这个概率收敛于1-(1/e),约等于0.632。因此,会有约37%的训练数据被浪费掉,没有参与建模, # 这些数据被称为袋外数据(out of bag data,简写为oob)。除了我们最开始就划分...
  • 建模的整个过程中最耗时的部分是特征工程(含变量分析),其次可能是调参,所以今天来通过代码实战介绍调参的相关方法:网格搜索、贝叶斯调参。 工作中最常用的训练集测试集划分方法主要是随机比例分割和(分层)...
  • 任务  使用网格搜索对模型进行调优并采用五折交叉验证的方式进行模型评估 ...本文只进行带交叉验证的网格搜索调参,然后与调参前评分做比较。 from sklearn.model_selection import GridSearchCV,train_test...
  • 机器学习算法中有两类参数:从训练集中学习到的参数,比如逻辑斯蒂回归中的权重参数,另一类是模型的超...网格搜索听起来高大上,实际上简单的一笔,就是暴力搜索而已,我们事先为每个参数设定一组值,然后穷举各...
  • ,过好年!
  • 网格搜索总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。 提示:以下是本篇...
  • 随机森林(RandomForest,RF)网格搜索法调参

    万次阅读 多人点赞 2019-03-27 11:06:51
    当你读到这篇博客,那么你肯定知道手动调参是多么的低效。那么现在我来整理一下近几日学习的笔记,和大家一起分享学习这个知识点。
  • # 设置网格参数 learning_rate = [0.0001,0.001,0.01,0.1,0.2,0.3] # 学习率 gamma = [1, 0.1, 0.01, 0.001] param_grid = dict(learning_rate = learning_rate,gamma = gamma) # 建模lgbm estimator = lgb....
  • 随机森林实现及调参一、R语言方法一、手动调参方法二、网格调参二、python 注:本博客数据仍采用决策树调参的泰坦尼克号数据,前奏(数据预处理)请参考☞ 决策树R&Python调参对比☜ 一、R语言 方法一、手动调参 PS.仅...
  • 文章目录简单网格化搜索参数过拟合的风险网格搜索与交叉验证模型调参接口: GridSearchCV函数整体流程GridSearchCV( )函数对交叉验证进一步分析不同核方法的情况网格化搜索中应用其他交叉验证策略嵌套交叉验证并行化...
  • 本文介绍了如何使用网格搜索寻找网络的最佳超参数配置。 文章目录1. 准备数据集2. 问题建模2.1 训练集测试集拆分2.2 转化为监督学习问题2.3 前向验证2.4 重复评估2.5 网格搜索2.6 实例化3. 使用网格搜索寻找CNN最佳...
  • xgb+网格调参流程及代码

    千次阅读 2019-04-26 15:03:27
    xgb+网格调参流程及代码XGB简介网格调参简介网格调参代码总结Xgb的特点: XGB简介 XGBoost是一个优化的分布式梯度增强库,旨在实现高效,灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。 XGBoost提供了...
  • 机器学习 交叉验证与网格搜索调参

    千次阅读 2018-08-01 14:34:17
    网格搜索一般是针对参数进行寻优,交叉验证是为了验证训练模型拟合程度。sklearn中的相关API如下: (1)交叉验证的首要工作:切分数据集train/validation/test A.)没指定数据切分方式,直接选用cross_val_...
  • 机器学习中的调参前言1、随机搜索和网格搜索2、 遗传算法 前言 超参数调优是机器学习中的重要一环,拿随机森林算法而言,树的个数,数的深度,剪枝参数等等需要找到最优的参数组合,超参数较少时,我们可以采用for...
  • 调参步骤: n_estimators max_depth 、min_child_weight gamma subsample、colsample_bytree reg_alpha、reg_lambda learning_rate 下面这段网上摘抄的,应该要加上 预测测试集 import xgboost as xgb ...
  • 模型的重要参数:提供泛化性能的参数 网格搜索:尝试所有重要参数的可能组合 简单的网格搜索:将数据集划分为用于构建模型的训练集、...在SVM模型中使用交叉验证调参: from sklearn.svm import SVC from sklearn.model
  • 网格搜索 GridSearchCV官方网址: https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV 2.1 原理解释 GridSearchCV,它存在的意义...
  • 网格搜索(调参)与数据预处理

    千次阅读 2018-09-28 10:52:20
    网格搜索是一种调参手段;穷举搜索:在所有候选的参数选择中,通过循环遍历,尝试每一种可能性,表现最好的参数就是最终的结果。其原理就像是在数组里找最大值。(为什么叫网格搜索?以有两个参数的模型为例,参数a...
  • Grid Search:一种调参手段;穷举搜索:在所有候选的参数选择中,通过循环遍历,尝试每一种可能性,表现最好的参数就是最终的结果。其原理就像是在数组里找最大值。(为什么叫网格搜索?以有两个参数的模型为例,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,070
精华内容 3,228
关键字:

网格调参