精华内容
下载资源
问答
  • 参数寻优

    千次阅读 2012-03-31 11:30:45
    好吧,既然老师对参数寻优这么感兴趣,我也就勉为其难吧,用最简单、最复杂,却能说明问题的网格法搜索吧: Start bestF=best_t=best_s=best_c=best_f=tempF=0.0 for t=0.1:0.2:0.05 for s=0.7:0.9:0.1 for c=...

    好吧,既然老师对参数寻优这么感兴趣,我也就勉为其难吧,用最简单、最复杂,却能说明问题的网格法搜索吧:

    Start
    bestF=best_t=best_s=best_c=best_f=tempF=0.0
    for t=0.1:0.2:0.05
    	for s=0.7:0.9:0.1
    		for c=0.5:0.7:0.1
    			for f=0.1:0.9:0.05
    			{
    				if  tempF  > bestF
    					bestF = tempF;
    				best_s=s;
    				best_c=c;
    				best_s=s;
    				best_f=f;
    			}
    over
    


    展开全文
  • 【寻优算法】交叉验证(Cross Validation)参数寻优的python实现一、交叉验证的意义二、常用的交叉验证方法1、Hold one method2、K-flod CV3、Leave-One-Out CV(LOO-CV)二、交叉验证参数寻优的python实现1、训练...


    有关交叉验证的博文有很多,这里我会引用几篇博文【参考资料1,2,3,4】,帮助大家温习一下。交叉验证可以用于机器学习训练模型的性能评价,也可以进行参数寻优,本博文主要介绍交叉验证用于机器学习参数寻优的方法。

    一、交叉验证的意义

    交叉验证将原始数据集分组,一部分作为训练集,一本分作为验证集。训练集用于训练模型,验证集用于评价训练模型的性能指标。
    参数寻优的意义:参数的数值决定着模型的性能。
    交叉验证进行参数寻优的意义:如果训练和验证的数据集是相同的,可能验证的结果特别好,但是对于新的数据集预测效果就差强人意,因为过拟合over-fitting)。采用交叉验证方法可以保障验证数据集没有参与过模型的训练,可以给出较为准确的参数寻优结果。

    二、常用的交叉验证方法

    1、Hold one method

    样本数据被分为两组,一组作为训练数据集,用于训练模型,另一组作为验证数据集,用于评估模型性能。
    优点:容易实现,处理简单。
    缺点:没有用到交叉的方法,验证数据集对于模型的训练没有任何贡献。

    2、K-flod CV

    样本数据被分为kk组,每次将一组作为验证数据集,其余的k1k-1组作为训练数据集。这样就会有kk个训练模型,这kk个模型的验证准确率的平均值作为模型的性能指标。
    优点:所有的样本都会被用于模型训练,评价结果可信。
    缺点:相较于Hold one method,处理较为复杂。

    3、Leave-One-Out CV(LOO-CV)

    设原始数据集中有KK个样本,每次选择一个样本作为验证数据集,其余的K1K-1个样本作为训练数据集,这样就会有KK个训练模型,这KK个训练模型的验证准确率平均值为模型的性能指标。
    优点:每次模型训练,几乎所有的样本都会应用到,结果最可信。
    缺点:需要训练的模型较多,且训练数据集样本大,计算成本高。

    二、交叉验证参数寻优的python实现

    1、训练模型和待寻优参数

    本博文选用的训练模型为线性的SVM模型(参考资料【5】),模型的数学表达为:

    minW,b12W2+C2i=1mei2s.t.yi(Wxi+b)1ei,i=1, ,mei0,i=1, ,m\begin{array}{l} \mathop {\min }\limits_{W,b} \frac{1}{2}{\left\| W \right\|^2} + \frac{C}{2}\sum\limits_{i = 1}^m {e_i^2} \\ s.t.{y_i}\left( {W \cdot {x_i} + b} \right) \ge 1 - {e_i},i = 1, \cdots ,m\\ {e_i} \ge 0,i = 1, \cdots ,m \end{array}

    其中WWbb是分隔超平面的权重和偏置,模型的训练就是为了训练WWbb的值。CC是正则化参数,对模型的性能有很大的影响,本博文就是用3-flod交叉验证方法求参数CC值。

    2、算法执行步骤

    步骤一、设置参数CC的取值范围
    步骤二、从第一个取值开始,将原始数据集分为3个子数据集(3-flod CV),每次将两个数据子集作为训练集用于线性SVM模型的训练,一个数据子集用于模型验证,共训练3个模型,取三个模型的验证准确率的平均值作为评价指标。参数CC的取值指针加1,重复步骤二,直到最后一个参数CC的取值。
    步骤三:画出参数CC与对应评价指标的示意图。

    3、交叉验证参数寻优的python实现

    代码及样本地址 https://github.com/shiluqiang/CV_parameter_optimization

    import numpy as np
    from sklearn import svm
    from sklearn import cross_validation
    import matplotlib.pyplot as plt
    
    def load_data(file_name):
        '''导入数据集和标签
        input:file_name(string):存储数据的地址
        output:trainX(array):样本数据集
               trainY(array):样本标签
        '''
        f = open(file_name)
        trainX = []
        trainY = []
        for line in f.readlines():
            X_tmp = []
            Y_tmp = []
            lines = line.strip().split('\t')
            for i in range(len(lines)-1):
                X_tmp.append(float(lines[i]))
                Y_tmp.append(float(lines[-1]))
            trainX.append(X_tmp)
            trainY.append(Y_tmp)
        f.close()
        return np.array(trainX),np.array(trainY)
    
    
    ###1.导入训练样本和标签
    trainX,trainY = load_data('data.txt')
    trainY = trainY[:,0]
    
    ###2.设置C的取值范围
    c_list = []
    for i in range(1,21):
        c_list.append(i * 0.5)
    
    ###3.交叉验证优化参数C
    cv_scores = []
    for j in c_list:
        linear_svm = svm.SVC( kernel = 'linear', C = j)
        scores = cross_validation.cross_val_score(linear_svm,trainX,trainY,cv =3,scoring = 'accuracy')
        cv_scores.append(scores.mean())
    
    fig = plt.figure().add_subplot(111)
    fig.plot(c_list,cv_scores)
    fig.set_xlabel('C')
    fig.set_ylabel('Average accuracy')
    plt.show()
    

    4、参数C与评价指标的关系

    在这里插入图片描述
    由上图可知,在本实验中参数CC的最优取值为2。

    参考资料

    1.https://blog.csdn.net/yawei_liu1688/article/details/79138202
    2 https://blog.csdn.net/wong2016/article/details/81407927
    3. http://www.cnblogs.com/pinard/p/5992719.html
    4. https://blog.csdn.net/qq_36523839/article/details/80707678
    5. https://blog.csdn.net/google19890102/article/details/35566949

    展开全文
  • 【寻优算法】交叉验证(Cross Validation)参数寻优的python实现:多参数寻优一、网格搜索原理二、网格搜索+交叉验证用于多参数寻优的python实现1、训练模型及待寻优参数2、直接循环嵌套实现网格搜索 + cross_...


    交叉验证的基础知识可参考上一篇博文,本博文主要介绍使用交叉验证进行多参数寻优时的参数搜索方法:网格搜索(Grid Search)以及网格搜索两种常用的python实现方式。

    一、网格搜索原理

    网格搜索是一种穷举搜索方法,通过循环遍历多参数的可能取值情况,性能最好的模型对应的参数就是最优参数。

    二、网格搜索+交叉验证用于多参数寻优的python实现

    代码及样本地址: https://github.com/shiluqiang/python_GridSearch-CV

    1、训练模型及待寻优参数

    本博文选用的多参数机器学习模型为非线性SVM(参考资料【1】),模型的优化问题为:

    minW,e12W2+C2i=1mei2s.t.yi(Wφ(xi)+b)1ei,i=1, ,me0,i=1, ,m\begin{array}{l} \mathop {\min }\limits_{W,e} \frac{1}{2}{\left\| W \right\|^2} + \frac{C}{2}\sum\limits_{i = 1}^m {{e_i}^2} \\ s.t.{y_i}\left( {W \cdot \varphi ({x_i}) + b} \right) \ge 1 - {e_i},i = 1, \cdots ,m\\ e \ge 0,i = 1, \cdots ,m \end{array}

    通过Lagrange乘数法并转化为对偶问题,优化问题转换为:

    minα12imjmαiαjyiyjK(xi,xj)i=1mαis.t.i=1mαiyi=00αiC,i=1, ,m\begin{array}{l} \mathop {\min }\limits_\alpha \frac{1}{2}\sum\limits_i^m {\sum\limits_j^m {{\alpha _i}{\alpha _j}{y^i}{y^j}K\left( {{x_i},{x_j}} \right) - \sum\limits_{i = 1}^m {{\alpha _i}} } } \\ s.t.\sum\limits_{i = 1}^m {{\alpha _i}{y^i} = 0} \\ 0 \le {\alpha _i} \le C,i = 1, \cdots ,m \end{array}

    其中:K(xi,xj)=exp(xixj22σ2)K\left( {{x_i},{x_j}} \right) = \exp \left( { - \frac{{{{\left\| {{x_i} - {x_j}} \right\|}^2}}}{{2{\sigma ^2}}}} \right)

    非线性SVM有两个参数:正则化参数CC和核参数σ\sigma

    2、直接循环嵌套实现网格搜索 + cross_validation

    import numpy as np
    from sklearn import svm
    from sklearn import cross_validation
    from sklearn.model_selection import GridSearchCV
    
    def load_data(data_file):
        '''导入训练数据
        input:  data_file(string):训练数据所在文件
        output: data(mat):训练样本的特征
                label(mat):训练样本的标签
        '''
        data = []
        label = []
        f = open(data_file)
        for line in f.readlines():
            lines = line.strip().split(' ')
            
            # 提取得出label
            label.append(float(lines[0]))
            # 提取出特征,并将其放入到矩阵中
            index = 0
            tmp = []
            for i in range(1, len(lines)):
                li = lines[i].strip().split(":")
                if int(li[0]) - 1 == index:
                    tmp.append(float(li[1]))
                else:
                    while(int(li[0]) - 1 > index):
                        tmp.append(0)
                        index += 1
                    tmp.append(float(li[1]))
                index += 1
            while len(tmp) < 13:
                tmp.append(0)
            data.append(tmp)
        f.close()
        return np.array(data), np.array(label).T
    
    ### 1.导入数据集
    trainX,trainY = load_data('heart_scale')
    
    ### 2.设置C和sigma的取值范围
    c_list = []
    for i in range(1,50):
        c_list.append(i * 0.5)
        
    gamma_list = []
    for j in range(1,40):
        gamma_list.append(j * 0.2)
        
    ### 3.1循环嵌套实现网格搜索 + 交叉验证
    best_value = 0.0
    
    for i in c_list:
        for j in gamma_list:
            current_value = 0.0
            rbf_svm = svm.SVC(kernel = 'rbf', C = i, gamma = j)
            scores = cross_validation.cross_val_score(rbf_svm,trainX,trainY,cv =3,scoring = 'accuracy')
            current_value = scores.mean()
            if current_value >= best_value:
                best_value = current_value
                best_parameters = {'C': i, 'gamma': j}
            print('Best Value is :%f'%best_value)
            print('Best Parameters is',best_parameters)
    

    3、GridSearchCV

    import numpy as np
    from sklearn import svm
    from sklearn.model_selection import GridSearchCV
    
    def load_data(data_file):
        '''导入训练数据
        input:  data_file(string):训练数据所在文件
        output: data(mat):训练样本的特征
                label(mat):训练样本的标签
        '''
        data = []
        label = []
        f = open(data_file)
        for line in f.readlines():
            lines = line.strip().split(' ')
            
            # 提取得出label
            label.append(float(lines[0]))
            # 提取出特征,并将其放入到矩阵中
            index = 0
            tmp = []
            for i in range(1, len(lines)):
                li = lines[i].strip().split(":")
                if int(li[0]) - 1 == index:
                    tmp.append(float(li[1]))
                else:
                    while(int(li[0]) - 1 > index):
                        tmp.append(0)
                        index += 1
                    tmp.append(float(li[1]))
                index += 1
            while len(tmp) < 13:
                tmp.append(0)
            data.append(tmp)
        f.close()
        return np.array(data), np.array(label).T
    
    ### 1.导入数据集
    trainX,trainY = load_data('heart_scale')
    
    ### 2.设置C和sigma的取值范围
    c_list = []
    for i in range(1,50):
        c_list.append(i * 0.5)
        
    gamma_list = []
    for j in range(1,40):
        gamma_list.append(j * 0.2)
        
    ### 3.2 GridSearchCV(网格搜索+CV)
    param_grid = {'C': c_list,
                  'gamma':gamma_list}
    
    rbf_svm1 = svm.SVC(kernel = 'rbf')
    grid = GridSearchCV(rbf_svm1, param_grid, cv=3, scoring='accuracy')
    grid.fit(trainX,trainY)
    best_parameter = grid.best_params_
    print(best_parameter)
    

    参考资料

    1.https://blog.csdn.net/google19890102/article/details/35989959

    展开全文
  • PI参数寻优

    2017-12-13 10:20:32
    PI参数寻优,是PSCAD4.5版本的一个参数寻优算例,典型模块
  • 【寻优算法】遗传算法(Genetic Algorithm) 参数寻优的python实现:多参数寻优一、遗传算法简介1、遗传算法由来2、遗传算法名词概念3、遗传算法中对染色体的操作3.1、选择3.2、交叉3.3、变异二、遗传算法多参数寻优...


    本博文首先简单介绍遗传算法(Genetic Algorithm)的基础知识,然后以为非线性SVM为例给出遗传算法多参数寻优的python实现。

    一、遗传算法简介

    遗传算法介绍部分主要参考(资料【1】),介绍过程中为方便大家理解相关概念,会有部分本人的理解,如有错误,请在评论区指正。

    1、遗传算法由来

    本人之前的两篇博文(资料【2,3】)分别介绍了如何用交叉验证方法进行单一参数和多参数寻优,交叉验证其实只是计算模型的评价指标的方法,参数的搜索过程其实是根据提前给出的取值范围进行穷举,如果参数取值范围给定的不合理,最优化参数就无从谈起。有没有一种方法,参数的取值范围可以随机设定,并在优化过程中不断变化,直到找到最优参数?

    遗传算法是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型,是一种通过模拟自然进化过程搜索最优解的方法。

    2、遗传算法名词概念

    染色体(个体):在参数寻优问题中一个染色体代表一个参数,染色体的十进制数值,用于获取待寻优参数实际输入到模型中的值。
    基因:每一个染色体都对应多个基因,基因是二进制数,基因的取值长度是染色体的长度。遗传算法的交叉、变异操作都是对染色体的基因进行的。
    种群:初始化的染色体取值范围。
    适应度函数:表征每一组染色体(每一组参数)对应的模型评价指标(本博文的python实例中,采用3-flod 交叉检验的平均值作为适应度函数值)。

    假设对于两个参数的寻优,我们设定染色体长度为20,种群数为200,就是说初始化两个染色体,每个染色体初始化200个可能的值,每一个染色体的十进制数值用20位二进制数表示。

    3、遗传算法中对染色体的操作

    随机产生的初始化染色体取值范围中,不一定包含最优的参数取值,为了找到最优的染色体,需要不断对适应度函数值表现优秀的染色体进行操作,直到找到最优的染色体。具体操作如下:

    3.1、选择

    染色体选择是为了把适应度函数值表现好的染色体选出来,保持种群数量不变,就是将适应度函数值表现好的染色体按照更高的概率保存到下一代种群中(下一代种群中更多的染色体是上一代适应度函数值表现好的染色体),具体方法可参考【资料1

    3.2、交叉

    交叉操作是为了产生新的染色体,将不同染色体的部分基因进行交换,具体方法有单点交叉和多点交叉。

    3.3、变异

    变异操作同样是为了产生新的染色体,通过改变部分染色体的部分基因。

    选择、交叉、变异这三种操作,既保证了适应度函数值表现好的染色体尽可能的保留到下一代种群,又能保证下一代种群的变化,可以产生新的染色体。

    二、遗传算法多参数寻优思路

    多参数寻优和单一参数寻优的基本思路是相同的,不过在种群初始化时,每次需要初始化两个染色体,并且在选择、交叉、变异操作时,两个染色体是分别进行的。

    步骤一:种群、染色体、基因初始化。
    步骤二:计算种群中每一组染色体对应的适应度函数值。
    步骤三:对种群中的染色体进行选择、交叉、变异操作,产生新的种群。
    步骤四:判断是否满足终止条件?如果不满足,跳转到步骤二;如果满足,输出最优参数。
    步骤五:结束。

    三、遗传算法多参数寻优的python实现

    完整的python代码及数据样本地址:https://github.com/shiluqiang/GA_python-for-multi-parameters-optimization

    ## 2. GA优化算法
    class GA(object):
    ###2.1 初始化    
        def __init__(self,population_size,chromosome_num,chromosome_length,max_value,iter_num,pc,pm):
            '''初始化参数
            input:population_size(int):种群数
                  chromosome_num(int):染色体数,对应需要寻优的参数个数
                  chromosome_length(int):染色体的基因长度
                  max_value(float):作用于二进制基因转化为染色体十进制数值
                  iter_num(int):迭代次数
                  pc(float):交叉概率阈值(0<pc<1)
                  pm(float):变异概率阈值(0<pm<1)
            '''
            self.population_size = population_size
            self.choromosome_length = chromosome_length
            self.chromosome_num = chromosome_num
            self.iter_num = iter_num
            self.max_value = max_value
            self.pc = pc   ##一般取值0.4~0.99
            self.pm = pm   ##一般取值0.0001~0.1
            
        def species_origin(self):
            '''初始化种群、染色体、基因
            input:self(object):定义的类参数
            output:population(list):种群
            '''
            population = []
            ## 分别初始化两个染色体        
            for i in range(self.chromosome_num):
                tmp1 = []  ##暂存器1,用于暂存一个染色体的全部可能二进制基因取值
                for j in range(self.population_size):
                    tmp2 = [] ##暂存器2,用于暂存一个染色体的基因的每一位二进制取值
                    for l in range(self.choromosome_length):
                        tmp2.append(random.randint(0,1))
                    tmp1.append(tmp2)
                population.append(tmp1)
            return population
    ###2.2 计算适应度函数值
        def translation(self,population):
            '''将染色体的二进制基因转换为十进制取值
            input:self(object):定义的类参数
                  population(list):种群
            output:population_decimalism(list):种群每个染色体取值的十进制数
            '''
            population_decimalism = []
            for i in range(len(population)):
                tmp = []  ##暂存器,用于暂存一个染色体的全部可能十进制取值
                for j in range(len(population[0])):
                    total = 0.0
                    for l in range(len(population[0][0])):
                        total += population[i][j][l] * (math.pow(2,l))
                    tmp.append(total)
                population_decimalism.append(tmp)
            return population_decimalism
        
        def fitness(self,population):
            '''计算每一组染色体对应的适应度函数值
            input:self(object):定义的类参数
                  population(list):种群
            output:fitness_value(list):每一组染色体对应的适应度函数值
            '''
            fitness = []
            population_decimalism = self.translation(population)
            for i in range(len(population[0])):
                tmp = [] ##暂存器,用于暂存每组染色体十进制数值
                for j in range(len(population)):
                    value = population_decimalism[j][i] * self.max_value / (math.pow(2,self.choromosome_length) - 10)                
                    tmp.append(value)
                ## rbf_SVM 的3-flod交叉验证平均值为适应度函数值
                ## 防止参数值为0
                if tmp[0] == 0.0:
                    tmp[0] = 0.5
                if tmp[1] == 0.0:
                    tmp[1] = 0.5
                rbf_svm = svm.SVC(kernel = 'rbf', C = abs(tmp[0]), gamma = abs(tmp[1]))
                cv_scores = cross_validation.cross_val_score(rbf_svm,trainX,trainY,cv =3,scoring = 'accuracy')
                fitness.append(cv_scores.mean())
            
            ##将适应度函数值中为负数的数值排除
            fitness_value = []
            num = len(fitness)
            for l in range(num):
                if (fitness[l] > 0):
                    tmp1 = fitness[l]
                else:
                    tmp1 = 0.0
                fitness_value.append(tmp1)
            return fitness_value
        
    ###2.3 选择操作
        def sum_value(self,fitness_value):
            '''适应度求和
            input:self(object):定义的类参数
                  fitness_value(list):每组染色体对应的适应度函数值
            output:total(float):适应度函数值之和
            '''
            total = 0.0
            for i in range(len(fitness_value)):
                total += fitness_value[i]
            return total
        
        def cumsum(self,fitness1):
            '''计算适应度函数值累加列表
            input:self(object):定义的类参数
                  fitness1(list):适应度函数值列表
            output:适应度函数值累加列表
            '''
            ##计算适应度函数值累加列表
            for i in range(len(fitness1)-1,-1,-1): # range(start,stop,[step]) # 倒计数
                total = 0.0
                j=0
                while(j<=i):
                     total += fitness1[j]
                     j += 1
                fitness1[i] = total
                
        def selection(self,population,fitness_value):
            '''选择操作
            input:self(object):定义的类参数
                  population(list):当前种群
                  fitness_value(list):每一组染色体对应的适应度函数值
            '''
            new_fitness = [] ## 用于存储适应度函归一化数值
            total_fitness = self.sum_value(fitness_value) ## 适应度函数值之和
            for i in range(len(fitness_value)):
                new_fitness.append(fitness_value[i] / total_fitness)
                
            self.cumsum(new_fitness)
            
            ms = [] ##用于存档随机数
            pop_len=len(population[0]) ##种群数
            
            for i in range(pop_len):
                ms.append(random.randint(0,1))
            ms.sort() ## 随机数从小到大排列
            
            ##存储每个染色体的取值指针
            fitin = 0
            newin = 0
    
            new_population = population
            
            ## 轮盘赌方式选择染色体
            while newin < pop_len & fitin < pop_len:
                if(ms[newin] < new_fitness[fitin]):
                    for j in range(len(population)):
                        new_population[j][newin]=population[j][fitin]
                    newin += 1
                else:
                    fitin += 1            
                    
            population = new_population
    
    ### 2.4 交叉操作        
        def crossover(self,population):
            '''交叉操作
            input:self(object):定义的类参数
                  population(list):当前种群
            '''
            pop_len = len(population[0])
            
            for i in range(len(population)):    
                for j in range(pop_len - 1):
                    if (random.random() < self.pc):                    
                        cpoint = random.randint(0,len(population[i][j])) ## 随机选择基因中的交叉点
                        ###实现相邻的染色体基因取值的交叉                    
                        tmp1 = []
                        tmp2 = []
                        #将tmp1作为暂存器,暂时存放第i个染色体第j个取值中的前0到cpoint个基因,
                        #然后再把第i个染色体第j+1个取值中的后面的基因,补充到tem1后面
                        tmp1.extend(population[i][j][0:cpoint])
                        tmp1.extend(population[i][j+1][cpoint:len(population[i][j])])
                        #将tmp2作为暂存器,暂时存放第i个染色体第j+1个取值中的前0到cpoint个基因,
                        #然后再把第i个染色体第j个取值中的后面的基因,补充到tem2后面
                        tmp2.extend(population[i][j+1][0:cpoint])
                        tmp2.extend(population[i][j][cpoint:len(population[i][j])])
                        #将交叉后的染色体取值放入新的种群中
                        population[i][j] = tmp1
                        population[i][j+1] = tmp2
    ### 2.5 变异操作
        def mutation(self,population):
            '''变异操作
            input:self(object):定义的类参数
                  population(list):当前种群
            '''
            pop_len = len(population[0]) #种群数
            Gene_len = len(population[0][0]) #基因长度
            for i in range(len(population)):
                for j in range(pop_len):
                    if (random.random() < self.pm):
                        mpoint = random.randint(0,Gene_len - 1) ##基因变异位点
                        ##将第mpoint个基因点随机变异,变为0或者1
                        if (population[i][j][mpoint] == 1):
                            population[i][j][mpoint] = 0
                        else:
                            population[i][j][mpoint] = 1
    
    ### 2.6 找出当前种群中最好的适应度和对应的参数值
        def best(self,population_decimalism,fitness_value):
            '''找出最好的适应度和对应的参数值
            input:self(object):定义的类参数
                  population(list):当前种群
                  fitness_value:当前适应度函数值列表
            output:[bestparameters,bestfitness]:最优参数和最优适应度函数值
            '''
            pop_len = len(population_decimalism[0])
            bestparameters = []  ##用于存储当前种群最优适应度函数值对应的参数
            bestfitness = 0.0    ##用于存储当前种群最优适应度函数值
            
            for i in range(0,pop_len):
                tmp = []
                if (fitness_value[i] > bestfitness):
                    bestfitness = fitness_value[i]
                    for j in range(len(population_decimalism)):
                        tmp.append(abs(population_decimalism[j][i]  * self.max_value / (math.pow(2,self.choromosome_length) - 10)))
                        bestparameters = tmp
                    
            return bestparameters,bestfitness
        
    ### 2.7 画出适应度函数值变化图
        def plot(self,results):
            '''画图
            '''
            X = []
            Y = []
            for i in range(self.iter_num):
                X.append(i + 1)
                Y.append(results[i])
            plt.plot(X,Y)
            plt.xlabel('Number of iteration',size = 15)
            plt.ylabel('Value of CV',size = 15)
            plt.title('GA_RBF_SVM parameter optimization')
            plt.show()
    
    ### 2.8 主函数
        def main(self):
            results = []
            parameters = []
            best_fitness = 0.0
            best_parameters = []
            ## 初始化种群
            population = self.species_origin()
            ## 迭代参数寻优
            for i in range(self.iter_num):
                ##计算适应函数数值列表
                fitness_value = self.fitness(population)
                ## 计算当前种群每个染色体的10进制取值
                population_decimalism = self.translation(population)
                ## 寻找当前种群最好的参数值和最优适应度函数值
                current_parameters, current_fitness = self.best(population_decimalism,fitness_value)
                ## 与之前的最优适应度函数值比较,如果更优秀则替换最优适应度函数值和对应的参数
                if current_fitness > best_fitness:
                    best_fitness = current_fitness
                    best_parameters = current_parameters
                print('iteration is :',i,';Best parameters:',best_parameters,';Best fitness',best_fitness)
                results.append(best_fitness)
                parameters.append(best_parameters)
                
                ## 种群更新
                ## 选择
                self.selection(population,fitness_value)
                ## 交叉
                self.crossover(population)
                ## 变异
                self.mutation(population)
            results.sort()
            self.plot(results)
            print('Final parameters are :',parameters[-1])
    

    最优的适应度函数值随迭代次数的变化如下图所示。由图可知,在第24次迭代时,参数达到最优,最优参数为[7.79372018547235, 0.010538201696412052]。
    在这里插入图片描述

    参考资料

    1、https://blog.csdn.net/quinn1994/article/details/80501542
    2、https://blog.csdn.net/Luqiang_Shi/article/details/84570133
    3、https://blog.csdn.net/Luqiang_Shi/article/details/84579052

    展开全文
  • SVM参数寻优

    2016-03-22 18:02:08
    SVM参数寻优
  • 【超参数寻优】遗传算法(GA) 超参数寻优的python实现本博文首先简单介绍遗传算法(Genetic Algorithm)的基础知识,然后以为非线性SVM为例给出遗传算法多参数寻优的python实现。一、遗传算法简介遗传算法介绍部分主要...
  • 前面介绍了参数寻优的传统方法,梯度下降,牛顿下降等,传统的参数寻优方法,都是提供了下降的方向和大小参考。如果参数非常多,成千上万个参数,很多峰谷时,有没有较好的方法去估计最优解呢。本文介绍的方法就是在...
  • 【寻优算法】粒子群算法(PSO) 参数寻优的python实现一、算法原理1、粒子群算法的名词解释2、粒子更新二、PSO算法参数寻优的python实现参考资料 粒子群优化算法(Particle swarm optimization,PSO)是模拟鸟群...
  • 【超参数寻优】量子遗传算法(QGA) 超参数寻优的java实现 本文基于【超参数寻优】量子遗传算法(QGA) 超参数寻优的python实现 这篇文章改写为Java代码实现,其中适应度计算本文简化了操作。 后期想改写成解决TSP...
  • 【寻优算法】量子遗传算法(QGA) 参数寻优的python实现:多参数寻优一、量子编码1、染色体量子编码2、量子编码转换为二进制编码二、量子进化1、全干扰交叉2、量子变异三、QGA多参数寻优的python实现1、训练模型及待...
  • 【寻优算法】量子粒子群算法(QPSO) 参数寻优的python实现一、粒子群算法的缺点二、量子粒子群算法三、QPSO算法的python实现参考资料 一、粒子群算法的缺点 本人之前的博文(参考资料【1】)已经详细介绍了PSO...
  • SVM参数寻优,寻找最佳的C和g,还可以做数据集的交叉验证。
  • 自定义函数使用GridSearchCV参数寻优GirdSearchCV and RandomizedSearchCV自定义函数中使用GirdSearchCVGridSearchCV参数说明GridSearchCV常用方法GridSearchCV属性说明自定义函数使用GridSearchCV GirdSearchCV and...
  • 函数使用接口: 利用PSO参数寻优函数(分类问题);利用PSO参数寻优函数(回归问题)
  • 果蝇参数寻优最小二乘支持向量机FOA-LSSVM的完整程序,自己写的
  • http://scikit-learn.org/stable/modules/grid_search.html1. 超参数寻优方法 gridsearchCV 和... 参数寻优的技巧进阶2.1.Specifying an objective metricBy default, parameter search uses thescorefunction ...
  • nbspmatlab基于MATLAB的PID参数寻优.pdf4页本文档一共被下载:次,您可全文免费在线阅读后下载本文档。 下载提示1.本站不保证该用户上传的文档完整性,不预览、不比对内容而直接下载产生的反悔问题本站不予受理。2....
  • result89.txt 这段批处理代码首先调用subset.py对文件b59.txt执行1000次分层随机抽样(对数据进行80-20%分割)然后调用easy.py 进行1000次参数寻优,把记录结果写到result89.txt中 (包括1000次训练的分类准确率和参数...
  • 基于粒子群算法的PID参数寻优(MATLA程序),利用混合粒子去算法寻优参数。
  • grid search 超参数寻优

    2017-09-05 13:39:00
    1. 超参数寻优方法 gridsearchCV 和RandomizedSearchCV 2. 参数寻优的技巧进阶 2.1.Specifying an objective metric By default, parameter search uses ...
  • 因此我们通常并不会把所有的数据集都拿来训练,而是分出一部分来(这一部分不参加训练)对训练集生成的参数进行测试,相对客观的判断这些参数对训练集之外的数据的符合程度。这种思想就称为交叉验证(Cross Validation)...
  • 参数寻优问题详细解析

    万次阅读 2015-09-29 15:55:44
    参数寻优 参数寻优背景  参数寻优问题随处可见,举几个例子。   1. 小明假期结束回校,可以坐火车,可以坐汽车,可以坐飞机,还可以走着,小明从哪条路去学校更好呢?   2. 简单的数学,一元二次方程...
  • 模型参数寻优过程基于ARMA(2n,2n-1)模型架构依次跳阶,每阶的参数初估后运用AMPSO算法展开寻优,适应度判定标准为当前模型残差方差最小。针对齿轮箱轴承的输出扭矩进行预测,结果表明,AMPSO算法在收敛性和寻优...
  • libsvm中使用python进行参数寻优,显示出错:File"c:\python26\gridregression.py",line17else:^是什么错误?其中gridregression.py文件是网上下载的,没有修改过gridregression.py程...libsvm中使用python进行参数...

空空如也

空空如也

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

参数寻优