精华内容
下载资源
问答
  • 贝叶斯优化

    2021-01-07 16:25:48
    文章目录前言贝叶斯定理贝叶斯优化算法概率代理模型采集函数论文中使用的BO算法概率代理模型:高斯过程采集函数:UCB小结 前言 如有错误,欢迎交流指正。 贝叶斯优化是一种十分有效的全局优化算法,目标是找到全局最...

    前言

    如有错误,欢迎交流指正。

    贝叶斯优化是一种十分有效的全局优化算法,目标是找到全局最优解.贝叶斯优化有效地解决了序贯决策理论中经典的机器智能问题:根据对未知目标函数 f 获取的信息,找到下一个评估位置,从而最快地达到最优解。

    实际上就是一种超参数优化方式。
     
     

    贝叶斯定理

    贝叶斯定理
    图片出自论文:贝叶斯优化方法和应用综述

     
     

    贝叶斯优化算法

    转载
    图片出自论文:贝叶斯优化方法和应用综述

           贝叶斯优化框架主要包含两个核心部分——概率代理模型(probabilistic surrogate model)采集函数 (acquisition function)

    • 概率代理模型包含先验概率模型和观测模型:先验概率模型即P(f);观测模型描述观测数据生成机制,即似然分布P(D1:t|f),更新概率代理模型意味着根据公式得到包含更多数据信息的后验概率分布P(f|D1:t)。概率代理模型用于代理未知目标函数,从假设先验开始,通过迭代地增加信息量、修正先验,从而得到更准确的代理模型。
    • 采集函数是根据后验概率分布构造的,通过最大化采集函数来选择下一个最有“潜力”的评估点。同时,有效的采集函数能够保证选择的评估点序列使得总损失(loss)最小。
       

    概率代理模型

           概率代理模型:使用概率模型代理原始评估代价高昂的复杂目标函数。概率代理模型根据模型的参数个数是否固定可分为参数模型和非参数模型

    • 参数模型:
             贝塔-伯努利(Beta-Bernoulli)模型、线性(linear)模型、广义线性(generalized linear)模型
    • 非参数模型:
    •        高斯过程、随机森林、深度神经网络

    相比参数固定的参数模型,非参数模型更加灵活,并且使用贝叶斯方法不易发生“过拟合”。
    在这里插入图片描述图片出自论文:贝叶斯优化方法和应用综述
     

    采集函数

           采集函数:根据后验概率分布构造的通过最大化采集函数来选择下一个最有“潜力”的评估点

    • 基于提升的策略:对于当前最优目标函数值有所提升的位置作为评估点。

    PI(probability of improvement)
    在这里插入图片描述
    EI(expected improvement)
    在这里插入图片描述

    • 置信边界策略:

    在求解目标函数最大值时,UCB 策略的采集函数为:
    在这里插入图片描述
    当求解目标函数的最小值时,使用置信下界策 LCB:
    在这里插入图片描述
    参数 βt平衡了期望和方差。

    • 基于信息的策略:

    汤普森采样(Thompson sampling,简称 TS);

    • 组合策略。

    在这里插入图片描述图片出自论文:贝叶斯优化方法和应用综述
     
     

    论文中使用的BO算法

    论文:Closed-loop optimization of fast-charging protocols for batteries with machine learning
     

    概率代理模型:高斯过程

    本小节图片出自:https://zhuanlan.zhihu.com/p/32152162

    目的:模拟目标函数(黑盒优化)
           高斯过程背后的关键思想是可以使用无限维多变量高斯分布来对函数进行建模神经网络和高斯过程之间有这样一个联系:存在无限多个隐层单元的神经网络等价于高斯过程。高斯过程是一个随机变量的集合,任意有限个随机变量都满足一个联合高斯分布。输入空间中的每个点都与一个随机变量相关联,而它们的联合分布可以被作为多元高斯分布建模。输入空间中的每个点都与一个随机变量相关联,而它们的联合分布可以被作为多元高斯分布建模。
           例如一个2维的高斯联合分布:
    在这里插入图片描述
    3D的钟形曲线,其中概率密度为其高度,若一次从图中抽取两点,反复进行10次,并把第一个值记录在x=0,第二个值在x=1,然后在两点间绘制线段。在这里插入图片描述
    扩展到20维:
    在这里插入图片描述
           曲线整体非常杂乱,但包含了许多有用的信息,如何改变分布来获得更好的样本?
           关键在于均值函数和协方差函数的选择,均值决定整体趋势,协方差决定平滑度。为了简便,通常假设先验均值函数为恒 0 函数,然后通过数据修正,修正后的后验均值并不限制为0。因此,该假设对后验准确性几乎不影响。只有选择合适的协方差函数才能保证得到理想的预测效果。
    论文中:
           均值函数:θTφ(x),θ参数空间,φ(x):充电协议x(CC1、CC2、CC3)的d(d=224)维特征向量投影空间,逼近K(xi,xj)=exp(y||xi-xj||22_2^2)得到;
           协方差:方差是两个不确定项的平方和**,这两个不确定项假设是同方差的(也就是说,所有协议都是一致的)。 第一项是在训练数据集中单个协议的重复运行中平均的经验方差(与用于训练早期预测器的经验方差相同),这解释了由于制造等外生因素而产生的变异性。第二项是早期预测的残差方差的最大值,因为早期预测不等待实验完成
     

    采集函数:UCB

           采集函数选择在周期寿命上的噪声预测分布具有高均值μ(鼓励开发)和高方差σ2(鼓励探索)的协议。 第k轮任何臂I(充电协议)的均值和上下置信界,由μk,i±βkσk,i给出。这两个项的相对由勘探权衡超参数β>0控制。在k轮上的勘探权衡超参数βk被另一个超参数ε∈(0,1]多次衰减,如βk0εk

    本图片出自:贝叶斯优化(BayesianOptimization)
    在这里插入图片描述 
     

    小结

    1.黑盒优化,类似神经网络;
    2.高斯过程拟合目标函数;
    3.多种采集函数可选。

    展开全文
  • 文起本篇文章记录通过 Python 调用第三方库,从而调用使用了贝叶斯优化原理的 Hyperopt 方法来进行超参数的优化选择。具体贝叶斯优化原理与相关介绍将在下一次文章中做较为详细的描述,可以参考这里。Hyperopt 是 ...

    万壑松风知客来,摇扇抚琴待留声

    1. 文起

    本篇文章记录通过 Python 调用第三方库,从而调用使用了贝叶斯优化原理的 Hyperopt 方法来进行超参数的优化选择。具体贝叶斯优化原理与相关介绍将在下一次文章中做较为详细的描述,可以参考这里。

    Hyperopt 是 Python 的几个贝叶斯优化库中的一个。它使用 Tree Parzen Estimator(TPE),其它 Python 库还包括了 Spearmint(高斯过程代理)和 SMAC(随机森林回归)。贝叶斯优化问题有四个部分:目标函数:使用的机器学习模型调用该组超参数在验证集上的损失。

    域空间:类似于网格搜索,传入超参数的搜索范围。

    参数搜索:构造替代函数并选择下一个超参数值进行评估的方法。

    存储结果:最小化函数在评估每组测试后的最优超参数存储结果。

    2. Hyperopt 简单样例说明:最简单的流程,实现以 XGBoost 作为调参模型,通过 hyperopt 完成上述贝叶斯优化的四个部分。

    一:定义目标函数1

    2

    3

    4

    5

    6

    7

    8

    9

    10train_X, test_X, train_y, test_y = train_test_split(df_scaler, df_y, test_size=0.3, random_state=999)

    data_train =xgb.DMatrix(train_X, train_y, silent=False)

    # 定义目标函数

    def (params, n_folds=10):

    cv_results =xgb.cv(params, data_train, num_boost_round=1000, nfold=n_folds, stratified=False, shuffle=True, metrics='mae', early_stopping_rounds=10)

    mae = max(cv_results['test-mae-mean'])

    loss = mae

    return loss

    objective() 是目标函数(黑盒函数),作用是返回一个损失值,Hyperopt 也是根据这个损失值来逐步选择超参数的。后续的 fmin() 函数会最小化这个损失,所以你可以根据是最大化还是最小化问题来改变这个返回值。此处的目标函数十分基础并没有做过多的调整,可根据实际情况来做修改目标函数。

    二:设置域空间1

    2

    3

    4

    5

    6

    7

    8

    9from hyperopt import hp

    space = {

    'learning_rate': hp.loguniform('learning_rate',np.log(0.01),np.log(0.4)),

    'max_depth': hp.choice('max_depth',range(1,8,1)),

    'min_child_weight': hp.choice('min_child_weight',range(1,5,1)),

    'reg_alpha': hp.uniform('reg_alpha',0.0,1.0),

    'subsample': hp.uniform('subsample',0.5,1.0),

    'colsample_bytree': hp.uniform('colsample_bytree',0.6,1.0)

    }

    域空间,也就是给定超参数搜索的范围。这个可以通过 hyperopt 的 hp 方法实现,hp 方法有很多个参数选择的方式如:hp.loguniform(对数空间搜索)、hp.lognormal(对数正态分布)、hp.normal(正态分布)、hp.choice(列表选项搜索)、hp.uniform(连续均匀分布搜索)、hp.quniform(连续均匀分布整数搜索)。

    这里也只是简单的设置域空间,比如还可以通过 choice 方法构建列表从而实现对多个不同模型的筛选,这个在后续会有介绍。强调:如果使用参数名相同会报错 “hyperopt.exceptions.DuplicateLabel”,例如域空间中定义了 XGBoost、LightGBM 两种模型,由于它们的部分参数名相同所以如果使用同名参数将报错。解决方法:可以修改内层名称,这个在后续代码中会说明。

    三:参数搜索1

    2

    3

    4

    5

    6

    7

    8# 参数搜索算法

    from hyperopt import tpe

    tpe_algorithm = tpe.suggest

    # 寻找目标函数的最小值

    from hyperopt import fmin

    MAX_EVALS = 500

    best = fmin(fn=objective, space=space, algo=tpe.suggest, max_evals=MAX_EVALS)

    Hyperopt 中可以使用几种搜索算法:tpe(tpe.suggest)、随机 rand(rand.suggest)、模拟退火 anneal(anneal.suggest)。同时定义用来寻找目标函数返回最小损失值的 fmin() 函数,其中 max_evals 参数表示迭代次数。

    四:存储结果1

    2# 优化结果参数

    print(best)

    best 就是 Hyperopt 返回最佳结果的参数。

    3. Hyperopt 可以变复杂

    上面使用几处简单的代码,实现了 Python 中调用 Hyperopt 来完成超参数选择的功能。任何方法都可以变得复杂,更何况 Hyperopt ,所以在上面代码的基础上稍加改变,实现一种稍微复杂点的 Hyperopt,从而完成较为强大的功能。说明:以下代码将实现,从 SVM、XGBoost、LightGBM、KNN、Linear 等多个不同模型中选择超参数,最终找到 Hyperopt 认为的最优参数。其中损失值为偏离度,并可以查看黑盒函数中的运行过程。

    一:定义目标函数1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66import pandas as pd

    import numpy as np

    from sklearn.preprocessing import StandardScaler

    from sklearn.model_selection import train_test_split

    from sklearn.model_selection import cross_val_score

    from sklearn.metrics import mean_absolute_error

    from sklearn.svm import SVR

    import xgboost as xgb

    import lightgbm as lgb

    from sklearn.neighbors import KNeighborsRegressor

    from sklearn.linear_model import LinearRegression

    from hyperopt import STATUS_OK

    import warnings

    warnings.filterwarnings('ignore')

    df = pd.read_csv('data.csv')

    features = df.iloc[:,:-1]

    target = df.iloc[:,-1]

    scaler = StandardScaler()

    features = scaler.fit_transform(features)

    train_X, test_X, train_y, test_y = train_test_split(features, target, test_size=0.25, random_state=999)

    # 计算偏离度

    def dod(real_values, pred_values):

    dod_result = np.around((np.absolute(real_values - pred_values) / real_values).mean(), 4)

    return dod_result

    # 计算传入模型的损失

    def (params):

    model_name = params['model_name']

    del params['model_name']

    if model_name == 'svm':

    clf = SVR(**params)

    elif model_name == 'xgboost':

    clf = xgb.XGBRegressor(**params)

    elif model_name == 'lightgbm':

    clf = lgb.LGBMRegressor(**params)

    elif model_name == 'knn':

    clf = KNeighborsRegressor(**params)

    elif model_name == 'linear':

    clf = LinearRegression(**params)

    else:

    return 0

    clf.fit(train_X, train_y)

    pred = clf.predict(test_X)

    loss = dod(test_y, pred)

    # 偏离度是自己定义的方法,当然可以返回交叉验证的结果(loss是负值需要注意)

    # loss = cross_val_score(clf, train_X, train_y, cv=10, scoring='neg_mean_absolute_error').mean()

    return {'loss':loss, 'params':params, 'status':STATUS_OK}

    # 定义总的目标函数

    count = 0

    best_score = np.inf

    model_name = None

    def fn(params):

    global model_name, best_score, count

    count +=1

    score = objective(params.copy())

    loss = score['loss']

    if loss < best_score:

    best_score = loss

    model_name = params['model_name']

    if count % 50 == 0:

    print('iters:{0}, score:{1}'.format(count, score))

    return loss

    二:设置域空间说明:两个树模型有相同的参数名,所以在设置参数时需要区别参数名。1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42from hyperopt import hp

    # 设置域空间

    space = hp.choice('regressor_type',[

    {

    'model_name': 'svm',

    'C': hp.uniform('C',0, 10.0),

    'kernel': hp.choice('kernel', ['linear', 'rbf']),

    'gamma': hp.uniform('gamma', 0, 20.0)

    },

    {

    'model_name': 'xgboost',

    'n_estimators': hp.choice('xgb_n_estimators', range(50,501,2)),

    'learning_rate': hp.uniform('xgb_learning_rate', 0.01, 0.3),

    'max_depth': hp.choice('xgb_max_depth', range(2,8,1)),

    'min_child_weight': hp.choice('xgb_min_child_weight', range(1,5,1)),

    'reg_alpha': hp.uniform('xgb_reg_alpha', 0, 1.0),

    'subsample': hp.uniform('xgb_subsample', 0.5, 1.0),

    'colsample_bytree': hp.uniform('xgb_colsample_bytree', 0.6, 1.0)

    },

    {

    'model_name': 'lightgbm',

    'n_estimators': hp.choice('lgb_n_estimators', range(50,501,2)),

    'learning_rate': hp.uniform('lgb_learning_rate', 0.01, 0.3),

    'max_depth': hp.choice('lgb_max_depth', range(2,8,1)),

    'num_leaves': hp.choice('lgb_num_leaves', range(20, 50, 1)),

    'min_child_weight': hp.choice('lgb_min_child_weight', [0.001,0.005,0.01,0.05,0.1]),

    'min_child_samples': hp.choice('lgb_min_child_samples', range(5,51,5)),

    'subsample': hp.uniform('lgb_subsample', 0.5, 1.0),

    'colsample_bytree': hp.uniform('lgb_colsample_bytree', 0.6, 1.0),

    'reg_alpha': hp.uniform('lgb_reg_alpha', 0, 1.0)

    },

    {

    'model_name': 'knn',

    'n_neighbors': hp.choice('n_neighbors', range(2,11)),

    'algorithm': hp.choice('algorithm', ['auto','ball_tree','kd_tree','brute'])

    },

    {

    'model_name': 'linear',

    'normalize': hp.choice('normalize', [False, True])

    }

    ])

    三:参数搜索1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12# 设定搜索算法

    from hyperopt import tpe

    # 如果有有必要,可以设置查看黑盒函数fn中的搜索情况(每次选择参数等)

    from hyperopt import Trials

    trials = Trials()

    # 定义搜索目标函数最小值函数

    from hyperopt import fmin

    MAX_EVALS = 1500

    best_params = fmin(fn=fn, space=space, algo=tpe.suggest, max_evals=MAX_EVALS,trials=trials)

    print('model_name: {0}, best_score: {1}'.format(model_name, best_score))

    四:存储结果1

    2

    3

    4

    5# 最佳参数

    print(best_params)

    # 查看黑盒函数中的变化

    print(trials)# 可以通过循环依次打印结果

    4. 文末

    Hyperopt 通过不同的设置可以变得更加完善和准确,从而在搜索参数上取得进一步成功。

    你需要注意一点,Hyperopt 并不是一个完全没有缺陷的方法,它也可能从一开始就陷入局部最优,所以相比于暴力的网格搜索它只是一种具有数学理论支撑的高级暴力搜索方法。

    展开全文
  • 贝叶斯优化 跳板/数据科学职业生涯轨迹/机器学习应用程序/ 18.2 / 6贝叶斯优化
  • 贝叶斯优化LSSVM

    2018-04-23 19:54:10
    贝叶斯优化最小二乘向量机,很好的优化方法,也比较少见
  • python实现贝叶斯优化The concept of ‘optimization’ is central to data science. We minimize loss by optimizing weights in a neural network. We optimize hyper-parameters in our gradient boosted trees ...

    python实现贝叶斯优化

    The concept of ‘optimization’ is central to data science. We minimize loss by optimizing weights in a neural network. We optimize hyper-parameters in our gradient boosted trees to find the best bias-variance trade-off. We use A-B testing to optimize behavior on our websites. Whether our function is a neural network, consumer behavior, or something more sinister, we all have something we want to optimize.

    “优化”的概念对于数据科学至关重要。 通过优化神经网络中的权重,我们将损失降至最低。 我们在梯度增强树中优化超参数,以找到最佳的偏差方差折衷方案。 我们使用AB测试来优化我们网站上的行为。 无论我们的功能是神经网络,消费者行为还是更险恶的事物,我们都有一些我们要优化的东西。

    Sometimes the functions we are trying to optimize are expensive, and we wish to get to our destination in as few steps as possible. Sometimes we want to be confident that we find the best possible solution, and sometimes our functions don’t have a tractable gradient, so there is no nice arrow to point us in the right direction. Often, our functions have random elements to them, so we are really trying to optimize f(x) = y + e, where e is some random error element. Bayesian optimization is a function optimizer (maximizer) which thrives in these conditions.

    有时,我们尝试优化的功能非常昂贵,并且我们希望以尽可能少的步骤到达目的地。 有时我们希望找到可能的最佳解决方案,有时我们的函数没有可控制的梯度,因此没有很好的箭头指向正确的方向。 通常,我们的函数具有随机元素,因此我们实际上是在尝试优化f(x)= y + e,其中e是一些随机误差元素。 贝叶斯优化是在这些条件下蓬勃发展的函数优化器(最大化器)。

    目录 (Table of Contents)

    1. What Is Bayesian Optimization

      什么是贝叶斯优化
    2. Implementing From Scratch

      从头开始实施
    3. Implementing In Parallel

      并行实施
    4. Final Words

      最后的话

    什么是贝叶斯优化(What Is Bayesian Optimization)

    Let’s say we have a function f, and we want to find the x which maximizes (or minimizes) f(x). We have many, many options. However, if our function fits the description right above the table of contents, we will definitely want to consider Bayesian optimization.

    比方说,我们有一个函数f,我们要找到它最大化X(或最小化)F(X)。 我们有很多选择。 但是,如果我们的函数适合目录上方的描述,则我们肯定会考虑贝叶斯优化。

    There are several different methods for performing Bayesian optimization. All of them involve creating an assumption about how certain things are distributed, making a decision based on that assumption, and then updating the assumption.

    有几种不同的方法可以执行贝叶斯优化。 所有这些都涉及创建关于某些事物如何分布的假设,基于该假设做出决定,然后更新该假设。

    The method in this article uses Gaussian processes to create an assumption about how f(x) is distributed. These processes can be thought of as a distribution of functions — where drawing a random sample from a Gaussian distribution results in a number, drawing a random sample from a Gaussian process results in a function. If you are not familiar with Gaussian processes, this is a little hard to picture. I recommend this video, which is what made the concept click for me.

    本文中的方法使用高斯过程来创建关于f(x)分布的假设。 可以将这些过程视为函数的分布-从高斯分布中抽取随机样本会产生一个数,从高斯过程中抽取随机样本会产生一个函数。 如果您不熟悉高斯过程,这很难想象。 我推荐此视频,这正是使这个概念吸引我的原因。

    The algorithm itself can be summarized as such:

    该算法本身可以概括如下:

    Image for post
    Image Uploaded by Author
    作者上传的图片

    从头开始实施(Implementing From Scratch)

    Here we walk through a single iteration of Bayesian optimization without using a package. The process is pretty straightforward. First, we define a toy function func we want to maximize, and then we sample it 4 times:

    在这里,我们不使用包就完成了贝叶斯优化的单次迭代。 这个过程非常简单。 首先,我们定义要最大化的玩具函数func ,然后对其进行4次采样:

    # Function to optimize
    func <- function(input) {
    dnorm(input,15,5) + dnorm(input,30,4) + dnorm(input,40,5)
    }# Sample the function 4 times
    func_results <- data.frame(input = c(5,18,25,44))
    func_results$output <- func(func_results$input)# Plot
    library(ggplot2)
    p <- ggplot(data = data.frame(input=c(0,50)),aes(input)) +
    stat_function(fun=func,size=1,alpha=0.25) +
    geom_point(data=func_results,aes(x=input,y=output),size=2) +
    ylab("output") +
    ylim(c(-0.05,0.2))
    p + ggtitle("Our Function and Attempts")
    Image for post
    Image Uploaded by Author
    作者上传的图片

    We are pretending we don’t know the true function, so all we see in practice are the 4 points we sampled. For the sake of keeping this walk-through interesting, we did a pretty miserable job of selection our initial points. Let’s fit a Gaussian process to the 4 points to define our assumption about how output is distributed for each input.

    我们假装不知道真正的功能,因此在实践中看到的只是我们采样的4点。 为了使本演练有趣,我们在选择初始要点方面做得很惨。 让我们将高斯过程拟合到这四个点,以定义关于每个输入的输出分布方式的假设。

    library(DiceKriging)
    set.seed(1991)
    gp <- km(
    design = data.frame(input=func_results$input)
    , response = func_results$output
    , scaling = TRUE
    )

    Let’s take a look at our Gaussian process next to the points we have sampled and the true function value:

    让我们看一下采样点和真实函数值旁边的高斯过程:

    predGP <- function(x,grab) {
    predict(gp,data.frame(input=x),type = "UK")[[grab]]
    }a=1
    cl = "purple"
    plotGP <- function(grab,cl,a) {
    stat_function(
    fun=predGP,args=list(grab=grab),color=cl,alpha=a,n=1000
    )
    }
    p + ggtitle("Gaussian Process Results") +
    plotGP("mean",cl,a) +
    plotGP("lower95",cl,a) +
    plotGP("upper95",cl,a)
    Image for post
    Image Uploaded by Author
    作者上传的图片

    The Gaussian process allows us to define a normal distribution of the output for each input. In the picture above, the purple lines show the Gaussian process. The middle line is the mean, and the upper/lower lines are the 95th percentiles of the normal distribution at that input. So, for example, if we wanted to know how we assume the output is distributed at input = 30, we could do:

    高斯过程允许我们为每个输入定义输出的正态分布。 在上面的图片中,紫色线表示高斯过程。 中线是平均值,上/下线是该输入处正态分布的第95个百分点。 因此,例如,如果我们想知道我们如何假设输出在输入= 30处分布,我们可以这样做:

    predict(gp,data.frame(input=30),type="UK")[c("mean","sd")]$mean
    [1] 0.05580301

    $sd
    [1] 0.007755026

    This tells us that we are assuming, at input = 30, our output follows a normal distribution with mean = 0.0558, and sd = 0.0078.

    这告诉我们,我们假设在输入= 30时,我们的输出遵循正态分布,平均值= 0.0558,并且sd = 0.0078。

    Now that we have defined our assumption about the distribution of the output, we need to determine where to sample the function next. To do this, we need to define how ‘promising’ an input is. We do this by defining an acquisition function. There are several to choose from:

    现在,我们已经定义了关于输出分布的假设,我们需要确定接下来要在哪里对函数进行采样。 为此,我们需要定义输入的“希望”程度。 我们通过定义采集功能来做到这一点。 有几种可供选择:

    Image for post
    Image Uploaded by Author
    作者上传的图片

    Of these, the upper confidence bound is the easiest to implement, so let’s define the function and plot it on our chart:

    其中,最高置信度范围最容易实现,因此让我们定义函数并将其绘制在图表上:

    ucb <- function(x,kappa=3) {
    gpMean <- predGP(x,grab="mean")
    gpSD <- predGP(x,grab="sd")
    return(gpMean + kappa * gpSD)
    }a=0.25
    p + ggtitle("Upper Confidence Bound") +
    plotGP("mean",cl,a) +
    plotGP("lower95",cl,a) +
    plotGP("upper95",cl,a) +
    stat_function(fun=ucb,color="blue")
    Image for post
    Image Uploaded By Author
    作者上传的图片

    We can see that our upper confidence bound is maximized (green diamond) somewhere between 10 and 15, so let’s find the specific spot, sample it, and update our GP:

    我们可以看到我们的置信度上限在10到15之间最大化(绿色菱形),因此让我们找到特定的点,对其进行采样并更新GP:

    # Find exact input that maximizes ucb
    acqMax <- optim(
    par = 12
    , fn = ucb
    , method = “L-BFGS-B”
    , control = list(fnscale = -1)
    , lower = 10
    , upper = 20
    )$par# Run our function as this spot
    func_results <- rbind(
    func_results
    , data.frame(input = acqMax,output = func(acqMax))
    )

    We have just completed one iteration of Bayesian optimization! If we continued to run more, we would see our chart evolve:

    我们刚刚完成了贝叶斯优化的一次迭代! 如果继续运行,我们将看到图表不断发展:

    Image for post
    Image Uploaded by Author
    作者上传的图片

    并行实施(Implementing in Parallel)

    We won’t implement this part from scratch. Instead, we will use the ParBayesianOptimization R package to do the heavy lifting. This package allows us to sample multiple promising points at once. If there is only 1 promising point, it samples the surrounding area multiple times. So, in our first example, we would sample all 5 of the local maximums of the acquisition function:

    我们不会从头开始实现这部分。 相反,我们将使用ParBayesianOptimization R包来完成繁重的工作。 该软件包使我们能够一次采样多个有希望的点。 如果只有1个有希望的点,它将对周围区域进行多次采样。 因此,在第一个示例中,我们将对采集函数的所有5个局部最大值进行采样:

    Image for post
    Image Uploaded by Author
    作者上传的图片

    Let’s get it up and running and see what comes out. We initialize the process with the 4 same points as above, and then run 1 optimization step with 5 points:

    让我们启动并运行它,看看有什么结果。 我们使用与上述相同的4个点初始化该过程,然后使用5个点运行1个优化步骤:

    library(ParBayesianOptimization)
    library(doParallel)# Setup parallel cluster
    cl <- makeCluster(5)
    registerDoParallel(cl)
    clusterExport(cl,c('func'))# bayesOpt requires the function to return a list with Score
    # as the metric to maximize. You can return other fields, too.
    scoringFunc <- function(input) return(list(Score = func(input)))# Initialize and run 1 optimization step at 5 points
    optObj <- bayesOpt(
    FUN = scoringFunc
    , bounds = list(input=c(0,50))
    , initGrid = list(input=c(5,18,25,44))
    , iters.n = 5
    , iters.k = 5
    , acqThresh = 0
    , parallel = TRUE
    )
    stopCluster(cl)
    registerDoSEQ()# Print the input and score of the first Epoch
    optObj$scoreSummary[,c("Epoch","input","Score","gpUtility")] Epoch input Score gpUtility
    0 5.00000 0.0107981936 NA
    0 18.00000 0.0677578712 NA
    0 25.00000 0.0573468343 NA
    0 44.00000 0.0581564852 NA
    1 35.59468 0.0916401614 0.6558418
    1 50.00000 0.0107985650 0.6326077
    1 13.74720 0.0773487879 0.5417429
    1 21.13259 0.0462167925 0.4734561
    1 0.00000 0.0008863697 0.1961284

    Our score summary shows us that bayesOpt ran our 4 initial points (Epoch = 0) and then ran 1 optimization step (Epoch = 1) in which it sampled all 5 of the local optimums of the acquisition function. If we ran for more iterations, we would continue to sample 5 points at a time. If our function to maximize was actually expensive, this would allow us to find the global optimum much faster.

    我们的分数摘要显示,bayesOpt运行了我们的4个初始点(Epoch = 0),然后运行了1个优化步骤(Epoch = 1),在该步骤中,它对采集函数的所有5个局部最优值进行了采样。 如果我们进行更多迭代,我们将继续一次采样5点。 如果最大化我们的功能实际上是昂贵的,这将使我们能够更快地找到全局最优值。

    The acqThresh parameter in bayesOpt is crucial to the sampling process. This parameter represents the minimum percentage of the global optimum of the acquisition function that a local optimum must reach for it to be sampled. For example, if acqThresh=0.5, then each local optimum (upper confidence bound, in our case) must be at least 50% of the global optimum, or it will be ignored. We set acqThresh=0, so all local optimums would be sampled.

    bayesOpt中的acqThresh参数对于采样过程至关重要。 此参数表示要对其进行采样的局部最优值必须达到的采集函数全局最优值的最小百分比。 例如,如果acqThresh = 0.5,则每个局部最优值(在我们的情况下为上限置信区间)必须至少为全局最优值的50%,否则它将被忽略。 我们设置acqThresh = 0,因此将对所有局部最优值进行采样。

    Draw your attention to the gpUtility field above. This is the scaled value of the acquisition function (upper confidence bound in our case) at each of the points sampled. If you notice this value converging to 0 over Epochs, then the Gaussian process’ opinion is that there is not many promising points left to explore. A more thorough, package specific explanation can be found here.

    请注意上面的gpUtility字段。 这是在每个采样点上采集函数的标度值(在我们的情况下为上限置信度)。 如果您注意到该值在历元上收敛到0,那么高斯过程的观点是,没有太多值得探索的点。 可以在此处找到更全面的,特定于软件包的说明。

    最后的话 (Final Words)

    Bayesian optimization is an amazing tool for niche scenarios. In modern data science, it is commonly used to optimize hyper-parameters for black box models. However, being a general function optimizer, it has found uses in many different places. I personally tend to use this method to tune my hyper-parameters in both R and Python.

    贝叶斯优化是利基场景的绝佳工具。 在现代数据科学中,它通常用于优化黑匣子模型的超参数。 但是,作为通用功能优化器,它已在许多不同的地方使用。 我个人倾向于使用此方法在R和Python中调整我的超参数。

    翻译自: https://towardsdatascience.com/a-parallel-implementation-of-bayesian-optimization-2ffcdb2733a2

    python实现贝叶斯优化

    展开全文
  • 本篇文章主要记录了贝叶斯优化算法hyperopt的学习笔记,如果想看自动化调参中的网格调参和遗传优化算法TPOT,请查看我另外两篇文章:网格搜索gridSearchCV和遗传优化算法TPOT。1、算法思想贝叶斯优化算法与网格搜索...

    注:转载请注明出处。

    本篇文章主要记录了贝叶斯优化算法hyperopt的学习笔记,如果想看自动化调参中的网格调参和遗传优化算法TPOT,请查看我另外两篇文章:网格搜索gridSearchCV和遗传优化算法TPOT。

    1、算法思想

    贝叶斯优化算法与网格搜索和随机搜索完全不同,会充分利用之前测试点的信息。贝叶斯优化算法通过对目标函数形状进行学习,找到使目标函数想全局最优提升的参数。

    2、具体步骤首先根据先验分布,假设一个搜索函数。

    然后每次使用新的测试点来测试目标函数时,利用这个信息来更新目标函数的先验分布。

    最后,算法测试由后验分布给出的全局最值可能出现的位置的点。

    3、缺陷与弥补缺陷:一旦找到一个局部最优,会在该区域不断地采样,很容易陷入局部最优值。

    弥补方式:在探索和利用之间找到一个平衡点。“探索”就是在还未取样的区域获取采样点;利用是在根据后验分布在最可能出现全局最值的区域进行采样。

    4、具体实现-python库 hyperopt

    1. 功能可以针对某个模型进行调优。

    可以同时调整多个模型的超参,并取得全局最优模型。–棒棒棒!!

    2. hyperopt 参数简介需导入模块:hyperopt

    调用方法和主要参数

    1

    2

    3

    4

    5

    6

    7from hyperopt import fmin, tpe, hp

    best = fmin(

    fn=lambda x: x,

    space=hp.uniform('x', 0, 1),

    algo=tpe.suggest,

    max_evals=100)

    print best

    fmin:作用就是在有限的迭代次数下,求使目标函数fn取得最小值的超参数(超参数的阈值在space中),在space中搜索超参数的方法使由algo进行指定。

    fn :目标函数当不是求最小值时,需要转化为求最小值。

    space:超参数的阈值空间。

    algo:超参数搜索算法

    max_evals: 最大迭代次数

    输出历史结果,甚至进行可视化:trails matplotlib.pyplot

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29from hyperopt import STATUS_OK,Trials

    fspace={

    'x': hp.uniform('x',-5,5)

    }

    def f(params):

    x=params['x']

    val=x**2

    return {'loss': val,'status': STATUS_OK}

    trials = Trials()

    best1=fmin(fn=f,space=fspace,algo=tpe.suggest,max_evals=500,trials=trials)

    print(best1)

    print('trials:')

    for trial in trials.trials[:10]:

    print(trial)

    ## 可视化

    # x随时间t的变化

    import matplotlib.pyplot as plt

    f, ax = plt.subplots(1)

    xs = [t['tid'] for t in trials.trials]

    ys = [t['misc']['vals']['x'] for t in trials.trials]

    ax.set_xlim(xs[0]-10, xs[-1]+10)

    ax.scatter(xs, ys, s=20, linewidth=0.01, alpha=0.75)

    ax.set_title('$x$ $vs$ $t$ ', fontsize=18)

    ax.set_xlabel('$t$', fontsize=16)

    ax.set_ylabel('$x$', fontsize=16)

    plt.show()

    输出图片结果:由图片可以看出最初算法从整个范围中均匀地选择值,但随着时间的推移以及参数对目标函数的影响了解越来越多,该算法越来越聚焦于它认为会取得最大收益的区域-一个接近0的范围。它仍然探索整个解空间,但频率有所下降。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11# 目标函数随时间t的变化

    import matplotlib.pyplot as plt

    f, ax = plt.subplots(1)

    xs = [t['tid'] for t in trials.trials]

    ys = [t['result']['loss'] for t in trials.trials]

    ax.set_xlim(xs[0]-10, xs[-1]+10)

    ax.scatter(xs, ys, s=20, linewidth=0.01, alpha=0.75)

    ax.set_title('$y$ $vs$ $t$ ', fontsize=18)

    ax.set_xlabel('$t$', fontsize=16)

    ax.set_ylabel('$y$', fontsize=16)

    plt.show()

    输出图片结果:可以看出目标函数逐渐趋向最小值0.

    目标函数与x的变化

    1

    2

    3

    4

    5

    6

    7

    8

    9import matplotlib.pyplot as plt

    f, ax = plt.subplots(1)

    xs = [t['misc']['vals']['x'] for t in trials.trials]

    ys = [t['result']['loss'] for t in trials.trials]

    ax.scatter(xs, ys, s=20, linewidth=0.01, alpha=0.75)

    ax.set_title('$y$ $vs$ $x$ ', fontsize=18)

    ax.set_xlabel('$x$', fontsize=16)

    ax.set_ylabel('$y$', fontsize=16)

    plt.show()

    输出图片结果:可以看出在y取最小值处,点比较密集。

    功能2:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63digits = datasets.load_digits()

    X = digits.data

    y = digits.target

    print X.shape, y.shape

    def hyperopt_train_test(params):

    t = params['type']

    del params['type']

    if t == 'naive_bayes':

    clf = BernoulliNB(**params)

    elif t == 'svm':

    clf = SVC(**params)

    elif t == 'dtree':

    clf = DecisionTreeClassifier(**params)

    elif t == 'knn':

    clf = KNeighborsClassifier(**params)

    else:

    return 0

    return cross_val_score(clf, X, y).mean()

    space = hp.choice('classifier_type', [

    {

    'type': 'naive_bayes',

    'alpha': hp.uniform('alpha', 0.0, 2.0)

    },

    {

    'type': 'svm',

    'C': hp.uniform('C', 0, 10.0),

    'kernel': hp.choice('kernel', ['linear', 'rbf']),

    'gamma': hp.uniform('gamma', 0, 20.0)

    },

    {

    'type': 'randomforest',

    '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', [0, 1]),

    'normalize': hp.choice('normalize', [0, 1])

    },

    {

    'type': 'knn',

    'n_neighbors': hp.choice('knn_n_neighbors', range(1,50))

    }

    ])

    count = 0

    best = 0

    def f(params):

    global best, count

    count += 1

    acc = hyperopt_train_test(params.copy())

    if acc > best:

    print 'new best:', acc, 'using', params['type']

    best = acc

    if count % 50 == 0:

    print 'iters:', count, ', acc:', acc, 'using', params

    return {'loss': -acc, 'status': STATUS_OK}

    trials = Trials()

    best = fmin(f, space, algo=tpe.suggest, max_evals=1500, trials=trials)

    print 'best:'

    print best

    5、参考

    展开全文
  • 介绍一下世界上最好的算法:贝叶斯优化。背景介绍近年来深度神经网络大火,可是神经网络的超参(hyperparameters)选择一直是一个问题,因为大部分时候大家都是按照玄学指导手动调参,各位调参的同学也跟奇异博士一样...
  • 压缩包为贝叶斯优化在机器学习和深度学习中应用的小案例,里包含: (1)data:iris.csv和mnist.npz; (2)贝叶斯优化_ML.py; (3)贝叶斯优化_DL.py。
  • 贝叶斯优化算法.docx

    2020-11-16 12:32:08
    贝叶斯优化算法 贝叶斯优化算法(BOA)是由美国UIUC大学的Pelikan等在2000年前后提出 的在贝叶斯优化算法中根据均匀分布随机产生初始种群 然后采用进化算法 的各种选择方法比如二进制锦标赛选择比例选择截断选择等从...
  • 贝叶斯优化(BayesianOptimization)

    万次阅读 多人点赞 2019-01-23 21:14:20
    文章目录贝叶斯优化贝叶斯优化器的介绍采集函数(Acquisition Function,AF)UCB(Upper confidence bound)EI(Expected improvement)PI(probability of improvement)算法流程贝叶斯优化的一个模拟实验贝叶斯优化的应用 ...
  • 超参数优化 贝叶斯优化框架 机器 (mlmachine) TL; DR (TL;DR) mlmachine is a Python library that organizes and accelerates notebook-based machine learning experiments. mlmachine是一个Python库,可组织和...
  • TPE CMAES 网格搜索 随机搜索 贝叶斯优化贝叶斯优化进行超参数调优@QI ZHANG · JUL 12, 2019 · 7 MIN READ超参数调优一直是机器学习里比较intractable的问题,繁多的超参数以及指数型爆炸的参数空间,往往让人...
  • 贝叶斯优化可以用于贝叶斯调参。 贝叶斯调参和grid search 和 random search的区别? 贝叶斯优化的主要目的是与大部分机器学习算法类似,学习模型的表达形式 ,在一定范围内求一个函数的最大(小)值。 ...
  • 贝叶斯优化算法

    2015-04-13 16:34:42
    贝叶斯优化算法在多目标优化问题中的应用,设计分布估计算法
  • 理解贝叶斯优化

    2020-01-23 10:16:40
    在工作中,需要用到贝叶斯优化, 查找了许多资料,总觉得讲的似是而非的,因此想要写一篇比较详述的文章从理论和实际问题两个角度对应着描述对贝叶斯优化的理解,因此有了下述文章。 1 总述 对于贝叶斯优化,总体...
  • 贝叶斯优化简介

    2020-10-24 01:07:03
    贝叶斯优化(Bayesian optimization)简介。
  • 文章目录贝叶斯优化在机器学习和深度学习的使用1.项目简介2.机器学习案例2.1导入相关库2.2导入数据及数据清洗2.3拆分数据集2.4贝叶斯优化2.5使用最优参数组合重新训练模型,并进行预测3.深度学习案例3.1导入相关库...
  • 贝叶斯优化xgboostHyperparameters: These are certain values/weights that determine the learning process of an algorithm. 超参数:这些是确定算法学习过程的某些值/权重。 Certain parameters for an Machine...
  • 贝叶斯优化方法和应用综述=
  • 贝叶斯优化参数

    千次阅读 2018-10-25 20:55:09
    [贝叶斯优化] 简介 贝叶斯优化用于机器学习调参由J. Snoek(2012)提出,主要思想是,给定优化的目标函数(广义的函数,只需指定输入和输出即可,无需知道内部结构以及数学性质),通过不断地添加样本点来更新目标函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,821
精华内容 728
关键字:

贝叶斯优化