精华内容
下载资源
问答
  • 网格搜索法

    万次阅读 多人点赞 2018-08-28 21:37:09
    网格搜索法是指定参数值的一种穷举搜索方法,通过将估计函数的参数通过交叉验证的方法进行优化来得到最优的学习算法。 即,将各个参数可能的取值进行排列组合,列出所有可能的组合结果生成“网格”。然后将各组合...

    网格搜索法是指定参数值的一种穷举搜索方法,通过将估计函数的参数通过交叉验证的方法进行优化来得到最优的学习算法。

    即,将各个参数可能的取值进行排列组合,列出所有可能的组合结果生成“网格”。然后将各组合用于SVM训练,并使用交叉验证对表现进行评估。在拟合函数尝试了所有的参数组合后,返回一个合适的分类器,自动调整至最佳参数组合,可以通过clf.best_params_获得参数值

     

     

     

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/sinat_32547403/article/details/73008127

    交叉验证与网格搜索

    交叉验证与网格搜索是机器学习中的两个非常重要且基本的概念,但是这两个概念在刚入门的时候并不是非常容易理解与掌握,自己开始学习的时候,对这两个概念理解的并不到位,现在写一篇关于交叉验证与网格搜索的文章,将这两个基本的概念做一下梳理。

    网格搜索

    网格搜索(Grid Search)名字非常大气,但是用简答的话来说就是你手动的给出一个模型中你想要改动的所用的参数,程序自动的帮你使用穷举法来将所用的参数都运行一遍。决策树中我们常常将最大树深作为需要调节的参数;AdaBoost中将弱分类器的数量作为需要调节的参数。

    评分方法

    为了确定搜索参数,也就是手动设定的调节的变量的值中,那个是最好的,这时就需要使用一个比较理想的评分方式(这个评分方式是根据实际情况来确定的可能是accuracy、f1-score、f-beta、pricise、recall等)

    交叉验证

    有了好的评分方式,但是只用一次的结果就能说明某组的参数组合比另外的参数组合好吗?这显然是不严谨的,上小学的时候老师就告诉我们要求平均��。所以就有了交叉验证这一概念。下面以K折交叉验证为例介绍这一概念。

    1. 首先进行数据分割 
      将原始数据集分为训练集和测试集。如下图以8:2的方式分割: 
      png 
      训练集使用来训练模型,测试集使用来测试模型的准确率。 
      注意:绝对不能使用测试集来训练数据,这相当于考试的时候先让你把考试的答案背过了,又让你参加考试。
    2. 数据验真 
      在k折交叉验证方法中其中K-1份作为训练数据,剩下的一份作为验真数据:

    png1 
    这个过程一共需要进行K次,将最后K次使用实现选择好的评分方式的评分求平均返回,然后找出最大的一个评分对用的参数组合。这也就完成了交叉验证这一过程。

    ### 举例 下面使用一个简单的例子(预测年收入是否大于5万美元)来进行说明网格搜索与交叉验证的使用。 数据集来自[UCI机器学习知识库](https://archive.ics.uci.edu/ml/datasets/Census+Income)。

    import numpy as np
    import pandas as pd
    from IPython.display import display
    from sklearn.preprocessing import MinMaxScaler
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import make_scorer, fbeta_score, accuracy_score
    from sklearn.model_selection import GridSearchCV, KFold
    
    %matplotlib inline 
    
    data = pd.read_csv("census.csv")
    
    # 将数据切分成特征和标签
    income_raw = data['income']
    features_raw = data.drop('income', axis=1)
    
    # 显示部分数据
    # display(features_raw.head(n=1))
    
    # 因为原始数据中的,capital-gain 和 capital-loss的倾斜度非常高,所以要是用对数转换。
    skewed = ['capital-gain', 'capital-loss']
    features_raw[skewed] = data[skewed].apply(lambda x: np.log(x + 1))
    
    # 归一化数字特征,是为了保证所有的特征均被平等的对待
    scaler = MinMaxScaler()
    numerical = ['age', 'education-num', 'capital-gain', 'capital-loss', 'hours-per-week']
    features_raw[numerical] = scaler.fit_transform(data[numerical])
    # display(features_raw.head(n=1))
    
    # 独热编码,将非数字的形式转化为数字
    features = pd.get_dummies(features_raw)
    income = income_raw.replace(['>50K', ['<=50K']], [1, 0])
    
    # 切分数据集
    X_train, X_test, y_train, y_test = train_test_split(features, income, test_size=0.2, random_state=0)
    
    # Adaboost
    from sklearn.ensemble import AdaBoostClassifier
    clf_Ada = AdaBoostClassifier(random_state=0)
    
    # 决策树
    from sklearn.tree import DecisionTreeClassifier
    clf_Tree = DecisionTreeClassifier(random_state=0)
    
    # KNN
    from sklearn.neighbors import KNeighborsClassifier
    clf_KNN = KNeighborsClassifier()
    
    # SVM
    from sklearn.svm import SVC
    clf_svm = SVC(random_state=0)
    
    # Logistic
    from sklearn.linear_model import LogisticRegression
    clf_log = LogisticRegression(random_state=0)
    
    # 随机森林
    from sklearn.ensemble import RandomForestClassifier
    clf_forest = RandomForestClassifier(random_state=0)
    
    # GBDT
    from sklearn.ensemble import GradientBoostingClassifier
    clf_gbdt = GradientBoostingClassifier(random_state=0)
    
    # GaussianNB
    from sklearn.naive_bayes import GaussianNB
    clf_NB = GaussianNB()
    
    scorer = make_scorer(accuracy_score)
    
    # 参数调优
    
    kfold = KFold(n_splits=10)
    # 决策树
    parameter_tree = {'max_depth': xrange(1, 10)}
    grid = GridSearchCV(clf_Tree, parameter_tree, scorer, cv=kfold)
    grid = grid.fit(X_train, y_train)
    
    print "best score: {}".format(grid.best_score_)
    display(pd.DataFrame(grid.cv_results_).T)

    best score: 0.855737070514.dataframe thead tr:only-child th { text-align: right; } .dataframe thead th { text-align: left; } .dataframe tbody tr th { vertical-align: top; }

      0 1 2 3 4 5 6 7 8
    mean_fit_time 0.0562535 0.0692133 0.0885126 0.110233 0.128337 0.158719 0.17124 0.193637 0.223979
    mean_score_time 0.00240474 0.00228212 0.00221529 0.0026047 0.00226772 0.00254297 0.00231481 0.00246696 0.00256622
    mean_test_score 0.75114 0.823811 0.839345 0.839926 0.846671 0.852392 0.851508 0.853139 0.855737
    mean_train_score 0.75114 0.82421 0.839628 0.840503 0.847878 0.853329 0.855264 0.859202 0.863667
    param_max_depth 1 2 3 4 5 6 7 8 9
    params {u’max_depth’: 1} {u’max_depth’: 2} {u’max_depth’: 3} {u’max_depth’: 4} {u’max_depth’: 5} {u’max_depth’: 6} {u’max_depth’: 7} {u’max_depth’: 8} {u’max_depth’: 9}
    rank_test_score 9 8 7 6 5 3 4 2 1
    split0_test_score 0.760641 0.8267 0.843836 0.844666 0.851575 0.855721 0.855445 0.86042 0.859038
    split0_train_score 0.750084 0.823828 0.839184 0.83943 0.847538 0.852913 0.854295 0.859947 0.863233
    split1_test_score 0.758154 0.821172 0.839138 0.842454 0.845218 0.849641 0.847706 0.850746 0.852957
    split1_train_score 0.750361 0.824442 0.839706 0.845911 0.850088 0.854203 0.855831 0.861482 0.864984
    split2_test_score 0.754837 0.824212 0.840243 0.84052 0.8466 0.854616 0.854339 0.854063 0.856551
    split2_train_score 0.750729 0.824718 0.839031 0.839307 0.847323 0.852237 0.854203 0.859578 0.86397
    split3_test_score 0.73162 0.820619 0.838032 0.838308 0.8466 0.850746 0.848535 0.846877 0.852957
    split3_train_score 0.753309 0.824503 0.839829 0.840106 0.848337 0.853742 0.85537 0.858104 0.863171
    split4_test_score 0.746545 0.818684 0.83361 0.833886 0.83969 0.847982 0.845495 0.85047 0.848811
    split4_train_score 0.751651 0.824718 0.840321 0.840597 0.844897 0.853558 0.858319 0.861912 0.864922
    split5_test_score 0.754284 0.826147 0.844942 0.845218 0.854063 0.859038 0.85738 0.858209 0.861802
    split5_train_score 0.750791 0.823889 0.839061 0.839338 0.847323 0.852729 0.854111 0.856967 0.862741
    split6_test_score 0.754284 0.825318 0.838032 0.837756 0.845495 0.848535 0.848535 0.852128 0.857103
    split6_train_score 0.750791 0.823981 0.839829 0.840167 0.848429 0.853773 0.855647 0.857766 0.863141
    split7_test_score 0.749793 0.821399 0.835499 0.835499 0.844623 0.85264 0.852087 0.853746 0.85264
    split7_train_score 0.75129 0.824416 0.840111 0.840418 0.848372 0.853501 0.854945 0.860811 0.863882
    split8_test_score 0.753387 0.826375 0.838264 0.83854 0.84407 0.852087 0.852917 0.852364 0.858446
    split8_train_score 0.750891 0.823864 0.839803 0.84008 0.848372 0.853071 0.854945 0.857801 0.863391
    split9_test_score 0.747857 0.827481 0.841858 0.842411 0.84877 0.852917 0.85264 0.852364 0.857064
    split9_train_score 0.751505 0.823741 0.839404 0.839681 0.848096 0.853563 0.854975 0.857647 0.863237
    std_fit_time 0.0123583 0.00442788 0.00552026 0.00631691 0.0053195 0.0157011 0.00476991 0.00622854 0.0147429
    std_score_time 0.000529214 0.000467091 0.000355028 0.000760624 0.000460829 0.000504627 0.000446289 0.000445256 0.000449312
    std_test_score 0.00769898 0.00292464 0.00333118 0.00358776 0.00382496 0.00324406 0.00360414 0.00366389 0.00363761
    std_train_score 0.000855482 0.000366166 0.000418973 0.00185264 0.00124698 0.000553171 0.00116151 0.00168732 0.000726325
    展开全文
  • svm 网格搜索法

    2016-03-09 15:43:07
    SVM参数优化 网格搜索法
  • 网格搜索法2--交叉验证csv文件下载网格搜索法网格通俗理解交叉验证理解交叉验证函数---cross_val_score搜索法2代码 csv文件下载 CSV(indian_pines.csv)文件在本人博客另外连接可自由下载,怎么生成的这个文件在SVM...

    csv文件下载

    CSV(indian_pines.csv)文件在本人博客另外连接可自由下载,怎么生成的这个文件在SVM那篇文章写了

    网格搜索法

    网格搜索法是指定参数值的一种穷举搜索方法,通过将估计函数的参数通过交叉验证的方法进行优化来得到最优的学习算法。
    即,将各个参数可能的取值进行排列组合,列出所有可能的组合结果生成“网格”。然后将各组合用于SVM训练,并使用交叉验证对表现进行评估。在拟合函数尝试了所有的参数组合后,返回一个合适的分类器,自动调整至最佳参数组合。

    网格通俗理解

    遍历各种组合参数,得到最佳得分的分类参数,最后使用该组参数

    交叉验证理解

    遍历每一种参数组合,使用一下两种方法进行验证最佳参数组合

    1. 最基础的验证方法:将样本按比例分成不重叠的两部分,即训练集跟验证集,验证集数据不能拿去训练,就像不能看过答案后拿这道题去考试,因为只用了一次,所以数据利用率比较低;
    2. K折交叉验证:将样本量分成K等分,每次将其中的一等分作为验证集,其余(k-1)份作为训练集,进行K次训练和验证,将验证准确率取平均数,作为该组参数的准确率
      交叉验证图解

    交叉验证函数—cross_val_score

    scikit-learn中的cross_val_score
    导入

    from sklearn.model_selection import cross_val_score
    

    函数定义

    sklearn.model_selection.cross_val_score(estimator, X, y=None, groups=None, scoring=None, cv=’warn’, n_jobs=None, verbose=0, fit_params=None, pre_dispatch=‘2*n_jobs’, error_score=’raise-deprecating’)
    

    下面用到的几个参数:
    estimator: 需要使用交叉验证的算法(本文使用SVM)
    X: 输入样本数据
    y: 样本标签
    cv: 交叉验证折数(K值)
    scoring: 交叉验证最重要的就是他的验证方式,选择不同的评价方法,会产生不同的评价结果。(https://scikitlearn.org/stable/modules/model_evaluation.html#scoring-parameter)
    scoring取值及代表的函数

    搜索法2代码

    循环遍历几种参数,拿去训练,然后比较最佳得分

    # # 网格搜索法2
    from sklearn.datasets import load_iris
    from sklearn.svm import SVC
    from sklearn.model_selection import train_test_split,cross_val_score
    import pandas as pd
    best_parameters = {}
    data = pd.read_csv(r'E:/xulu备份/高光谱/Indian_pine.csv', header=None)
    data = data.values
    data_D = data[:, :-1]
    data_L = data[:, -1]
    #test_size表示验证集占原始数据的比例
    X_trainval, X_test, y_trainval, y_test = train_test_split(data_D, data_L, test_size=0.2)
    
    # grid search start
    best_score = 0
    for gamma in [0.001]:  # ,0.01,1,10,100,列表可以很多参数,基于时间太长只选一个[0.01,1,10,100]
        for c in [1]:  # 0.001,0.01,,10,100,列表可以很多参数,基于时间太长直选一个[0.001,0.01,,10,100]
            # 对于每种参数可能的组合,进行一次训练
            svm = SVC(gamma=gamma, C=c)
            # 3 折(cv = 3)交叉验证
            scores = cross_val_score(svm, X_trainval, y_trainval, cv=3)
            score = scores.mean()
            # 找到表现最好的参数
            if score > best_score:
                best_score = score
                best_parameters = {'gamma': gamma, "C": c}
    # 使用最佳参数,构建新的模型
    svm = SVC(gamma=best_parameters['gamma'],C=best_parameters['C'])
    # 使用训练集和标签进行训练 
    svm.fit(X_trainval, y_trainval)
    # evalyation 实际模型评估
    test_score = svm.score(X_test, y_test)
    print('Best socre:{:.2f}'.format(best_score))
    print('Best parameters:{}'.format(best_parameters))
    print('Best score on test set:{:.2f}'.format(test_score))
    
    展开全文
  • 超参数优化:网格搜索法

    千次阅读 2020-06-07 21:20:15
    使用Python完成网格搜索法在机器学习和深度学习的小案例!

    网格搜索法在机器学习和深度学习中的使用

    1.项目简介

      在机器学习和深度学习中,经常需要进行超参数优化。其中,网格搜索法在小批量的超参数优化时被经常使用,该项目是一个多分类(26个类别)问题。
      使用Jupyter Notebook完成,代码和数据文件

    2.机器学习案例

    2.1导入相关库

    from sklearn import svm  # 支持向量机库
    import pandas as pd
    from sklearn.model_selection import train_test_split  # 拆分数据集
    from sklearn.model_selection import GridSearchCV  # 网格搜索法
    from sklearn import metrics  # 用于模型评估
    

    2.2导入数据

    filepath = 'E:/Jupyter/Mojin/超参数优化/data/letterdata.csv'
    letters = pd.read_csv(filepath)
    letters.shape
    letters.tail(10)  # 返回数据后10行
    

      运行结果:
    在这里插入图片描述
      可以看到,总共有2万个数据,17个指标,其中,letter为目标变量,其余16个指标为特征变量。

    2.3拆分数据集

    features = letters.columns[1:]
    trainX, valX, trainY, valY = train_test_split(letters[features], letters[['letter']], 
                                                  test_size=0.2, 
                                                  random_state=1234)
    

    2.4网格搜索法

    C = [0.05, 0.1, 0.15, 0.2]
    kernel = ['rbf', 'sigmoid']
    Hyperparameter = dict(C=C, kernel=kernel)  # 将超参数范围包成字典
    
    grid = GridSearchCV(estimator=svm.SVC(),  # 支持向量机中的SVC模型
                        param_grid=Hyperparameter)
    
    # 模型在训练数据集上的拟合
    grid_result = grid.fit(trainX, trainY)
    
    # 返回最佳参数组合
    print('Best:%f using %s' % (grid_result.best_score_, grid_result.best_params_))
    

      运行结果:
    在这里插入图片描述
      可以看到,最佳参数组合:C:‘0.2’,kernel:‘rbf’,准确率:0.914125。

    2.5使用最优参数重新训练模型

    SVC = svm.SVC(kernel='rbf', C=0.2, gamma='scale').fit(trainX, trainY)
    pred = SVC.predict(valX)  # 预测
    print('模型预测的准确率:{0}'.format(metrics.accuracy_score(valY, pred)))
    

      运行结果:
    在这里插入图片描述

    3.深度学习案例

    3.1导入相关库

    from keras.models import Sequential
    from keras.layers import Dense
    from keras.layers import Dropout
    import pandas as pd
    import random  # 随机库
    from sklearn.model_selection import GridSearchCV  # 网格搜索法
    from keras.wrappers.scikit_learn import KerasClassifier  # Keras库分类模型封装器
    from keras.utils.np_utils import to_categorical  # Keras库独热编码
    

      KerasClassifier是将深度模型包装传递给网格搜索法的接口,具体说明见官方文档

    3.2导入数据

    filepath = 'E:/Jupyter/Mojin/超参数优化/data/letterdata.csv'
    letters = pd.read_csv(filepath)
    letters.shape
    letters.tail(10)
    
    # 将letter指标数据类型转换成category
    letter = letters['letter'].astype('category')
    # 使用标签的编码作为真正的数据
    letters['letter'] = letter.cat.codes
    letters.tail(10)
    
    # 提取特征变量并转换成数组格式
    X = letters[letters.columns[1:]].values
    X.shape
    Y = letters[['letter']].values
    Y.shape
    

      运行结果:
    在这里插入图片描述

    # 独热编码
    Y = to_categorical(Y)
    Y.shape
    

      运行结果:
    在这里插入图片描述
      可以看到,经过独热编码Y的维度从1变为26。

    3.3拆分数据集

    random_index = random.sample(list(range(X.shape[0])), X.shape[0])
    train_size = int(X.shape[0] * 0.8)
    train_index = random_index[:train_size]
    test_index = random_index[train_size:]
    
    trainX = X[train_index]
    trainX.shape
    trainY = Y[train_index]
    
    testX = X[test_index]
    testY = Y[test_index]
    

    3.4构造模型

    def create_model(dropout=0.2, depth=2):
        """
        dropout: Dropout层丢弃的比例,一般在0.2~0.5之间
        depth: 模型隐藏层的层数
        """
        model = Sequential()
        if depth < 2:
            raise Exception('至少两层结构')
        else:
            model.add(Dense(units=32, 
                        input_shape=(16,),  # 特征指标个数:16(trainX.shape[1])
                        activation='relu'))
            model.add(Dropout(rate=dropout))  # 防止过拟合
            for i in range(depth - 2):
                model.add(Dense(units=32,
                                    activation='relu'))
            model.add(Dense(units=26,
                            activation='softmax'))
            
            model.compile(loss='categorical_crossentropy',
                      optimizer='rmsprop', 
                      metrics=['accuracy'])
            model.summary()
        return model
    
    model = KerasClassifier(build_fn=create_model)
    

    3.5网格搜索法

    # 构建需要优化的超参数范围
    depth = [3, 4, 5]
    epochs = [30, 50]
    batch_size = [100]
    param_grid = dict(depth=depth,
                      epochs=epochs,
                      batch_size=batch_size)
              
    grid = GridSearchCV(estimator=model, 
                        param_grid=param_grid)  # 默认是cv=3,即3折交叉验证
    grid.fit(trainX, trainY)
    
    # 返回最佳参数组合
    print('Best:%f using %s' % (grid.best_score_, grid.best_params_))
    

      运行结果:
    在这里插入图片描述

    3.6使用最优参数重新训练模型

    model = create_model(depth=4)
    model.fit(trainX, trainY, epochs=50, batch_size=100)
    predict = model.predict(testX)
    loss, acc = model.evaluate(testX, testY)
    print('模型预测的准确率:{0}'.format(acc))
    

      运行结果:
    在这里插入图片描述

    展开全文
  • 比较了现今应用比较广泛的3种支持向量机( SVM)参数优化方法. 具体分析了网格法、遗传算法和粒子群算 法在 SVM参数优化方面的性能以及优缺点,... 实验表明改进的网格搜索法耗时短,更适用于有时间要求的说话人识别应用中.
  • python 网格搜索法调节超参数 import numpy from sklearn.model_selection import GridSearchCV from keras.models import Sequential from keras.layers import Dense from keras.wrappers.scikit_learn import ...

    python 网格搜索法调节超参数

    import numpy
    from sklearn.model_selection import GridSearchCV
    from keras.models import Sequential
    from keras.layers import Dense
    from keras.wrappers.scikit_learn import KerasClassifier
    def create_model():
         model = Sequential()
         model.add(Dense(12,input_dim=8,activation='relu'))
         model.add(Dense(1,activation='sigmoid'))
         #Compile model
         model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])
         return model
     #fix random seed for reproducibility
    seed=7
    numpy.random.seed(seed)
    #load dataset
    dataset=numpy.loadtxt("pima_indians.txt",delimiter=",")
    #split into input(x)and output(y) variables
    x=dataset[:,0:8]
    y=dataset[:,8]
    #create model
    model = KerasClassifier(build_fn=create_model,verbose=0)
    #define the Grid search parameters
    batch_size=[10,20,40,60,80,100]
    epochs=[10,50,100]
    param_grid=dict(batch_size=batch_size,epochs=epochs)
    
    '''
    tune the optimizer
    #model=kerasClassifier(build_fn=create_model,epochs=100,batch_size=10,verbose=0)
    #optimizer = ['SGD','RMSprop','Adagrad','Adadelta','Adam','Adamax','Nadam']
    #param_grid=dict(optimizer=optimizer)
    ##tune the learning rate and momentum
    #model=KerasClassifier(build_fn=create_model,epochs=100,batch_size=10,verbose=0)
    #learn_rate=[0.001,0.01,0.1,0.2,0.3]
    #momentum=[0.0,0.2,0.4,0.6,0.8,0.9]
    #param_grid=dict(learn_rate=learn_rate,momentum=momentum)
    '''
    grid=GridSearchCV(estimator=model,param_grid=param_grid,n_jobs=1,cv=3)
    grid_result =grid.fit(x,y)
    #summarize results
    print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
    means = grid_result.cv_results_['mean_test_score']
    stds = grid_result.cv_results_['std_test_score']
    params = grid_result.cv_results_['params']
    for mean, stdev, param in zip(means, stds, params):
        print("%f (%f) with: %r" % (mean, stdev, param))
    
    展开全文
  • 为了提高煤矿主扇风机故障诊断的准确性,将网格搜索法和支持向量机(SVM)应用到主扇风机的故障诊断中。首先,建立主扇风机运行故障的知识库,并将采集到的主扇风机振动信号进行小波消澡和归一化;然后,设计了网格搜索参数...
  • 网格搜索法在机器学习和深度学习中的小案例,使用Jupyter,压缩包包括: (1)data:letterdata.csv (2)Hyperparameter optimization.ipynb
  • 比较了现今应用比较广泛的3种支持向量机(SVM)参数优化方法. 具体分析了网格法、遗传算法和粒子群算法在SVM参数优化方面的性能以及优缺点... 实验表明改进的网格搜索法耗时短,更适用于有时间要求的说话人识别应用中.
  • 机器学习-sklearn网格搜索法

    千次阅读 2017-06-18 20:48:11
    网格搜索法可以用来寻找合适的参数,尝试所有可能的参数组合。sklearn提供的GridSearchCV类,可以通过字典来提供分类器或回归器的类型对象。字典的键我们将要调整的参数,而字典的值就是需要尝试的参数值的相应列表...
  • 网格搜索法--求公切线算法。Mathematica程序。
  • 一种改进的网格搜索法在基于PCA和SVM人脸识别技术中的应用,张龙,马敏,近年来,PCA和SVM算法因其在人脸识别中表现出的良好识别率而倍受关注。PCA通过特征提取能够达到降维的目的,SVM作为统计模式识别领域

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 437
精华内容 174
关键字:

网格搜索法