精华内容
下载资源
问答
  • 自动调参hyperopt可用tpe算法自动调参,实测强于随机调参。 hyperopt 需要自己写个输入参数,返回模型分数的函数(只能求最小化,如果分数是求最大化的,加个负号),设置参数空间。 本来最优参数fmin函数会自己...
    在此之前,调参要么网格调参,要么随机调参,要么肉眼调参。虽然调参到一定程度,进步有限,但仍然很耗精力。 自动调参库hyperopt可用tpe算法自动调参,实测强于随机调参。 hyperopt 需要自己写个输入参数,返回模型分数的函数(只能求最小化,如果分数是求最大化的,加个负号),设置参数空间。 本来最优参数fmin函数会自己输出的,但是出了意外,参数会强制转化整数,没办法只好自己动手了。 demo如下: import lightgbm as lgb from sklearn.metrics import roc_auc_score as auc def get_set(n1,data='trained.csv',n_splits=10,y=False,random_state=0): from sklearn.model_selection import KFold data=pd.read_csv(data) kf = KFold(n_splits=n_splits,shuffle=True,random_state=random_state) if y: train,test=pd.DataFrame(),pd.DataFrame() clas=list(data[y].unique()) for cla in clas: i=0 dd=data[data[y]==cla] for train_index,test_index in kf.split(dd): i=i+1 if n1==i: train=train.append(data.loc[list(train_index)]) test=test.append(data.loc[list(test_index)]) else: i=0 for train_index,test_index in kf.split(data): i=i+1 if n1==i: train=data.iloc[list(train_index),:] test=data.iloc[list(test_index),:] return train,test def scorer(yp,data): yt= data.get_label() score=auc(yt,yp) return 'auc',score,True def peropt(param): conf=['num_leaves','max_depth','min_child_samples','max_bin'] for i in conf: param[i]=int(param[i]) evals_result={} lgb.train(param, dtrain, 2000, feval=scorer, valid_sets=[dval], verbose_eval=None, evals_result=evals_result, early_stopping_rounds=10) best_score=evals_result['valid_0']['auc'][-11] #print(param,best_score,len(evals_result['valid_0']['auc'])-10) result.append((param,best_score,len(evals_result['valid_0']['auc'])-10)) return -best_score if 0:#数据集 i=1 x_train,x_test=get_set(i,n_splits=5) x_train.pop('CaseId') x_test.pop('CaseId') y_train=x_train.pop('Evaluation') y_test=x_test.pop('Evaluation') dtrain=lgb.Dataset(x_train,y_train) dval=lgb.Dataset(x_test,y_test) if 1:#调参 from hyperopt import fmin,tpe,hp#,rand#,pyll#,partial space={ 'num_leaves': hp.quniform('num_leaves',50,70,1) ,'max_depth':hp.quniform('max_depth',7,15,1) ,'min_child_samples':hp.quniform('min_child_samples',5,20,1) ,'max_bin':hp.quniform('max_bin',100,150,5) ,'learning_rate':hp.choice('learning_rate',[0.01]) ,'subsample':hp.uniform('subsample',0.9,1) ,'colsample_bytree':hp.uniform('colsample_bytree',0.95,1) ,'min_split_gain':hp.loguniform('min_split_gain',-5,2) ,'reg_alpha':hp.loguniform('reg_alpha',-5,2) ,'reg_lambda':hp.loguniform('reg_lambda',-5,2) } result=[] #print(pyll.stochastic.sample(space))#抽样 #algo=partial(tpe.suggest,n_startup_jobs=10)#作用未知 fmin(peropt, space=space, algo=tpe.suggest, max_evals=100 ) sort=sorted(result,key=lambda x:x[1],reverse=True)

    转载于:https://www.cnblogs.com/offline-ant/p/9928839.html

    展开全文
  • hyperopt自动调参

    2018-10-22 20:05:00
    hyperopt自动调参 在传统机器学习和深度学习领域经常需要调参,调参有些是通过通过对数据和算法的理解进行的,这当然是上上策,但还有相当一部分属于"黑盒" hyperopt可以帮助我们做很多索然无味的调参工作 示例 直接...

    hyperopt自动调参

    在传统机器学习和深度学习领域经常需要调参,调参有些是通过通过对数据和算法的理解进行的,这当然是上上策,但还有相当一部分属于"黑盒"

    hyperopt可以帮助我们做很多索然无味的调参工作

    示例

    直接看代码以及注释比较直接,下面通过一个随机森林可以感受一下:

    # coding=utf-8
    
    from sklearn import datasets
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.cross_validation import cross_val_score
    from sklearn.preprocessing import scale, normalize
    from hyperopt import hp, STATUS_OK, Trials, fmin, tpe
    
    
    iris = datasets.load_iris()
    X = iris.data
    y = iris.target
    
    
    def hyperopt_train_test(params):
        X_ = X[:]
        # 这里可以自定义一些操作
        if params['normalize']:
            X_ = normalize(X_)
        if params['scale']:
            X_ = scale(X_)
    
        del params['normalize']
        del params['scale']
    
        clf = RandomForestClassifier(**params)
        # 交叉验证
        return cross_val_score(clf, X, y, cv=10).mean()
    
    
    space_rf = {
        'max_depth': hp.choice('max_depth', range(1, 20)),
        'max_features': hp.choice('max_features', range(1, 5)),
        'n_estimators': hp.choice('n_estimators', range(1, 20)),
        'criterion': hp.choice('criterion', ["gini", "entropy"]),
        'scale': hp.choice('scale', [True, False]),
        'normalize': hp.choice('normalize', [True, False])
    }
    
    
    # 待优化目标函数
    def f(params):
        acc = hyperopt_train_test(params)
        return {'loss': -acc, 'status': STATUS_OK}
    
    
    trials = Trials()
    best = fmin(f,  # 待最小化函数
                space=space_rf,  # 参数所搜索空间
                algo=tpe.suggest,  # 算法选择,这里选择了TPE,也可以用rand.suggest等
                max_evals=50,  #  迭代次数
                trials=trials,  # 可以用trials数组记录中间结果
                )
    
    # best是loss最小的参数组合
    # 对于离散值,如criterion,会返回选择的元素索引
    print(best)
    loss = []
    for trial in trials.results:
        loss.append(trial['loss'])
    print(min(loss))

    运行输出

    {'normalize': 1, 'scale': 0, 'n_estimators': 14, 'criterion': 1, 'max_features': 1, 'max_depth': 11}
    -0.973333333333

    小结

    hyperopt还有很多高阶用法,如借助mongo并行化,但基本的使用架构上面的demo应该已经很好的体现了

    超参调优是一个很大的问题,很多启发式算法会被采用,如数学建模中的一些优化算法

    转载于:https://www.cnblogs.com/fanghao/p/9832403.html

    展开全文
  • 如何使用hyperopt对Lightgbm进行自动调参之前的教程以及介绍过如何使用hyperopt对xgboost进行调参,并且已经说明了,该代码模板可以十分轻松的转移到lightgbm,或者catboost上。而本篇教程就是对原模板的一次迁移,...

    77bcdd6a49393173ed84c3654cb9f962.png

    如何使用hyperopt对Lightgbm进行自动调参

    之前的教程以及介绍过如何使用hyperopt对xgboost进行调参,并且已经说明了,该代码模板可以十分轻松的转移到lightgbm,或者catboost上。而本篇教程就是对原模板的一次迁移,前半部分为教程-如何使用hyperopt对xgboost进行自动调参的迁移,后半部分是对在Hyperopt框架下使用XGboost与交叉验证的迁移。

    关于Hyperopt

    Hyperopt:是python中的一个用于"分布式异步算法组态/超参数优化"的类库。使用它我们可以拜托繁杂的超参数优化过程,自动获取最佳的超参数。广泛意义上,可以将带有超参数的模型看作是一个必然的非凸函数,因此hyperopt几乎可以稳定的获取比手工更加合理的调参结果。尤其对于调参比较复杂的模型而言,其更是能以远快于人工调参的速度同样获得远远超过人工调参的最终性能。

    目前中文文档的地址由本人FontTian在2017年翻译,但是hyperopt文档本身确实写的不怎么样。所以才有了这份教程。源代码请前往Github教程地址下载下载。

    • 中文文档地址
    • FontTian的博客
    • Hyperopt官方文档地址

    迁移一:自动调参

    获取数据

    这里我们使用UCI的红酒质量数据集,除此之外我还额外增加了两个特征。

    import numpy as np
    import pandas as pd
    
    def GetNewDataByPandas():
        wine = pd.read_csv("/home/fonttian/Data/UCI/wine/wine.csv")
        wine['alcohol**2'] = pow(wine["alcohol"], 2)
        wine['volatileAcidity*alcohol'] = wine["alcohol"] * wine['volatile acidity']
        y = np.array(wine.quality)
        X = np.array(wine.drop("quality", axis=1))
    
        columns = np.array(wine.columns)
    
        return X, y, columns

    分割数据并转换

    首先将数据分割为三份,一部分用于预测,训练数据则同样分成额外的两部分用于evallist参数。

    同时为了加快速度和减少内存,我们将数据转换为lightgbm自带的读取格式。

    from sklearn.model_selection import train_test_split
    # Read wine quality data from file
    X, y, wineNames = GetNewDataByPandas()
    
    # split data to [[0.8,0.2],01]
    x_train_all, x_predict, y_train_all, y_predict = train_test_split(X, y, test_size=0.10, random_state=100)
    
    x_train, x_test, y_train, y_test = train_test_split(x_train_all, y_train_all, test_size=0.2, random_state=100)
    
    import lightgbm as lgb
    
    train_data = lgb.Dataset(data=x_train,label=y_train)
    test_data = lgb.Dataset(data=x_test,label=y_test)

    定义参数空间

    使用hyperopt自带的函数定义参数空间,但是因为其randint()方法产生的数组范围是从0开始的,所以我额外定义了一个数据转换方法,对原始参数空间进行一次转换。

    关于hyperopt中定义参数区间需要使用的函数请参考: - 中文地址,请点击这里 - 英文地址,请点击这里

    from hyperopt import fmin, tpe, hp, partial
    
    # 自定义hyperopt的参数空间
    space = {"max_depth": hp.randint("max_depth", 15),
             "num_trees": hp.randint("num_trees", 300),
             'learning_rate': hp.uniform('learning_rate', 1e-3, 5e-1),
             "bagging_fraction": hp.randint("bagging_fraction", 5),
             "num_leaves": hp.randint("num_leaves", 6),
             }
    
    def argsDict_tranform(argsDict, isPrint=False):
        argsDict["max_depth"] = argsDict["max_depth"] + 5
        argsDict['num_trees'] = argsDict['num_trees'] + 150
        argsDict["learning_rate"] = argsDict["learning_rate"] * 0.02 + 0.05
        argsDict["bagging_fraction"] = argsDict["bagging_fraction"] * 0.1 + 0.5
        argsDict["num_leaves"] = argsDict["num_leaves"] * 3 + 10
        if isPrint:
            print(argsDict)
        else:
            pass
    
        return argsDict

    创建模型工厂与分数获取器

    lightgbm模型工厂用于生产我们需要的model,而分数获取器则是为了解耦。这样在实际的测试工作中可以更加方便地套用代码。

    from sklearn.metrics import mean_squared_error
    
    def lightgbm_factory(argsDict):
        argsDict = argsDict_tranform(argsDict)
    
        params = {'nthread': -1,  # 进程数
                  'max_depth': argsDict['max_depth'],  # 最大深度
                  'num_trees': argsDict['num_trees'],  # 树的数量
                  'eta': argsDict['learning_rate'],  # 学习率
                  'bagging_fraction': argsDict['bagging_fraction'],  # 采样数
                  'num_leaves': argsDict['num_leaves'],  # 终点节点最小样本占比的和
                  'objective': 'regression',
                  'feature_fraction': 0.7,  # 样本列采样
                  'lambda_l1': 0,  # L1 正则化
                  'lambda_l2': 0,  # L2 正则化
                  'bagging_seed': 100,  # 随机种子,light中默认为100
                  }
        params['metric'] = ['rmse']
    
        model_lgb = lgb.train(params, train_data, num_boost_round=300, valid_sets=[test_data],early_stopping_rounds=100)
    
        return get_tranformer_score(model_lgb)
    
    def get_tranformer_score(tranformer):
    
        model = tranformer
        prediction = model.predict(x_predict, num_iteration=model.best_iteration)
    
        return mean_squared_error(y_predict, prediction)

    调用Hyperopt开始调参

    之后我们调用hyperopt进行自动调参即可,同时通过返回值获取最佳模型的结果。

    # 开始使用hyperopt进行自动调参
    algo = partial(tpe.suggest, n_startup_jobs=1)
    best = fmin(lightgbm_factory, space, algo=algo, max_evals=20, pass_expr_memo_ctrl=None)
    /home/fonttian/anaconda3/lib/python3.6/site-packages/lightgbm/engine.py:116: UserWarning: Found `num_trees` in params. Will use it instead of argument
      warnings.warn("Found `{}` in params. Will use it instead of argument".format(alias))
    
    
    [1] valid_0's rmse: 0.793788
    Training until validation scores don't improve for 100 rounds.
    [2] valid_0's rmse: 0.776669
    [3] valid_0's rmse: 0.762522
    [4] valid_0's rmse: 0.749776
    ...
    
    ...
    
    ...
    [299]   valid_0's rmse: 0.562895
    [300]   valid_0's rmse: 0.56334
    Did not meet early stopping. Best iteration is:
    [226]   valid_0's rmse: 0.560096

    展示结果

    展示我们获取的最佳参数,以及该模型在训练集上的最终表现,如果想要使用交叉验证请参考其他教程。

    RMSE = lightgbm_factory(best)
    print('best :', best)
    print('best param after transform :')
    argsDict_tranform(best,isPrint=True)
    print('rmse of the best lightgbm:', np.sqrt(RMSE))
    [1] valid_0's rmse: 0.793948
    Training until validation scores don't improve for 100 rounds.
    [2] valid_0's rmse: 0.776625
    ...
    [239]   valid_0's rmse: 0.569307
    Early stopping, best iteration is:
    [139]   valid_0's rmse: 0.567378
    best : {'bagging_fraction': 0.6, 'learning_rate': 0.05863937473720532, 'max_depth': 17, 'num_leaves': 25, 'num_trees': 393}
    best param after transform :
    {'bagging_fraction': 0.56, 'learning_rate': 0.05117278749474411, 'max_depth': 22, 'num_leaves': 85, 'num_trees': 543}
    rmse of the best lightgbm: 0.5808431444826054

    迁移二-交叉验证

    说明

    其实本部分与之前的一样重点依旧在于Hyperopt与Lightgbm参数传入上的一个冲突,不过解决方案很简单,先构建带有Hyperopt参数空间的模型,然后再从构建的模型中获取参数。其实这点xgboost,hyperopt,catboost三个模型的解决方案都一样。catboost自带的教程中也有这种解决方案。只不过catboost自带的教程不和lightgbm与xgboost一样在自己的原项目里,而是在原账号下又额外开了个Github项目,导致不太容易发现。实际上我也是最近在写这个的时候,才发现catboost原来是自带教程的。也正因为如此,本系列教程就不再往catboost上迁移代码了。请自行参考catboost自带的教程

    使用CV方法进行交叉验证

    sklearn部分过于简单,本处将不再做迁移。如有需要请自行迁移。

    import hyperopt
    
    train_all_data = lgb.Dataset(data=x_train_all,label=y_train_all)
    
    def hyperopt_objective(params):
    
        model = lgb.LGBMRegressor(
            num_leaves=31,
            max_depth=int(params['max_depth']) + 5,
            learning_rate=params['learning_rate'],
            objective='regression',
            eval_metric='rmse',
            nthread=-1,
        )
    
        num_round = 10
        res = lgb.cv(model.get_params(),train_all_data, num_round, nfold=5, metrics='rmse',early_stopping_rounds=10)
    
        return min(res['rmse-mean']) # as hyperopt minimises
    # 这里的warnings实在太多了,我们加入代码不再让其显示
    import warnings
    warnings.filterwarnings("ignore")
    
    from numpy.random import RandomState
    
    params_space = {
        'max_depth': hyperopt.hp.randint('max_depth', 6),
        'learning_rate': hyperopt.hp.uniform('learning_rate', 1e-3, 5e-1),
    }
    
    trials = hyperopt.Trials()
    
    best = hyperopt.fmin(
        hyperopt_objective,
        space=params_space,
        algo=hyperopt.tpe.suggest,
        max_evals=50,
        trials=trials,
        rstate=RandomState(123)
    )
    
    print("n展示hyperopt获取的最佳结果,但是要注意的是我们对hyperopt最初的取值范围做过一次转换")
    print(best)
    展示hyperopt获取的最佳结果,但是要注意的是我们对hyperopt最初的取值范围做过一次转换
    {'learning_rate': 0.059356676015000595, 'max_depth': 5}

    额外的:CSDN与知乎

    以后文章会做内容分级:主要内容将发布在知乎,首发仍然在CSDN,知乎只保留部分内容,而CSDN比较全面。CSDN会有的而知乎没有的:一些比较简单的内容,或者草稿。知乎主要发重点内容,以质量为主。

    • CSDN博客地址
    • 知乎主页
    展开全文
  • 文章目录机器学习自动调参1. Hyperopt**Hyperopt搜索参数空间**参数空间的设置使用sample函数从参数空间内采样:在参数空间内使用函数:**指定搜索的算法**实例Hyperopt调参XGBoost2. 贝叶斯调参 机器学习自动调参 ...

    机器学习自动调参

    在实际应用中,我们需要选取合适的模型,并对模型调参,得到一组合适的参数。尤其是在模型的调参阶段,需要花费大量的时间和精力,却又效率低下。但是我们可以换一个角度来看待这个问题,模型的选取,以及模型中需要调节的参数,可以看做是一组变量,模型的质量标准(比如正确率,AUC)等等可以看做是目标函数,这个问题就是超参数的优化的问题。我们可以使用搜索算法来解决。

    假设有如下函数:

    def q (args) :
        x, y = args
        return x ∗∗ 2 + y ∗∗ 2
    

    该如何优化得到q最小值呢?

    1. Hyperopt

    Hyperopt提供了一个优化接口,这个接口接受一个评估函数和参数空间,能计算出参数空间内的一个点的函数值。

    Hyheropt四个重要的因素:指定需要最小化的函数,搜索的空间,采样的数据集(trails database)(可选),搜索的算法(可选)。

    上文提到的q即为最小化的函数。

    Hyperopt搜索参数空间

    from hyperopt import hp
    space = [hp.uniform(’x’, 0, 1), hp.normal(’y’, 0, 1)] # x在0-1区间内取值,y是实数
    

    参数空间的设置

    比如优化函数q,输入fmin(q,space=hp.uniform(‘a’,0,1)).

    • hp.uniform函数的第一个参数是标签,每个超参数在参数空间内必须具有独一无二的标签。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)前闭后开的区间内的随机整数。 搜索空间可以含有list和dictionary.

    使用sample函数从参数空间内采样:

    from hyperopt import hp
    list_space = [
    hp.uniform(’a’, 0, 1),
    hp.loguniform(’b’, 0, 1)]
    
    tuple_space = (
    hp.uniform(’a’, 0, 1),
    hp.loguniform(’b’, 0, 1))
    
    dict_space = {
    ’a’: hp.uniform(’a’, 0, 1),
    ’b’: hp.loguniform(’b’, 0, 1)}
    
    from hyperopt.pyll.stochasti import sample
    print sample(list_space)
    # => [0.13, .235]
    

    在参数空间内使用函数:

    from hyperopt.pyll import scope
    def foo(x):
    return str(x) ∗ 3
    expr_space = {
    ’a’: 1 + hp.uniform(’a’, 0, 1),
    ’b’: scope.minimum(hp.loguniform(’b’, 0, 1), 10),
    ’c’: scope.call(foo, args=(hp.randint(’c’, 5),)),
    }
    

    指定搜索的算法

    算法也就是hyperopt的fmin函数的algo参数的取值。当前支持的算法由随机搜索(对应是hyperopt.rand.suggest),模拟退火(对应是hyperopt.anneal.suggest),TPE算法。

    from hyperopt import hp, fmin, rand, tpe, space_eval
    best = fmin(q, space, algo=rand.suggest)
    print space_eval(space, best)
    

    搜索算法本身也有内置的参数决定如何去优化目标函数,我们可以指定搜索算法的参数,比如针对TPE,指定jobs:

    from functools import partial
    from hyperopt import hp, fmin, tpe
    algo = partial(tpe.suggest, n_startup_jobs=10)
    best = fmin(q, space, algo=algo)
    print space_eval(space, best)
    

    实例

    一段使用感知器判别鸢尾花数据的代码,使用的学习率是0.1,迭代40次得到了一个测试集上正确率为82%的结果。使用hyperopt优化参数,将正确率提升到了91%。

    from sklearn import datasets
    import numpy as np
    from sklearn.cross_validation import train_test_split
    from sklearn.metrics import accuracy_score
    iris = datasets.load_iris()
    X = iris.data
    y = iris.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
    
    
    from sklearn.preprocessing import StandardScaler
    sc = StandardScaler()
    sc.fit(X_train)
    X_train_std = sc.transform(X_train)
    X_test_std = sc.transform(X_test)
    
    from sklearn.linear_model import Perceptron
    ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
    ppn.fit(X_train_std, y_train)
    
    y_pred = ppn.predict(X_test_std)
    print accuracy_score(y_test, y_pred)
    
    def percept(args):
        global X_train_std,y_train,y_test
        ppn = Perceptron(n_iter=int(args["n_iter"]),eta0=args["eta"]*0.01,random_state=0)
        ppn.fit(X_train_std, y_train)
        y_pred = ppn.predict(X_test_std)
        return -accuracy_score(y_test, y_pred)
    
    from hyperopt import fmin,tpe,hp,partial
    space = {"n_iter":hp.choice("n_iter",range(30,50)),
             "eta":hp.uniform("eta",0.05,0.5)}
    algo = partial(tpe.suggest,n_startup_jobs=10)
    best = fmin(percept,space,algo = algo,max_evals=100)
    print best
    print percept(best)
    #0.822222222222
    #{'n_iter': 14, 'eta': 0.12877033763511717}
    #-0.911111111111
    

    Hyperopt调参XGBoost

    import xgboost as xgb
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import train_test_split
    from hyperopt import fmin, tpe, hp, partial
    from sklearn import datasets
    
    iris = datasets.load_iris()
    X = iris.data
    y = iris.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
    
    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
        print("max_depth:" + str(max_depth))
        print("n_estimator:" + str(n_estimators))
        print("learning_rate:" + str(learning_rate))
        print("subsample:" + str(subsample))
        print("min_child_weight:" + str(min_child_weight))
        global X_train, y_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步不降则停止
            num_class=3,
            eval_metric='auc',
            objective="multi:softprob"
        )
    
        metric = cross_val_score(gbm, X_train, y_train, cv=5).mean()
        print('----auc----', 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=5)
    
    print(best)
    print(-GBM(best))
    

    2. 贝叶斯调参

    贝叶斯调参是基于高斯分布回归的。与Hyperopt不同的是它取目标函数最大化

    实例: 使用贝叶斯调参优化lightGBM

    from bayes_opt import BayesianOptimization
    import lightgbm as lgb
    from sklearn import datasets
    from sklearn.model_selection import cross_val_score
    
    iris = datasets.load_iris()
    X = iris.data
    # print(X.shape)
    y = iris.target
    
    space = {"max_depth": (3, 5),
             "num_leaves": (20, 40),
             # "n_estimators": (50, 150),  # [0,1,2,3,4,5] -> [50,]
             "learning_rate": (0.03, 0.07),  # [0,1,2,3,4,5] -> 0.05,0.06
             "subsample": (0.7, 1.0),  # [0,1,2,3] -> [0.7,0.8,0.9,1.0]
             "min_child_weight": (2, 6)  #
             }
    
    def GBM(max_depth, num_leaves, learning_rate, subsample, min_child_weight):
        max_depth = int(max_depth)
        # n_estimators = int(n_estimators)
        min_child_weight = int(min_child_weight)
        num_leaves = int(num_leaves)
    
        gbm = lgb.LGBMClassifier(
            num_leaves=num_leaves,
            nthread=3,  # 进程数
            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步不降则停止
            num_class=3,
            random_state=300,
            metric='auc',
            objective="multiclass",
            silent=False
    
        )
    
        metric = cross_val_score(gbm, X, y, cv=5).mean()
        return metric
    
    
    b_xgb = BayesianOptimization(GBM, space, random_state=2000)
    b_xgb.maximize()
    print(b_xgb.res['max']) # 获取最大化时的值和参数
    
    展开全文
  • 如何使用hyperopt对xgboost进行自动调参

    千次阅读 热门讨论 2018-12-17 10:26:17
    本教程重点在于传授如何使用Hyperopt对xgboost进行自动调参。但是这份代码也是我一直使用的代码模板之一,所以在其他数据集上套用该模板也是十分容易的。 同时因为xgboost,lightgbm,catboost。三个类库调用方法都...
  • 本篇文章主要记录了贝叶斯优化算法hyperopt的学习笔记,如果想看自动调参中的网格调参和遗传优化算法TPOT,请查看我另外两篇文章:网格搜索gridSearchCV和遗传优化算法TPOT。1、算法思想贝叶斯优化算法与网格搜索...
  •  直到一提的是,keras有其对应的自动调参工具:hyperas[8],你甚至可以用它来调整神经网络的结构。 }   结语: {  我对西瓜书第10章的内容还是有些不明白,所以最近买了csdn上的视频课[9],先看着...
  • 一直想找个Kernal了解一下贝叶斯调参框架的原理和LighGBM的算法实现,没想到HomeDefaultRisk数据集的大神竟然专门有一篇kernal是讲基于LightGBM的贝叶斯调参框架Hyperpot。赶紧自己实现一遍,收获很多,文中也有很多...
  • Hyperopt介绍超参数优化是实现模型性能最大化的重要步骤,scikit-learn提供了GridSearchCV和RandomizedSearchCV两个比较流行的选项。Hypero...
  • 一般的方法就是网格搜索(sklearn里面的gridsearch)、贝叶斯调参hyperopt工具)。 http://www.360doc.com/content/18/0707/15/7669533_768542933.shtml
  • 机器学习中,调参是一项繁琐但至关重要的任务,因为它很大程度上影响了算法的性能。手动调参十分耗时,网格搜索和随机搜索不需要人力,但需要很长的运行时间。因此,诞生了许多自动调整超参数的方法,例如遗传算法、...
  • Lightgbm with Hyperopt

    千次阅读 2018-12-18 12:49:39
    如何使用hyperopt对Lightgbm进行自动调参 之前的教程以及介绍过如何使用hyperopt对xgboost进行调参,并且已经说明了,该代码模板可以十分轻松的转移到lightgbm,或者catboost上。而本篇教程就是对原模板的一次歉意...
  • 前言 这本笔记目前仍在撰写状态。 基本上从python最基础的安装,python3.6最基本的语法和linux基础开始,再到python网络编程,数据库...机器学习自动调参Hyperopt和贝叶斯调参 Keras笔记(以tensorflow为预期) ...
  • 前言Xgboost中内置了交叉验证,如果我们...与第一篇教程-如何使用hyperopt对xgboost进行自动调参相同的是,本处教程中的代码也可以很好的被套用。并且可以很好的迁移到lightgbm与catboost上面。源代码请前往Githu...
  • Hyperopt中文文档导读:自动调参神器 Python 启发式算法的包 如何通俗易懂地解释遗传算法 一文读懂遗传算法工作原理(附 Python 实现) 遗传算法(python版) 遗传算法与其python实现 GAFT - 一个使用 Python 实现的...
  • 【导读】机器学习中,调参是一项繁琐但至关重要的任务,因为它很大程度上影响了算法的性能。手动调参十分耗时,网格和随机搜索不需要人力,但需要很长的运行时间。因此,诞生了许多自动调整超参数的方法。贝叶斯优化...
  • 【导读】机器学习中,调参是一项繁琐但至关重要的任务,因为它很大程度上影响了算法的性能。手动调参十分耗时,网格和随机搜索不需要人力,但需要很长的运行时间。因此,诞生了许多自动调整超参数的方法。贝叶斯优化...
  • 【导读】机器学习中,调参是一项繁琐但至关重要的任务,因为它很大程度上影响了算法的性能。手动调参十分耗时,网格和随机搜索不需要人力,但需要很长的运行时间。因此,诞生了许多自动调整超参数的方法。贝叶斯优化...
  • python之NetworkX的使用

    万次阅读 2018-08-14 21:34:10
    最近在使用学习机器学习算法时,使用下python的调参Hyperopt, 发现程序一直出现问题,结果发现不是程序问题,而是在安装 Hyperopt时出现问题。 在安装Hyperopt时 会自动安装依赖库 networkx-2.1, 结果发现其并不...

空空如也

空空如也

1 2
收藏数 25
精华内容 10
关键字:

自动调参hyperopt