精华内容
下载资源
问答
  • FreeBSD系统优化部分内核参数调优中文解释。#最大的接受TCP缓冲区空间net.inet.tcp.recvspace=65536#最大的接受UDP缓冲区大小net.inet.udp.sendspace=65535#最大的发送UDP数据缓冲区大小  #最大的接受TCP缓冲区空间...
  • 主要介绍了Nginx访问控制与参数调优的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • KNN算法介绍与参数调优 K近邻法(k-nearest neighbors,KNN)是一种很基本的机器学习方法了在我们平常的生活中也会不自主的应用比如我们判断一个人的人品只需要观察他来往最密切的几个人的人品好坏就可以得出了这里就...
  • JVM实战参数调优

    2018-12-14 23:40:59
    JVM实战参数调优与垃圾回收机制算法资料
  • Linux 下 系统参数调优经验之谈,非常给力的!调优系统必备
  • 性能参数调优

    2014-02-14 09:50:32
    总结一次大型企业(中国移动)的一次性能调优测试,以实际的测试调优实例,说明调优的方法,涉及JDBC调优,WAS server调优,IHS调优,linux系统调优,日志调优,并发测试脚本调优
  • 【JVM实战】JVM参数调优

    千次阅读 2020-03-30 14:45:24
    文章目录JVM参数调优一、调优基本概念二、常用JVM参数三、GC调优思路 JVM参数调优 一、调优基本概念 在调整性能时,JM有三个组件 堆大小调整 垃圾收集器调整 JIT编译器调整 大多数调优选项都与调整堆大小和选择的...

    JVM参数调优

    一、调优基本概念

    在调整性能时,JM有三个组件

    1. 堆大小调整
    2. 垃圾收集器调整
    3. JIT编译器调整

    大多数调优选项都与调整堆大小和选择的垃圾收集器有关

    同样,JIT编译器对性能也有很大影响,但是这个对程序员自身要求非常高。

    通常,在调优Java应用程序时,重点是以下两个主要目标之一:

    • 响应性:应用程序或系统对请求的数据进行响应的速度,对于专注于响应性的应用程序,长的暂停时间是不可接受的,重点是在短时间内做出回应。
    • 吞吐量:侧重于在特定时间段内最大化应用程序的工作量,对于专注于吞吐量的应用程序,高暂停时间是可接受的。

    一般而言,系统瓶颈核心还是在应用代码,一般情况下无需过多调优,而且JVM本身在不断优化的过程。

    二、常用JVM参数

    文章围绕Java8,下面的一些参数,在JDK9之后就被淘汰了,加红进行了凸显。

    参数说明
    -XX:+AlwaysPreTouchJVM启动时分配内存,非使用时再分配
    -XX:ErrorFile= filename崩溃日志
    -XX:+TraceClassLoading跟踪类加载信息
    -XX:+PrintClassHistogram按下Ctr+ Break后,打印类的信息
    -Xmx -Xms最大堆和最小堆
    -xx:permSize, -xx:metaspaceSize永久代/元数据空间
    -XX:+HeapDumpOnOutOfMemoryError0OM时导出堆到文件
    -XX:+HeapDumpPathOOM时堆导出的路径
    -XX:+OnOutOfMemoryErrorJVM启动时分配内存,非使用时再分配在OOM时,执行一个脚本
    java-XX:+PrintFlagsFinal -version  打印所有的-XX参数和默认值
    

    通用GC参数

    参数说明
    -XX:ParallelGCThread并行GC线程数量
    -XX:ConcGCThreads并发GC线程数量
    -XX:MaxGCPauseMillis最大停顿时间,单位毫秒。GC尽力保证回收时间不超过设定值
    -XX:GCTimeRatio0-100的取值范围,表示垃圾收集时间占总时间的比,默认99,即最大允许1%时间进行GC
    -XX. SurvivorRatio设置Eden区大小和 Survivor区大小的比例, 8表示两个 Survivor:Eden=2:8,即一个 Survivor占年轻代的1/10
    -XX:NewRatio新生代和老年代的比,4表示新生代老年代=1:4,即年轻代占堆的1/5
    -verbose:gc, -XX;+printGC打印GC的简要信息
    -XX:+PrintGCDetails打印GC详细信息
    -XX:+PrintGCTimeStamps打印CG发生的时间戳
    -Xloggc:log/gc.log指定 GC log的位置,以文件输出
    -XX:ParallelGCThread每次一次GC后,都打印堆信息

    三、GC调优思路

    首先准备环境

    创建一个springboot的空项目,在启动类部分添加一下代码,打包,放在阿里云服务器上运行。

    测试环境:JVM配置为1核2G,JAVA8,固定设置堆大小 1G

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import java.util.Random;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    @SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
            // 每333毫秒创建150线程,每个线程创建一个512kb的对象,最多一秒同时存在450线程,占用内存225m,查看6C的情况
            Executors.newScheduledThreadPool(1).scheduleAtFixedRate(() -> {
                new Thread(() -> {
                    for (int i = 0; i < 150; i++) {
                        try {
                            //  不干活,专门创建512kb的小对象
                            byte[] temp = new byte[1024 * 512];
                            Thread.sleep(new Random().nextInt(100)); // 随机睡眠200毫秒秒以内
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }, 1000, 333, TimeUnit.MILLISECONDS);
        }
    }
    

    在运行之前要记得指定一下堆的大小

    java -Xmx1024m -jar xxx.jar
    

    启动是正常的
    在这里插入图片描述
    上面已经能看到端口号了,但是我们这里用jcmd象征的看一下
    在这里插入图片描述
    我们看一下堆的使用情况
    在这里插入图片描述
    里面的数据都是动态的。

    我们看一下调优的思路

    1. 分析场景。例如:启动速度慢;偶尔出现响应慢于平均水平或者出现卡顿
    2. 确定目标。内存占用、低延时、吞吐量
    3. 收集日志。通过参数配置收集GC日志;通过JDK工具查看GC状态(例如jstat 实时查看)
    4. 分析日志。使用工具辅助分析日志,查看GC次数,GC时间(事后分析)
    5. 调整参数。切换垃圾收集器或者调整垃圾收集器参数

    前两点的话,要和具体场景结合起来。文章主要展示整个过程该怎么走(相当于工具说明书),具体问题要具体分析。

    java -Xmx1024m -Xloggc:/opt/gc.log -jar xxx.jar
    

    我们这里添加了日志的收集
    在这里插入图片描述
    我们去对应目录找一下日志,里面的参数我们都介绍过,这个不难看懂。
    在这里插入图片描述
    但是文件内容是非常非常多的,这样一点点的看可能有点困难,我们一边把文件下载下来,用GCViewer这个开源的工具来做这件事情。

    GCViewer工具,辅助分析GC日志文件 https://github.com/chewiebug/GCViewer
    在这里插入图片描述
    打开下载到本地的gc.log文件
    在这里插入图片描述
    再看右下角的信息,主要是一些汇总信息。各种数据的分析,比如平均,最大,最小等。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    至于首页的图形,怎么看,可以直接参考文档:https://github.com/chewiebug/GCViewer

    红线意思是什么等等 都写的很详细。

    在这里插入图片描述
    下面看一下jstat 动态监控GC统计信息,采用的格式是间隔1000毫秒统计一次,每10行数据后输出列标题

    jstat -gc -h10 $(jcmd | grep "demo-0.0.1-SNAPSHOT.jar" | awk '{print $1}') 1000
    

    里面的参数,我们说过了,参考上一篇文章【JVM实战】基于JDK命令行工具的监控
    在这里插入图片描述

    下面看一下切换垃圾收集器或者调整垃圾收集器参数相关信息:

    垃圾收集器 Parallel参数调优

    这是JDK默认的收集器–吞吐量优先

    参数说明
    -XX:+UseParallelGC新生代使用并行回收收集器
    -XX:+Use ParalleloldGC老年代使用并行回收收集器
    -XX:ParallelGCThreads设置用于垃圾回收的线程数
    -XX:+UseAdaptiveSizePolicy打开自适应GC策略

    自适应GC策略是指自动调整分代分区的大小。UseAdaptiveSizePolicy自适应默认开启。

    垃圾收集器CMS参数调优

    关于CMS

    • 响应时间优先2
    • Parallel gc无法满足应用程序延迟要求时再考虑使用CMS垃圾收集器。
    • 新版建议用G1垃圾收集器

    在这里插入图片描述
    垃圾收集器G1参数调优

    关于G1:

    • 兼顾吞吐量和响应时间
    • 超过50%的Java堆被实时数据占用。
    • 建议大堆(大小约为6GB或更大)
    • 且GC延迟要求有限的应用(稳定且可预测的暂停时间低于0.5秒)。
      在这里插入图片描述

    运行时JIT编译器优化参数

    JIT编译指的是字节码编译为本地代码(汇编)执行,只有热点代码才会编译为本地代码。解释器执行节约内存,反之可以使用编译执行来提升效率

    在这里插入图片描述
    最后由于版本不断更新,JVM参数和具体说明,建议需要时参考 oracle官网的手册。

    说实话,如果没有一个具体的线上场景,很难去演示调优的过程,这里能做到的就是,给出调优的思路、相关工具的使用,以及调优用到的参数信息。

    参数的调整多少都会对JVM的运行有影响,比如 Parallel参数调优中-XX:ParallelGCThreads设置线程的数量,这个在不同配置的服务器上测试得到的结果会有差别,你可以在自己服务器上试试看。

    展开全文
  • 参数调优方法整理大全

    千次阅读 2019-11-06 19:08:21
    机器学习中总是会碰见调...一、随机森林超参数优化- RandomSearch和GridSearch (1)RandomSearch 原理: 超参数优化也就是常说的调参,python-sklearn里常用的有GridSearchCV和RandomizedSearchCV可以用。其中Gr...

     

    机器学习中总是会碰见调参这种枯燥无味且消耗时间的事情,所幸,有很多可以帮助你自动调参的库以及相应的方法,在这里统一总结一下吧。

    一、随机森林超参数优化- RandomSearch和GridSearch

    (1)RandomSearch

    原理:

    超参数优化也就是常说的调参,python-sklearn里常用的有GridSearchCV和RandomizedSearchCV可以用。其中GridSearchCV的原理很简明,就是程序去挨个尝试每一组超参数,然后选取最好的那一组。可以想象,这个是比较费时间的,面临着维度灾难。因此James Bergstra和Yoshua Bengio在2012年提出了超参数优化的RandomSearch方法。

    RandomizedSearchCV是在论文的基础上加入了cross-validation

    RandomSearchCV是如何"随机搜索"的:

    考察其源代码,其搜索策略如下:

    (a)对于搜索范围是distribution的超参数,根据给定的distribution随机采样;

    (b)对于搜索范围是lit的超参数,在给定的list中等概率采样;

    (c)对a、b两步中得到的n_iter组采样结果,进行遍历。

    (补充)如果给定的搜索范围均为list,则不放回抽样n_iter次。

    更详细的可以参考sklearn-RandomizedSearchCV的ParameterSampler类的代码。

    为什么RandomSearchCV会有效?

    在这里插入图片描述

    (a)目标函数为 f(x,y)=g(x)+h(y),其中绿色为g(x),黄色为h(y),目的是求f的最大值。

    (b)其中由于g(x)数值上要明显大于h(y),因此有f(x,y)=g(x)+h(y)≈g(x),也就是说在整体求解f(x,y)最大值的过程中,g(x)的影响明显大于h(y)。

    (c)两个图都进行9次实验(搜索),可以看到左图实际探索了各三个点(在横轴和纵轴上的投影均为3个),而右图探索了9个不同的点(横轴纵轴均是,不过实际上横轴影响更大)。

    (d)右图更可能找到目标函数的最大值。

    因此引入随机因素在某些情况下可以提高寻优效率。 

    下面是具体代码

    from sklearn.ensemble import RandomForestRegressor
    from sklearn.model_selection import RandomizedSearchCV
    import numpy as np
    from pprint import pprint
    from sklearn.datasets import load_iris
    if __name__=='__main__':
        # Number of trees in random forest
        n_estimators = [int(x) for x in np.linspace(start = 200, stop = 2000, num = 10)]
        # Number of features to consider at every split
        max_features = ['auto', 'sqrt']
        # Maximum number of levels in tree
        max_depth = [int(x) for x in np.linspace(10, 110, num = 11)]
        max_depth.append(None)
        # Minimum number of samples required to split a node
        min_samples_split = [2, 5, 10]
        # Minimum number of samples required at each leaf node
        min_samples_leaf = [1, 2, 4]
        # Method of selecting samples for training each tree
        bootstrap = [True, False]
        # Create the random grid
        random_grid = {'n_estimators': n_estimators,
                       'max_features': max_features,
                       'max_depth': max_depth,
                       'min_samples_split': min_samples_split,
                       'min_samples_leaf': min_samples_leaf,
                       'bootstrap': bootstrap}
        pprint(random_grid)
    
        #导入数据
        data=load_iris()
    
        # 使用随机网格搜索最佳超参数
        # 首先创建要调优的基本模型
        rf = RandomForestRegressor()
        # 随机搜索参数,使用3倍交叉验证
        # 采用100种不同的组合进行搜索,并使用所有可用的核心
        rf_random = RandomizedSearchCV(estimator = rf, param_distributions = random_grid, n_iter = 100, cv = 3, verbose=2, random_state=42, n_jobs = -1)
        # Fit模型
        rf_random.fit(data.data, data.target)
        print(rf_random.best_params_)

    (2)GridSearch网格搜索

    #下面是网格搜索:
        from sklearn.model_selection import GridSearchCV
    
        data = load_iris()
        # Create the parameter grid based on the results of random search
        param_grid = {
            'bootstrap': [True, False],
            'max_depth': [int(x) for x in np.linspace(10, 110, num = 11)],
            'max_features': ['auto', 'sqrt'],
            'min_samples_leaf': [1, 2, 4],
            'min_samples_split': [2, 5, 10],
            'n_estimators': [int(x) for x in np.linspace(start = 200, stop = 2000, num = 10)]
        }
        # Create a based model
        rf = RandomForestRegressor()
        # Instantiate the grid search model
        grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=3, n_jobs=-1, verbose=2)
        grid_search.fit(data.data, data.target)
        pprint(grid_search.best_params_)
    
        best_grid = grid_search.best_estimator_
        grid_accuracy = evaluate(best_grid, data.data, data.target)
        pprint(best_grid)
        pprint(grid_accuracy)

    二、 Hyperopt自动化超参数调优- 贝叶斯优化

    网格搜索和随机搜索则对ml模型超参数的优化能取得不错的效果,但是需要大量运行时间去评估搜索空间中并不太可能找到最优点的区域。因此越来越多的的超参数调优过程都是通过自动化的方法完成的,它们旨在使用带有策略的启发式搜索(informed search)在更短的时间内找到最优超参数。

     

    贝叶斯优化是一种基于模型的用于寻找函数最小值的方法。近段时间以来,贝叶斯优化开始被用于机器学习超参数调优,结果表明,该方法在测试集上的表现更加优异,并且需要的迭代次数小于随机搜索。

    Python 环境下有一些贝叶斯优化程序库,它们目标函数的代理算法有所区别。本部分主要介绍「Hyperopt」库,它使用树形 Parzen 评估器(TPE,https://papers.nips.cc/paper/4443-algorithms-for-hyper-parameter-optimization.pdf)作为搜索算法,其他的 Python 库还包含「Spearmint」(高斯过程代理)和「SMAC」(随即森林回归)。

     

    贝叶斯优化问题有四个组成部分:

    1)目标函数:我们想要最小化的对象,这里指带超参数的机器学习模型的验证误差

    2)域空间:待搜索的超参数值

    3)优化算法:构造代理模型和选择接下来要评估的超参数值的方法

    4)结果的历史数据:存储下来的目标函数评估结果,包含超参数和验证损失

    通过以上四个步骤,我们可以对任意实值函数进行优化(找到最小值)。

    详解:

    1)目标函数

    模型训练目的是最小化目标函数,所以输出为需要最小化的实值——交叉验证损失。Hyperopt 将目标函数作为黑盒处理,因为这个库只关心输入和输出是什么。为了找到使损失最小的输入值。

    cross_val_score
    对衡量的estimator,它默认返回的是一个array,包含K folder情况下的各次的评分,一般采用mean()。 需要确定这个estimator默认的 scoring 是什么,它的值是越大越匹配还是越小越匹配。如果自己指定了scoring,一定要确定这个scoring值的意义,切记切记! 而如果用户不指定,一般对于Classification类的estimator,使用accuracy,它是越大越好,那么,hyperopt里面的loss的值就应该是对这个值取负数,因为hyperopt通过loss最小取找最佳匹配。 可以把feature的normalize或者scale作为一个choice,然后看看是否更合适。如果更合适,best里面就会显示 normalize 为1。

    from sklearn.datasets import load_iris
    from sklearn import datasets
    from sklearn.preprocessing import normalize, scale
    from hyperopt import fmin, tpe, hp, STATUS_OK, Trials
     
     
    iris = load_iris()
    X = iris.data
    y = iris.target
     
    def hyperopt_train_test(params):
        X_ = X[:]
     
        # 因为下面的两个参数都不属于KNeighborsClassifier支持的参数,故使用后直接删除
        if 'normalize' in params:
            if params['normalize'] == 1:
                X_ = normalize(X_)
                del params['normalize']
     
        if 'scale' in params:
            if params['scale'] == 1:
                X_ = scale(X_)
                del params['scale']
     
        clf = KNeighborsClassifier(**params)
        return cross_val_score(clf, X_, y).mean()
     
    space4knn = {
        'n_neighbors': hp.choice('n_neighbors', range(1,50)),
        'scale': hp.choice('scale', [0, 1]),  # 必须是choice,不要用quniform
        'normalize': hp.choice('normalize', [0, 1])
    }
     
    def f(params):
        acc = hyperopt_train_test(params)
        return {'loss': -acc, 'status': STATUS_OK} #注意这里的负号
     
    trials = Trials()
    best = fmin(f, space4knn, algo=tpe.suggest, max_evals=100, trials=trials)
    print best

    例二,也是取负 

    def objective(trial):
        C=trial.suggest_loguniform('C', 10e-10, 10)
        model=LogisticRegression(C=C, class_weight='balanced',max_iter=10000, solver='lbfgs', n_jobs=-1)
        score=-cross_val_score(model, Xtrain, Ytrain, cv=kf, scoring='roc_auc').mean()
        return score

    实际GBM完整的目标函数

    import lightgbm as lgb
    from hyperopt import STATUS_OK
    
    N_FOLDS = 10
    
    # Create the dataset
    train_set = lgb.Dataset(train_features, train_labels)
    
    def objective(params, n_folds = N_FOLDS):
        """Objective function for Gradient Boosting Machine Hyperparameter Tuning"""
    
        # Perform n_fold cross validation with hyperparameters
        # Use early stopping and evalute based on ROC AUC
        cv_results = lgb.cv(params, train_set, nfold = n_folds, num_boost_round = 10000, early_stopping_rounds = 100, metrics = 'auc', seed = 50)
    #此部分为核心代码,
    
        # Extract the best score
        best_score = max(cv_results['auc-mean'])
    
        # Loss must be minimized
        loss = 1 - best_score
    
        # Dictionary with information for evaluation
        return {'loss': loss, 'params': params, 'status': STATUS_OK}

    2)域空间

    贝叶斯优化中,域空间对每个超参数来说是一个概率分布而不是离散的值。因为很难确定不同数据集之间的最佳模型设定区间,此处主要采用贝叶斯算法进行推理。

    此外,模型中有些参数是不需要调优的。以GBM为例,除了n_estimator之外,还有10个左右的参数需要调整。因此我们采用不同的分布来定义每个参数的域空间

    from hyperopt import hp
    # Define the search space
    space = {
        'class_weight': hp.choice('class_weight', [None, 'balanced']),
        'boosting_type': hp.choice('boosting_type', 
                                   [{'boosting_type': 'gbdt', 
                                        'subsample': hp.uniform('gdbt_subsample', 0.5, 1)}, 
                                    {'boosting_type': 'dart', 
                                         'subsample': hp.uniform('dart_subsample', 0.5, 1)},
                                    {'boosting_type': 'goss'}]),
        'num_leaves': hp.quniform('num_leaves', 30, 150, 1),
        'learning_rate': hp.loguniform('learning_rate', np.log(0.01), np.log(0.2)),
        'subsample_for_bin': hp.quniform('subsample_for_bin', 20000, 300000, 20000),
        'min_child_samples': hp.quniform('min_child_samples', 20, 500, 5),
        'reg_alpha': hp.uniform('reg_alpha', 0.0, 1.0),
        'reg_lambda': hp.uniform('reg_lambda', 0.0, 1.0),
        'colsample_bytree': hp.uniform('colsample_by_tree', 0.6, 1.0)
    }

    不同分布名称含义:

     choice:类别变量

       quniform:离散均匀分布(在整数空间上均匀分布)

       uniform:连续均匀分布(在浮点数空间上均匀分布)

       loguniform:连续对数均匀分布(在浮点数空间中的对数尺度上均匀分布)

    • 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)前闭后开的区间内的随机整数。
    • hp.normal(label, mu, sigma) where mu and sigma are the mean and standard deviation σ , respectively. 正态分布,返回值范围没法限制。
    • hp.qnormal(label, mu, sigma, q)
    • hp.lognormal(label, mu, sigma)
    • hp.qlognormal(label, mu, sigma, q)

    定义与空间后,可以选择一个样本来查看典型样本形式

    # Sample from the full space
    example = sample(space)
    
    # Dictionary get method with default
    subsample = example['boosting_type'].get('subsample', 1.0)
    
    # Assign top-level keys
    example['boosting_type'] = example['boosting_type']['boosting_type']
    example['subsample'] = subsample
    
    example

    3)搜索算法

    algo指定搜索算法,目前支持以下算法:
    ①随机搜索(hyperopt.rand.suggest)
    ②模拟退火(hyperopt.anneal.suggest)
    ③TPE算法(hyperopt.tpe.suggest,算法全称为Tree-structured Parzen Estimator Approach)

    尽管从概念上来说,这是贝叶斯优化最难的一部分,但在 Hyperopt 中创建优化算法只需一行代码。使用树形 Parzen 评估器(Tree Parzen Estimation,以下简称 TPE)的代码如下:

    from hyperopt import tpe
    # Algorithm
    tpe_algorithm = tpe.suggest

    4)结果历史数据

    想知道背后的发展进程,可以使用「Trials」对象,它将存储基本的训练信息,还可以使用目标函数返回的字典(包含损失「loss」和参数「params」)

    from hyperopt import Trials
    # Trials object to track progress
    bayes_trials = Trials()

    Trials只是用来记录每次eval的时候,具体使用了什么参数以及相关的返回值。这时候,fn的返回值变为dict,除了loss,还有一个status。Trials对象将数据存储为一个BSON对象,可以利用MongoDB做分布式运算。

    from hyperopt import fmin, tpe, hp, 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()
    best = fmin(fn=f, space=fspace, algo=tpe.suggest, max_evals=50, trials=trials)
     
    print('best:', best)
     
    print('trials:')
    for trial in trials.trials[:2]:
        print(trial)

    对于STATUS_OK的返回,会统计它的loss值,而对于STATUS_FAIL的返回,则会忽略。

    可以通过这里面的值,把一些变量与loss的点绘图,来看匹配度。或者tid与变量绘图,看它搜索的位置收敛(非数学意义上的收敛)情况。
    trials有这几种:

    • trials.trials - a list of dictionaries representing everything about the search
    • trials.results - a list of dictionaries returned by ‘objective’ during the search
    • trials.losses() - a list of losses (float for each ‘ok’ trial) trials.statuses() - a list of status strings

    5)优化算法

    from hyperopt import fmin
    MAX_EVALS = 500
    
    # Optimize
    best = fmin(fn = objective, space = space, algo = tpe.suggest, 
                max_evals = MAX_EVALS, trials = bayes_trials)

    使用sklearn的数据进行一次测试

    #coding:utf-8
    from hyperopt import fmin, tpe, hp, rand
    import numpy as np
    from sklearn.metrics import accuracy_score
    from sklearn import svm
    from sklearn import datasets
    
    # SVM的三个超参数:C为惩罚因子,kernel为核函数类型,gamma为核函数的额外参数(对于不同类型的核函数有不同的含义)
    # 有别于传统的网格搜索(GridSearch),这里只需要给出最优参数的概率分布即可,而不需要按照步长把具体的值给一个个枚举出来
    parameter_space_svc ={
        # loguniform表示该参数取对数后符合均匀分布
        'C':hp.loguniform("C", np.log(1), np.log(100)),
        'kernel':hp.choice('kernel',['rbf','poly']),
        'gamma': hp.loguniform("gamma", np.log(0.001), np.log(0.1)),
    }
    
    # 鸢尾花卉数据集,是一类多重变量分析的数据集
    # 通过花萼长度,花萼宽度,花瓣长度,花瓣宽度4个属性预测鸢尾花卉属于(Setosa,Versicolour,Virginica)三个种类中的哪一类
    iris = datasets.load_digits()
    
    #--------------------划分训练集和测试集--------------------
    train_data = iris.data[0:1300]
    train_target = iris.target[0:1300]
    test_data = iris.data[1300:-1]
    test_target = iris.target[1300:-1]
    #-----------------------------------------------------------
    
    # 计数器,每一次参数组合的枚举都会使它加1
    count = 0
    
    def function(args):
        print(args)
    
        # **可以把dict转换为关键字参数,可以大大简化复杂的函数调用
        clf = svm.SVC(**args)
    
        # 训练模型
        clf.fit(train_data,train_target)
    
        # 预测测试集
        prediction = clf.predict(test_data)
    
        global count
        count = count + 1
        score = accuracy_score(test_target,prediction)
        print("第%s次,测试集正确率为:" % str(count),score)
    
        # 由于hyperopt仅提供fmin接口,因此如果要求最大值,则需要取相反数
        return -score
    
    # algo指定搜索算法,目前支持以下算法:
    # ①随机搜索(hyperopt.rand.suggest)
    # ②模拟退火(hyperopt.anneal.suggest)
    # ③TPE算法(hyperopt.tpe.suggest,算法全称为Tree-structured Parzen Estimator Approach)
    # max_evals指定枚举次数上限,即使第max_evals次枚举仍未能确定全局最优解,也要结束搜索,返回目前搜索到的最优解
    best = fmin(function, parameter_space_svc, algo=tpe.suggest, max_evals=100)
    
    # best["kernel"]返回的是数组下标,因此需要把它还原回来
    kernel_list = ['rbf','poly']
    best["kernel"] = kernel_list[best["kernel"]]
    
    print("最佳参数为:",best)
    
    clf = svm.SVC(**best)
    print(clf)

    输出结果如下:

    {'gamma': 0.0010051585652497248, 'kernel': 'poly', 'C': 29.551164584073586}
    第1次,测试集正确率为: 0.959677419355
    {'gamma': 0.006498482991283678, 'kernel': 'rbf', 'C': 6.626826808981864}
    第2次,测试集正确率为: 0.834677419355
    {'gamma': 0.008192671915044216, 'kernel': 'poly', 'C': 34.48947180442318}
    第3次,测试集正确率为: 0.959677419355
    {'gamma': 0.001359874432712413, 'kernel': 'rbf', 'C': 1.6402360233244775}
    第98次,测试集正确率为: 0.971774193548
    {'gamma': 0.0029328466160223813, 'kernel': 'poly', 'C': 1.6328276445108112}
    第99次,测试集正确率为: 0.959677419355
    {'gamma': 0.0015786919481979775, 'kernel': 'rbf', 'C': 4.669133703622153}
    第100次,测试集正确率为: 0.969758064516
    最佳参数为: {'gamma': 0.00101162002595069, 'kernel': 'rbf', 'C': 21.12514792460218}
    SVC(C=21.12514792460218, cache_size=200, class_weight=None, coef0=0.0,
      decision_function_shape=None, degree=3, gamma=0.00101162002595069,
      kernel='rbf', max_iter=-1, probability=False, random_state=None,
      shrinking=True, tol=0.001, verbose=False)

    三、Optuna

    有关这个库的文献好少,不过看代码的话,形式和Hyperopt差不太多

    from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
    from sklearn.linear_model import LogisticRegression
    from sklearn.metrics import roc_auc_score
    import matplotlib.pyplot as plt
    import seaborn as sns
    import pandas as pd
    import numpy as np
    import optuna
    import os
    from hyperopt import hp
    # print(hp.loguniform('sdf',1,5))
    # 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)}
    # print(dict_space,tuple_space,dict_space)
    train=pd.read_csv('../data/train.csv', index_col='id')
    test=pd.read_csv('../data/test.csv', index_col='id')
    submission=pd.read_csv('../data/sample_submission.csv', index_col='id')
    Ytrain=train['target']
    train=train[list(test)]
    all_data=pd.concat((train, test))
    print(train.shape, test.shape, all_data.shape)
    
    encoded=pd.get_dummies(all_data, columns=all_data.columns, sparse=True)
    encoded=encoded.sparse.to_coo()
    encoded=encoded.tocsr()
    
    Xtrain=encoded[:len(train)]
    Xtest=encoded[len(train):]
    
    kf=StratifiedKFold(n_splits=10)
    
    def objective(trial):
        C=trial.suggest_loguniform('C', 10e-10, 10)
        model=LogisticRegression(C=C, class_weight='balanced',max_iter=10000, solver='lbfgs', n_jobs=-1)
        score=-cross_val_score(model, Xtrain, Ytrain, cv=kf, scoring='roc_auc').mean()
        return score
    study=optuna.create_study()
    
    study.optimize(objective, n_trials=5)
    print(study.best_params)
    print(-study.best_value)
    print(study.best_params)
    
    model=LogisticRegression(C=0.09536298444122952, class_weight='balanced',max_iter=10000, solver='lbfgs', n_jobs=-1)
    model.fit(Xtrain, Ytrain)
    predictions=model.predict_proba(Xtest)[:,1]
    submission['target']=predictions
    submission.to_csv(r"E:\TensorFlow\大数据之路\kaggle\Categorical_Feature_Encoding_Challenge\result\res2.csv",
                                  index=False)
    

     

     

    展开全文
  • NULL 博文链接:https://tywo45.iteye.com/blog/1208224
  • 为此,提出了一种基于稳健设计的超参数调优方法(称为稳健调优法)。具体地,以SGNS算法中的超参数调优为例,在词语推断任务上实验并得出:经方差分析得到SGNS算法中的七个超参数中的五个对算法预测性能有显著影响,...
  • 优化提高tomcat性能.Tomcat参数调优 大家也许经常会遇到面试时问你会不会TOMCAT性能调优技术,现在奉上
  • nginx参数调优

    千次阅读 2019-06-17 17:52:25
    注:后台有导出的话,其中参数keepalive_timeout可设置大些,为 1065 client_header_buffer_size 4k; 客户端请求的Header头缓冲区大小 client_max_body_size 2048m; 客户端上传的body的最大值(由于会诊之类...

    不完整配置参考(可参考修改或新增以下配置):

    worker_processes 4;
    worker_cpu_affinity = 0001 0010 0100 1000;
    worker_rlimit_nofile 65538;
    
    events {
    	use epoll;
        worker_connections 65538;
    	accept_mutex off;
        multi_accept off;
    }
    
    http {
    	sendfile on;
    	tcp_nopush on;
    	tcp_nodelay on;
    	keepalive_timeout 65;
    	client_header_buffer_size 4k;
    	client_max_body_size 2048m;
    
    	gzip on;
        gzip_disable "msie6";
        gzip_min_length 1024;
        gzip_vary on;
        gzip_comp_level 2;
        gunzip_static on;
        gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
    
        fastcgi_connect_timeout      	600;
    	fastcgi_read_timeout            600;
    	fastcgi_send_timeout            600;
    	fastcgi_buffer_size				64k;
    	fastcgi_buffers 				4 64k;
    
    
        # 静态文件缓存 在各个server中按需单独配置
        server {
        	location ~* .(jpg|jpeg|png|gif|ico)$ {
    		    expires 365d;
    		}
    
    		error_log  /xxx/error.log;
    		access_log off;
        }
    
    }
    

    参数说明:

    worker_processes 4;

    nginx进程数,一般设置为CPU核数量, grep processor /proc/cpuinfo | wc -l 命令可获得CPU核数。

    worker_cpu_affinity = 0001 0010 0100 1000;

    将worker process与指定cpu核绑定,降低由于多CPU核切换造成的寄存器等现场重建带来的性能损耗
    如果为2核,则配置为:worker_cpu_affinity = 01 10;
    如果是8核,则配置为:worker_cpu_affinity 00000001 00000010 00000100 00001000 00010000 00100000 01000000 10000000;
    如果超过8核,(最多开启8个,8个以上会不稳定)则worker_processes auto;且不配置worker_cpu_affinity参数。

    worker_connections 65538;

    每个进程允许的最多连接数,与ulimit -n值保持一致

    worker_rlimit_nofile 65538;

    一个nginx 进程打开的最多文件描述符数目,与worker_connections值保持一致

    sendfile on;

    提高文件传输性能

    tcp_nopush on;

    sendfile为on时这里也应该设为on,数据包会累积一下再一起传输,可以提高一些传输效率。

    tcp_nodelay on;

    小的数据包不等待直接传输

    keepalive_timeout 65;

    keepalive_timeout 指定了与客户端的 keep-alive 链接的超时时间。服务器会在这个时间后关闭链接。降低这个值,以避免让 worker 过长时间的忙碌。

    注:后台有导出的话,其中参数keepalive_timeout可设置大些,为 1065

    client_header_buffer_size 4k;

    客户端请求的Header头缓冲区大小

    client_max_body_size 2048m;

    客户端上传的body的最大值(由于会诊之类的功能有大文件上传,所以这里的值需要设置为可上传最大文件上限)

    gzip on;

    开启Gzip,gzip可以帮助Nginx减少大量的网络传输工作

    gzip_disable “msie6”;

    对IE6浏览器的数据不进行GZIP压缩。

    gzip_min_length 1024;

    Gzip压缩功能对大数据的压缩效果明显,但是如果压缩很小的数据,可能出现越压缩数据量越大的情况,因此应该根据相应页面的大小,选择性开启或者关闭Gzip功能。建议将值设置为1KB。

    gzip_vary on;

    用于设置在使用Gzip功能时是否发送带有“Vary:Accept-Encoding”头域的响应头部,该头域的主要功能是告诉接收方发送的数据经过了压缩处理,开启后端效果是在响应头部Accept-Encoding: gzip,对于本身不支持Gzip的压缩的客户端浏览器是有用的。

    gzip_comp_level 2;

    压缩级别

    gunzip_static on;

    如果客户端浏览器不支持Gzip处理,Nginx服务器将返回解压后的数据,如果客户端浏览器支持Gzip处理。Nginx服务器忽略该指令设置,仍然返回压缩数据。

    gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

    启用gzip压缩的文件类型

    access_log off;

    日志,关闭访问日志,减少磁盘IO

    fastcgi_connect_timeout 600;

    Nginx服务器和后端FastCGI服务器连接的超时时间

    fastcgi_read_timeout 600;

    Nginx允许FastCGI服务器返回数据的超时时间,即在规定时间内后端服务器必须传完所有的数据,否则Nginx将断开这个连接

    fastcgi_read_timeout 600;

    Nginx从FastCGI服务器读取响应信息的超时时间,表示连接建立成功后,Nginx等待后端服务器的响应时间

    fastcgi_buffer_size 64k;

    Nginx FastCGI 的缓冲区大小,用来读取从FastCGI服务器端收到的第一部分响应信息的缓冲区大小

    fastcgi_buffers 4 64k;

    设定用来读取从FastCGI服务器端收到的响应信息的缓冲区大小和缓冲区数量

    location ~* .(jpg|jpeg|png|gif|ico)$ {

            expires 365d;

    }

    静态文件缓存

    配置完成后,执行nginx -s reload命令重新加载配置文件

    展开全文
  • ElasticSearch 参数调优

    千次阅读 2020-02-25 18:20:15
    1. 系统层面的调优 系统层面的调优主要是内存的设定与避免交换内存。 ES 安装后默认设置的堆内存是 1GB,这很明显是不够的,那么接下来就会有一个问题出现:我们要设置多少内存给 ES 呢? 其实这是要看我们集群节点...

    1. 系统层面的调优

    系统层面的调优主要是内存的设定避免交换内存

    ES 安装后默认设置的堆内存是 1GB,这很明显是不够的,那么接下来就会有一个问题出现:我们要设置多少内存给 ES 呢?

    其实这是要看我们集群节点的内存大小,还取决于我们是否在服务器节点上还是否要部署其他服务。

    • 如果内存相对很大,如 64G 及以上,并且我们不在 ES 集群上部署其他服务,那么我建议 ES 内存可以设置为 31G-32G,因为这里有一个 32G 性能瓶颈问题,直白的说就是即使你给了 ES 集群大于 32G 的内存,其性能也不一定会更加优良,甚至会不如设置为 31G-32G 时候的性能。
      以我调优的集群为例,我所调优的服务器节点内存为 64G,服务器节点上也基本不跑其他服务,所以我把 ES 集群内存大小设置为了 31G,以充分发挥集群性能。

    • 设置 ES 集群内存的时候,还有一点就是确保堆内存最小值(Xms)与最大值(Xmx)的大小是相同的,防止程序在运行时改变堆内存大小,这是一个很耗系统资源的过程。

    • 还有一点就是避免交换内存,可以在配置文件中对内存进行锁定,以避免交换内存(也可以在操作系统层面进行关闭内存交换)。对应的参数:bootstrap.mlockall: true

    2. 分片与副本

    • 分片 (shard):ES 是一个分布式的搜索引擎, 索引通常都会分解成不同部分, 分布在不同节点的部分数据就是分片。ES 自动管理和组织分片, 并在必要的时候对分片数据进行再平衡分配, 所以用户基本上不用担心分片的处理细节。创建索引时默认的分片数为 5 个,并且一旦创建不能更改。

    • 副本 (replica):ES 默认创建一份副本,就是说在 5 个主分片的基础上,每个主分片都相应的有一个副本分片。额外的副本有利有弊,有副本可以有更强的故障恢复能力,但也占了相应副本倍数的磁盘空间。

    那我们在创建索引的时候,应该创建多少个分片与副本数呢?

    • 对于副本数,比较好确定,可以根据我们集群节点的多少与我们的存储空间决定,我们的集群服务器多,并且有足够大多存储空间,可以多设置副本数,一般是 1-3 个副本数,如果集群服务器相对较少并且存储空间没有那么宽松,则可以只设定一份副本以保证容灾(副本数可以动态调整)。

    • 对于分片数,是比较难确定的。因为一个索引分片数一旦确定,就不能更改,所以我们在创建索引前,要充分的考虑到,以后我们创建的索引所存储的数据量,否则创建了不合适的分片数,会对我们的性能造成很大的影响。

    3. 参数调优

    下面我会介绍一些 ES 关键参数的调优。

    有很多场景是,我们的 ES 集群占用了多大的 cpu 使用率,该如何调节呢。cpu 使用率高,有可能是写入导致的,也有可能是查询导致的,那要怎么查看呢?

    可以先通过 GET _nodes/{node}/hot_threads 查看线程栈,查看是哪个线程占用 cpu 高,如果是 elasticsearch[{node}][search][T#10] 则是查询导致的,如果是 elasticsearch[{node}][bulk][T#1] 则是数据写入导致的。

    在实际调优中,cpu 使用率很高,如果不是 SSD,建议把 index.merge.scheduler.max_thread_count: 1 索引 merge 最大线程数设置为 1 个,该参数可以有效调节写入的性能。因为在存储介质上并发写,由于寻址的原因,写入性能不会提升,只会降低。

    还有几个重要参数可以进行设置,各位同学可以视自己的集群情况与数据情况而定。

    • index.refresh_interval:这个参数的意思是数据写入后几秒可以被搜索到,默认是 1s。每次索引的 refresh 会产生一个新的 lucene 段, 这会导致频繁的合并行为,如果业务需求对实时性要求没那么高,可以将此参数调大,实际调优告诉我,该参数确实很给力,cpu 使用率直线下降。

    • indices.memory.index_buffer_size:如果我们要进行非常重的高并发写入操作,那么最好将 indices.memory.index_buffer_size 调大一些,index buffer 的大小是所有的 shard 公用的,一般建议(看的大牛博客),对于每个 shard 来说,最多给 512mb,因为再大性能就没什么提升了。ES 会将这个设置作为每个 shard 共享的 index buffer,那些特别活跃的 shard 会更多的使用这个 buffer。默认这个参数的值是 10%,也就是 jvm heap 的 10%。

    • translog:ES 为了保证数据不丢失,每次 index、bulk、delete、update 完成的时候,一定会触发刷新 translog 到磁盘上。在提高数据安全性的同时当然也降低了一点性能。如果你不在意这点可能性,还是希望性能优先,可以设置如下参数:

      "index.translog": {
              "sync_interval": "120s",     --sync间隔调高
              "durability": "async",       -– 异步更新
              "flush_threshold_size":"1g"  --log文件大小
          }
      

      这样设定的意思是开启异步写入磁盘,并设定写入的时间间隔与大小,有助于写入性能的提升。

    还有一些超时参数的设置:

    • discovery.zen.ping_timeout 判断 master 选举过程中,发现其他 node 存活的超时设置
    • discovery.zen.fd.ping_interval 节点被 ping 的频率,检测节点是否存活
    • discovery.zen.fd.ping_timeout 节点存活响应的时间,默认为 30s,如果网络可能存在隐患,可以适当调大
    • discovery.zen.fd.ping_retries ping 失败/超时多少导致节点被视为失败,默认为 3

    4. 其他建议

    还有一些零碎的优化建议喔。

    • 插入索引自动生成 id:当写入端使用特定的 id 将数据写入 ES 时,ES 会检查对应的索引下是否存在相同的 id,这个操作会随着文档数量的增加使消耗越来越大,所以如果业务上没有硬性需求建议使用 ES 自动生成的 id,加快写入速率。

    • 避免稀疏索引:索引稀疏之后,会导致索引文件增大。ES 的 keyword,数组类型采用 doc_values 结构,即使字段是空值,每个文档也会占用一定的空间,所以稀疏索引会造成磁盘增大,导致查询和写入效率降低。

    展开全文
  • 性能参数调优文档

    2013-12-30 12:28:22
    文档为自己做性能测试过程中所得经验,是关于TOMCAT、ORACLE、Mosquitto、Linux的参数调优,希望对大家有帮助
  • XBGBoost参数调优代码.md
  • Flink 参数配置和常见参数调优

    千次阅读 2020-07-27 11:34:54
    Flink参数配置 jobmanger.rpc.address jm的地址。 jobmanager.rpc.port jm的端口号。 jobmanager.heap.mb jm的堆内存大小。不建议配的太大,1-2G足够。 taskmanager.heap.mb tm的堆内存大小。大小视任务量而定。...
  • linux 参数调优笔记

    2021-07-22 17:13:11
    linux 参数调优
  • hive优化之参数调优

    千次阅读 2020-10-17 22:44:21
    这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成...hive优化之参数调优 1、hive参数优化之默认启用本地模式 启动hive本地模式参数,一般建议将其设置为true,即时刻
  • 参数调优主要有以下几种方法: 1、网格搜索(grid search) Grid search 是一种暴力的调参方法,通过遍历所有可能的参数值以获取所有所有参数组合中最优的参数组合。 如果采用较大的搜索范围以及较小的步长,网格...
  • 常见的超参数调优方法

    千次阅读 2019-11-05 15:42:57
    学习器模型中一般有两类参数,一类是可以从数据中学习估计得到,还有一类参数时无法从数据中估计,只能靠人的经验进行设计指定,后者成为超参数。比如,支持向量机里面的C, Kernal, game;朴素贝叶斯里面的alpha等。...
  • ML之XGBoost:XGBoost参数调优的优秀外文翻译—《XGBoost中的参数调优完整指南(带python中的代码)》(一) 目录 概述/Overview 介绍/Introduction 你应该知道什么/What should you know ? 目录/Table of ...
  • ML之XGBoost:XGBoost参数调优的优秀外文翻译—《XGBoost中的参数调优完整指南(带python中的代码)》(三) 目录 3. 参数微调案例/Parameter Tuning with Example 参数微调的一般方法/General Approach for ...
  • 本篇文章主要介绍了eclipse修改jvm参数调优方法(2种),小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 线程池参数调优

    2020-03-29 18:00:24
    ThreadPoolExecutor ThreadPoolExecutor构造函数的五大参数 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, ...
  • 参数调优 问题:超参数有哪些调优方法?
  • 参数调优

    千次阅读 2018-01-08 23:14:23
    参数调优参数调优我们以learning rate和 正则强度为例介绍 搜索策略 一般的超参数调优采用分阶段搜索的方式,1.最开始定义一个广泛的搜索区间,以learning rate为例,可以选取[1e-3,1e-6],正则强度可以...
  • JVM优化3(Tomcat参数调优,JVM参数调优,jvm字节码,代码优化),供大家查阅!!!!!!!!!!!!!!
  • 一、zuul并发调优 zuul默认是使用semaphore隔离,并且最大的并发默认是10 1、修改隔离策略 默认情况下推荐使用 thread 隔离策略 线程池提供了比信号量更好的隔离机制,并且从实际测试发现高吞吐场景下可以完成...
  • linux系统参数调优

    千次阅读 2019-08-09 10:23:09
    一 CPU 参数调优 1.1性能模式调整 1.2开启服务器超线程功能 1.3Numa参数调整 二 内存参数调优 2.1THP(Transparent HugePages) 2.2 ksm调整 2.3swappiness调整 2.4min_free_kbytes调整 2.5 di...
  • 参数调优 这里以单参数max_depth为例,演示机器学习中如何用网格搜索进行参数调优。使用Scikit-Learn库中的GridSearchCV()函数对决策树模型进行参数调优,代码如下。 第1行代码从Scikit-Learn库中引入...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 142,845
精华内容 57,138
关键字:

参数调优