精华内容
下载资源
问答
  • 然后,设计了网格搜索参数优化SVM的主扇风机故障诊断模型。最后,通过工程现场提取的数据进行实验验证,并与遗传算法和粒子群算法寻优的时间和诊断结果准确率进行比较。实验结果表明,网格搜索法SVM参数优化非常适合于...
  • 使用网格搜索优化模型参数

    千次阅读 2019-10-04 12:19:30
    ############################# 使用网格搜索优化模型参数 ####################################### #导入套索回归模型 from sklearn.linear_model import Lasso #导入数据集拆分工具 from skle...

    1.简单网格搜索法

    • Lasso算法中不同的参数调整次数

    #############################  使用网格搜索优化模型参数 #######################################
    #导入套索回归模型
    from sklearn.linear_model import Lasso
    #导入数据集拆分工具
    from sklearn.model_selection import train_test_split
    #导入红酒数据集
    from sklearn.datasets import load_wine
    #载入红酒数据集
    wine = load_wine()
    #将数据集差分为训练集与测试集
    X_train,X_test,y_train,y_test = train_test_split(wine.data,wine.target,random_state=38)
    #设置初始分数为0
    best_score = 0
    #设置alpha参数遍历0.01,0.1,1,10
    for alpha in [0.01,0.1,1.0,10.0]:
        #最大迭代数遍历100,1000,5000,10000
        for max_iter in [100,1000,5000,10000]:
            lasso = Lasso(alpha=alpha,max_iter=max_iter)
            #训练套索回归模型
            lasso.fit(X_train,y_train)
            score = lasso.score(X_test,y_test)
            #令最佳分数为所有分数中的最高值
            if score > best_score:
                best_score = score
                #定义字典,返回最佳参数和最佳最大迭代数
                best_parameters = {'alpha':alpha,'最大迭代次数':max_iter}
    
    #打印结果
    print('模型最高分为:{:.3f}'.format(best_score))
    print('最佳参数设置:{}'.format(best_parameters))
    
    模型最高分为:0.889
    最佳参数设置:{'alpha': 0.01, '最大迭代次数': 100}
    #将数据集差分为训练集与测试集
    X_train,X_test,y_train,y_test = train_test_split(wine.data,wine.target,random_state=0)
    #设置初始分数为0
    best_score = 0
    #设置alpha参数遍历0.01,0.1,1,10
    for alpha in [0.01,0.1,1.0,10.0]:
        #最大迭代数遍历100,1000,5000,10000
        for max_iter in [100,1000,5000,10000]:
            lasso = Lasso(alpha=alpha,max_iter=max_iter)
            #训练套索回归模型
            lasso.fit(X_train,y_train)
            score = lasso.score(X_test,y_test)
            #令最佳分数为所有分数中的最高值
            if score > best_score:
                best_score = score
                #定义字典,返回最佳参数和最佳最大迭代数
                best_parameters = {'alpha':alpha,'最大迭代次数':max_iter}
    
    #打印结果
    print('模型最高分为:{:.3f}'.format(best_score))
    print('最佳参数设置:{}'.format(best_parameters))
    
    模型最高分为:0.830
    最佳参数设置:{'alpha': 0.1, '最大迭代次数': 100}

    2.与交叉验证结合的网格搜索

    #导入numpy
    import numpy as np
    #导入交叉验证工具
    from sklearn.model_selection import cross_val_score
    #设置alpha参数遍历0.01,0.1,1,10
    for alpha in [0.01,0.1,1.0,10.0]:
        #最大迭代数遍历100,1000,5000,10000
        for max_iter in [100,1000,5000,10000]:
            lasso = Lasso(alpha=alpha,max_iter=max_iter)
            #训练套索回归模型
            lasso.fit(X_train,y_train)
            scores = cross_val_score(lasso,X_train,y_train,cv=6)
            score = np.mean(scores)
            if score > best_score:
                best_score = score
                #定义字典,返回最佳参数和最佳最大迭代数
                best_parameters = {'alpha':alpha,'最大迭代次数':max_iter}
    
    #打印结果
    print('模型最高分为:{:.3f}'.format(best_score))
    print('最佳参数设置:{}'.format(best_parameters))
    
    模型最高分为:0.865
    最佳参数设置:{'alpha': 0.01, '最大迭代次数': 100}
    #用最佳参数模型拟合数据
    lasso = Lasso(alpha=0.01,max_iter=100).fit(X_train,y_train)
    #打印测试数据集得分
    print('测试数据集得分:{:.3f}'.format(lasso.score(X_test,y_test)))
    
    测试数据集得分:0.819
    #导入网格搜索工具
    from sklearn.model_selection import GridSearchCV
    #将需要遍历的参数定义为字典
    params = {'alpha':[0.01,0.1,1.0,10.0],'max_iter':[100,1000,5000,10000]}
    #定义网格搜索中使用的模型和参数
    grid_search = GridSearchCV(lasso,params,cv=6,iid=False)
    #使用网格搜索模型拟合数据
    grid_search.fit(X_train,y_train)
    #打印结果
    print('模型最高分:{:.3f}'.format(grid_search.score(X_test,y_test)))
    print('最有参数:{}'.format(grid_search.best_params_))
    
    模型最高分:0.819
    最有参数:{'alpha': 0.01, 'max_iter': 100}
    #打印网格搜索中的best_score_属性
    print('交叉验证最高得分:{:.3f}'.format(grid_search.best_score_))
    
    交叉验证最高得分:0.865

    总结 :  

    • GridSearchCV本身就是将交叉验证和网格搜索封装在一起的方法.
    • GridSearchCV虽然是个非常强悍的功能,但是由于需要反复建模,因此所需要的计算时间更长.

     

    文章引自 : 《深入浅出python机器学习》

    转载于:https://www.cnblogs.com/weijiazheng/p/10966005.html

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

    千次阅读 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参数优化方面的性能以及优缺点... 实验表明改进的网格搜索法耗时短,更适用于有时间要求的说话人识别应用中.
  • 网格搜索 C++实现 机器暴力参数优化: 参数设置和实现原理见下图,后面附带C++源码(个人原创),帮助解决C++程序参数优化问题。 一般放那跑一夜,最好的参数就出来了,哈哈,还是比较方便滴。 有问题记得留言...

    网格搜索 C++实现 机器暴力参数优化:

    参数设置和实现原理见下图,后面附带C++源码(个人原创),帮助解决C++程序参数优化问题。

    一般放那跑一夜,最好的参数就出来了,哈哈,还是比较方便滴。

    有问题记得留言讨论。。

    class JrGrid
    {
    public:
    	JrGrid() 
    	{
    		/* --搜索初始化设置-- */
    		m_para_num = 3; // 参数个数
    		m_iter = 10;	// 迭代次数
    		m_parts = 5;	// 每次迭代的搜索分片数
    		m_upper = new double[m_para_num];
    		m_lower = new double[m_para_num];
    		set_lower_and_upper(0, 10, 15); // 设置第1个参数的下限是10 上限是15
    		set_lower_and_upper(1, 1, 5000);// 设置第2个参数的下限是1 上限是5000
    		set_lower_and_upper(2, 5, 10);  // 设置第3个参数的下限是5 上限是10
    	}
    private:
    	/* --将你的代码写到这个函数里,从para中获取参数,返回其得分(默认选择得分高的参数组合)-- */
    	double validate(double *para);
    public:
    	~JrGrid() { delete m_upper; delete m_lower; delete m_score; delete m_paras; }
    	/* --调用此函数启动网格搜索-- */
    	void do_grid_search() 
    	{
    		int size = (int)pow(m_parts + 1, m_para_num);
    		m_score = new double[size];
    		m_paras = new double[size*m_para_num];
    		for (int i = 0; i < m_iter; i++) {
    			std::cout <<"GS ITER "<<i+1<<" -->"<<std::endl;
    			double *para = new double[m_para_num];
    			double *delta = new double[m_para_num];
    			for (int j = 0; j < m_para_num; j++) {
    				delta[j] = (m_upper[j] - m_lower[j]) / m_parts;
    				para[j] = m_lower[j];
    			}
    			m_count_para = 0;
    			m_count_part = 0;
    			m_count_s = 0;
    			iter_search2(para, delta, 0);
    			double set = -9999999.0;
    			int locate = 0;
    			for (int j = 0; j < size; j++) {
    				if (m_score[j] > set) {
    					locate = j;
    					set = m_score[j];
    				}
    			}
    			for (int j = 0; j < m_para_num; j++) {
    				std::cout <<"para"<<j+1<<"="<< m_paras[locate*m_para_num + j]<<",";
    				double next_lower = m_paras[locate*m_para_num + j] - delta[j];
    				if (next_lower > m_lower[j]) {
    					m_lower[j] = next_lower;
    				}
    				double next_upper = m_paras[locate*m_para_num + j] + delta[j];
    				if (next_upper < m_upper[j]) {
    					m_upper[j] = next_upper;
    				}
    			}
    
    			std::cout <<"score="<< set << std::endl;
    			delete para;
    			delete delta;
    		}
    	}
    private:
    	void iter_search2(double *para, double *delta, int layer)
    	{
    		if (layer == m_para_num) {
    			m_score[m_count_s] = validate(para);
    			for (int j = 0; j < m_para_num; j++) {
    				m_paras[m_count_s*m_para_num + j] = para[j];
    			}
    			m_count_s++;
    		}
    		else {
    			for (int i = 0; i <= m_parts; i++) {
    				double *spara = new double[m_para_num];
    				memcpy(spara, para, m_para_num*sizeof(double));
    				spara[layer] += i*delta[layer];
    				iter_search2(spara, delta, layer + 1);
    				delete spara;
    			}
    		}
    	}
    	void set_lower_and_upper(int para_i, double low, double up) { m_lower[para_i] = low; m_upper[para_i] = up; }
    private:
    	int m_para_num;
    	int m_iter;
    	int m_parts;
    	double *m_upper;
    	double *m_lower;
    	int m_count_para;
    	int m_count_part;
    	int m_count_s;
    	double *m_score;
    	double *m_paras;
    };


    展开全文
  • 全栈工程师开发手册 (作者:栾鹏) python数据挖掘系列教程 优化的相关的知识内容可以参考 ...网格搜索GridSearchCV GridSearchCV用于系统地遍历多种参数组合,通过交叉验证确定最佳效果参数。 classskle...

    分享一个朋友的人工智能教程。零基础!通俗易懂!风趣幽默!还带黄段子!大家可以看看是否对自己有帮助:点击打开


    ad1.jpg

    全栈工程师开发手册 (作者:栾鹏)
    python数据挖掘系列教程

    优化的相关的知识内容可以参考
    https://blog.csdn.net/luanpeng825485697/article/details/78765923

    网格搜索GridSearchCV

    GridSearchCV用于系统地遍历多种参数组合,通过交叉验证确定最佳效果参数。

    classsklearn.model_selection.GridSearchCV(estimator,param_grid, scoring=None, fit_params=None, n_jobs=1, iid=True, refit=True,cv=None, verbose=0, pre_dispatch='2*n_jobs', error_score='raise',return_train_score=True)
    

    常用参数解读

    estimator:所使用的分类器,如estimator=RandomForestClassifier(min_samples_split=100,min_samples_leaf=20,max_depth=8,max_features='sqrt',random_state=10), 并且传入除需要确定最佳的参数之外的其他参数。每一个分类器都需要一个scoring参数,或者score方法。

    param_grid:值为字典或者列表,即需要最优化的参数的取值,param_grid =param_test1,param_test1 = {'n_estimators':range(10,71,10)}。

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

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

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

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

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

    n_jobs: 并行数,int:个数,-1:跟CPU核数一致, 1:默认值。

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

    随机参数优化RandomizedSearchCV

    尽管使用参数设置的网格法是目前最广泛使用的参数优化方法, 其他搜索方法也具有更有利的性能。 RandomizedSearchCV 实现了对参数的随机搜索, 其中每个设置都是从可能的参数值的分布中进行取样。 这对于穷举搜索有两个主要优势:

    • 可以选择独立于参数个数和可能值的预算
    • 添加不影响性能的参数不会降低效率

    指定如何取样的参数是使用字典完成的, 非常类似于为 GridSearchCV 指定参数。 此外, 通过 n_iter 参数指定计算预算, 即取样候选项数或取样迭代次数。 对于每个参数, 可以指定在可能值上的分布或离散选择的列表 (均匀取样):

    {'C': scipy.stats.expon(scale=100), 'gamma': scipy.stats.expon(scale=.1),
      'kernel': ['rbf'], 'class_weight':['balanced', None]}
    

    搜索的输出值

    cv_results_:给出不同参数情况下的评价结果的记录

    best_params_:描述了已取得最佳结果的参数的组合

    best_score_:成员提供优化过程期间观察到的最好的评分

    from sklearn.datasets import load_iris  # 自带的样本数据集
    from sklearn.neighbors import KNeighborsClassifier  # 要估计的是knn里面的参数,包括k的取值和样本权重分布方式
    import matplotlib.pyplot as plt  # 可视化绘图
    from sklearn.model_selection import GridSearchCV,RandomizedSearchCV  # 网格搜索和随机搜索
    
    iris = load_iris()
    
    X = iris.data  # 150个样本,4个属性
    y = iris.target # 150个类标号
    
    k_range = range(1, 31)  # 优化参数k的取值范围
    weight_options = ['uniform', 'distance']  # 代估参数权重的取值范围。uniform为统一取权值,distance表示距离倒数取权值
    # 下面是构建parameter grid,其结构是key为参数名称,value是待搜索的数值列表的一个字典结构
    param_grid = {'n_neighbors':k_range,'weights':weight_options}  # 定义优化参数字典,字典中的key值必须是分类算法的函数的参数名
    print(param_grid)
    
    knn = KNeighborsClassifier(n_neighbors=5)  # 定义分类算法。n_neighbors和weights的参数名称和param_grid字典中的key名对应
    
    
    # ================================网格搜索=======================================
    # 这里GridSearchCV的参数形式和cross_val_score的形式差不多,其中param_grid是parameter grid所对应的参数
    # GridSearchCV中的n_jobs设置为-1时,可以实现并行计算(如果你的电脑支持的情况下)
    grid = GridSearchCV(estimator = knn, param_grid = param_grid, cv=10, scoring='accuracy') #针对每个参数对进行了10次交叉验证。scoring='accuracy'使用准确率为结果的度量指标。可以添加多个度量指标
    grid.fit(X, y)
    
    print('网格搜索-度量记录:',grid.cv_results_)  # 包含每次训练的相关信息
    print('网格搜索-最佳度量值:',grid.best_score_)  # 获取最佳度量值
    print('网格搜索-最佳参数:',grid.best_params_)  # 获取最佳度量值时的代定参数的值。是一个字典
    print('网格搜索-最佳模型:',grid.best_estimator_)  # 获取最佳度量时的分类器模型
    
    
    # 使用获取的最佳参数生成模型,预测数据
    knn = KNeighborsClassifier(n_neighbors=grid.best_params_['n_neighbors'], weights=grid.best_params_['weights'])  # 取出最佳参数进行建模
    knn.fit(X, y)  # 训练模型
    print(knn.predict([[3, 5, 4, 2]]))  # 预测新对象
    
    
    
    # =====================================随机搜索===========================================
    rand = RandomizedSearchCV(knn, param_grid, cv=10, scoring='accuracy', n_iter=10, random_state=5)  #
    rand.fit(X, y)
    
    print('随机搜索-度量记录:',grid.cv_results_)  # 包含每次训练的相关信息
    print('随机搜索-最佳度量值:',grid.best_score_)  # 获取最佳度量值
    print('随机搜索-最佳参数:',grid.best_params_)  # 获取最佳度量值时的代定参数的值。是一个字典
    print('随机搜索-最佳模型:',grid.best_estimator_)  # 获取最佳度量时的分类器模型
    
    
    # 使用获取的最佳参数生成模型,预测数据
    knn = KNeighborsClassifier(n_neighbors=grid.best_params_['n_neighbors'], weights=grid.best_params_['weights'])  # 取出最佳参数进行建模
    knn.fit(X, y)  # 训练模型
    print(knn.predict([[3, 5, 4, 2]]))  # 预测新对象
    
    
    # =====================================自定义度量===========================================
    from sklearn import metrics
    # 自定义度量函数
    def scorerfun(estimator, X, y):
        y_pred = estimator.predict(X)
        return metrics.accuracy_score(y, y_pred)
    
    rand = RandomizedSearchCV(knn, param_grid, cv=10, scoring='accuracy', n_iter=10, random_state=5)  #
    rand.fit(X, y)
    
    print('随机搜索-最佳度量值:',grid.best_score_)  # 获取最佳度量值
    
    

    当你的调节参数是连续的,比如回归问题的正则化参数,有必要指定一个连续分布而不是可能值的列表,这样RandomizeSearchCV就可以执行更好的grid search。

    Scoring Function Comment
    Classification
    ‘accuracy’ metrics.accuracy_score
    ‘average_precision’ metrics.average_precision_score
    ‘f1’ metrics.f1_score for binary targets
    ‘f1_micro’ metrics.f1_score micro-averaged
    ‘f1_macro’ metrics.f1_score macro-averaged
    ‘f1_weighted’ metrics.f1_score weighted average
    ‘f1_samples’ metrics.f1_score by multilabel sample
    ‘neg_log_loss’ metrics.log_loss requires predict_proba support
    ‘precision’ etc. metrics.precision_score suffixes apply as with ‘f1’
    ‘recall’ etc. metrics.recall_score suffixes apply as with ‘f1’
    ‘roc_auc’ metrics.roc_auc_score
    Clustering
    ‘adjusted_rand_score’ metrics.adjusted_rand_score
    ‘adjusted_mutual_info_score’ metrics.adjusted_mutual_info_score
    ‘completeness_score’ metrics.completeness_score
    ‘fowlkes_mallows_score’ metrics.fowlkes_mallows_score
    ‘homogeneity_score’ metrics.homogeneity_score
    ‘mutual_info_score’ metrics.mutual_info_score
    ‘normalized_mutual_info_score’ metrics.normalized_mutual_info_score
    ‘v_measure_score’ metrics.v_measure_score
    Regression
    ‘explained_variance’ metrics.explained_variance_score
    ‘neg_mean_absolute_error’ metrics.mean_absolute_error
    ‘neg_mean_squared_error’ metrics.mean_squared_error
    ‘neg_mean_squared_log_error’ metrics.mean_squared_log_error
    ‘neg_median_absolute_error’ metrics.median_absolute_error
    ‘r2’ metrics.r2_score

    如果没有我们想要的度量字符串表达,我们可以自定义度量函数,将函数名设置为scoring参数的值。函数名必须为

    # 自定义度量函数
    def scorerfun(estimator, X, y):
    	。。。
        return 。。
    

    python调参神器hyperopt

    Hyperopt库为python中的模型选择和参数优化提供了算法和并行方案。

    给一段代码,一看就明白

    from sklearn.model_selection import cross_val_score
    import pickle
    from hyperopt import fmin, tpe, hp,space_eval,rand,Trials,partial,STATUS_OK
    from xgboost.sklearn import XGBClassifier
    import xgboost as xgb
    
    # 定义一个目标函数,接受一个变量,计算后返回一个函数的损失值,
    def GBM(argsDict):
        max_depth = argsDict["max_depth"] + 5
        n_estimators = argsDict['n_estimators'] * 5 + 50
        learning_rate = argsDict["learning_rate"] * 0.02 + 0.05
        subsample = argsDict["subsample"] * 0.1 + 0.7
        min_child_weight = argsDict["min_child_weight"]+1
        global attr_train,label_train
    
        gbm = xgb.XGBClassifier(nthread=4,    #进程数
                                max_depth=max_depth,  #最大深度
                                n_estimators=n_estimators,   #树的数量
                                learning_rate=learning_rate, #学习率
                                subsample=subsample,      #采样数
                                min_child_weight=min_child_weight,   #孩子数
                                max_delta_step = 10,  #10步不降则停止
                                objective="binary:logistic")
    
        metric = cross_val_score(gbm,attr_train,label_train,cv=5,scoring="roc_auc").mean()
        print(metric)
        return -metric
    
    # 定义参数的搜索空间
    
    space = {"max_depth":hp.randint("max_depth",15),
             "n_estimators":hp.randint("n_estimators",10),  #[0,1,2,3,4,5] -> [50,]
             "learning_rate":hp.randint("learning_rate",6),  #[0,1,2,3,4,5] -> 0.05,0.06
             "subsample":hp.randint("subsample",4),#[0,1,2,3] -> [0.7,0.8,0.9,1.0]
             "min_child_weight":hp.randint("min_child_weight",5), #
            }
    algo = partial(tpe.suggest,n_startup_jobs=1)  # 定义随机搜索算法。搜索算法本身也有内置的参数决定如何去优化目标函数
    best = fmin(GBM,space,algo=algo,max_evals=4)  # 对定义的参数范围,调用搜索算法,对模型进行搜索
    
    print(best)
    print(GBM(best))
    

    关于参数空间的设置,比如优化函数q,输入fmin(q,space=hp.uniform(‘a’,0,1))
    hp.uniform函数的第一个参数是标签,每个超参数在参数空间内必须具有独一无二的标签。

    • hp.choice返回一个选项,选项可以是list或者tuple.options可以是嵌套的表达式,用于组成条件参数。
    • hp.pchoice(label,p_options)以一定的概率返回一个p_options的一个选项。这个选项使得函数在搜索过程中对每个选项的可能性不均匀。
    • hp.uniform(label,low,high)参数在low和high之间均匀分布。
    • hp.quniform(label,low,high,q),参数的取值是round(uniform(low,high)/q)*q,适用于那些离散的取值。
    • hp.loguniform(label,low,high)绘制exp(uniform(low,high)),变量的取值范围是[exp(low),exp(high)]
    • hp.randint(label,upper) 返回一个在[0,upper)前闭后开的区间内的随机整数。
    展开全文
  • 提出了一种基于袋外数据估计的分类误差,利用改进的网格搜索算法对随机森林算法中的决策树数量和候选分裂属性数进行参数优化的随机森林算法。仿真结果表明,利用该方法优化得到的参数都能够使随机森林的分类效果得到...
  • ML模型超参数调节:网格搜索、随机搜索与贝叶斯优化 贝叶斯优化: 一种更好的超参数调优方式 Theroy: 贝叶斯优化/Bayesian Optimization Compare with code in detail: 用贝叶斯优化进行超参数调优 随机搜索...
  • 文章目录一、超参二、网格搜索 GridSearchCV三、随机搜索 RandomizedSearchCV四、自动超参搜索:遗传算法(GA) 一、超参 学习器模型中一般有两类参数,一类是可以从数据中学习估计得到,我们称为参数(Parameter)...
  • 在进行机器学习的过程中,最为核心的一个概念就是参数,而参数又分为模型参数与超参数。模型参数,顾名思义就是我们使用的模型根据训练数据的...通常情况下,常用的超参数调参的方法有:网格搜索,随机搜索与贝叶...
  • Overview In this post I want to show you both how you can use the scikit-learn grid search capabilit...

空空如也

空空如也

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

网格搜索参数优化