精华内容
下载资源
问答
  • SVM(支持向量机)参数寻优,用到的方法是交叉验证法。
  • SVM参数寻优,寻找最佳的C和g,还可以做数据集的交叉验证。
  • PI参数寻优

    2017-12-13 10:20:32
    PI参数寻优,是PSCAD4.5版本的一个参数寻优算例,典型模块
  • 基于粒子群算法的PID参数寻优(MATLA程序),利用混合粒子去算法寻优参数。
  • 文档介绍了基于MIT律的自适应模型参考自适应控制基本原理 基于Simulink进行了仿真实验 文档中包含了详细的Simulink仿真图以供参考 文档内容仅限学习交流使用,需要仿真原文件可联系hit_lu@foxmail.com,长期有效
  • 【寻优算法】量子粒子群算法(QPSO) 参数寻优的python实现一、粒子群算法的缺点二、量子粒子群算法三、QPSO算法的python实现参考资料 一、粒子群算法的缺点 本人之前的博文(参考资料【1】)已经详细介绍了PSO...

    【超参数寻优】量子粒子群算法(QPSO) 超参数寻优的python实现

    一、粒子群算法的缺点

    本人之前的博文(参考资料【1】)已经详细介绍了PSO算法,学习本博文前需要先学习PSO算法。

    PSO算法的缺点:
    1、需要设定的参数(惯性因子 w w w,局部学习因子 c 1 {c_1} c1和全局学习因子 c 2 {c_2} c2)太多,不利于找到待优化模型的最优参数。
    2、粒子位置变化缺少随机性,容易陷入局部最优的陷阱。

    二、量子粒子群算法

    量子粒子群优化(Quantum Particle Swarm Optimization,QPSO)算法取消了粒子的移动方向属性,粒子位置的更新跟该粒子之前的运动没有任何关系,这样就增加了粒子位置的随机性(参考资料【2】)。
    量子粒子群算法中引入的新名词:
    mbest:表示pbest的平均值,即平均的粒子历史最好位置。
    量子粒子群算法的粒子更新步骤:
    步骤一:计算mbest

    M b e s t = 1 M ∑ i = 1 M p b e s t _ i {M_{best}} = \frac{1}{M}\sum\limits_{i = 1}^M {{p_{best\_i}}} Mbest=M1i=1Mpbest_i

    其中 M M M表示粒子群的大小, p b e s t _ i {p_{best\_i}} pbest_i表示当前迭代中的第 i i i p b e s t pbest pbest

    步骤二:粒子位置更新

    P i = ϕ ⋅ p b e s t _ i + ( 1 − ϕ ) g b e s t {P_i} = \phi \cdot {p_{best\_i}} + (1 - \phi )gbest Pi=ϕpbest_i+(1ϕ)gbest

    其中 g b e s t gbest gbest表示当前全局最优粒子, P i {P_i} Pi用于第 i i i个粒子位置的更新。
    粒子位置更新公式为:

    x i = P i ± α ∣ M b e s t − x i ∣ ln ⁡ ( 1 u ) {x_i} = {P_i} \pm \alpha \left| {{M_{best}} - {x_i}} \right|\ln \left( {\frac{1}{u}} \right) xi=Pi±αMbestxiln(u1)

    其中 x i {x_i} xi表示第 i i i个粒子的位置, α \alpha α为创新参数, ϕ \phi ϕ u u u ( 0 , 1 ) (0,1) 0,1上的均匀分布数值。取 + + + − - 的概率为0.5。

    由上所示,QPSO算法中只有一个创新参数 α \alpha α设置,一般 α \alpha α不大于1。

    三、QPSO算法的python实现

    完整python代码和样本地址:https://github.com/shiluqiang/QPSO_python
    本博文以非线性SVM为待优化模型,待优化参数为正则化参数 C C C和核参数 σ \sigma σ,适应度函数值为3-fold交叉验证平均值。

    ## 2. QPSO算法
    class QPSO(object):
        def __init__(self,particle_num,particle_dim,alpha,iter_num,max_value,min_value):
            '''定义类参数
            particle_num(int):粒子群大小
            particle_dim(int):粒子维度,对应待寻优参数的个数
            alpha(float):控制系数
            iter_num(int):最大迭代次数
            max_value(float):参数的最大值
            min_value(float):参数的最小值
            '''
            self.particle_num = particle_num
            self.particle_dim = particle_dim
            self.iter_num = iter_num
            self.alpha = alpha
            self.max_value = max_value
            self.min_value = min_value
    
    ### 2.1 粒子群初始化
        def swarm_origin(self):
            '''初始化粒子群中的粒子位置
            input:self(object):QPSO类
            output:particle_loc(list):粒子群位置列表
            '''
            particle_loc = []
            for i in range(self.particle_num):
                tmp1 = []
                for j in range(self.particle_dim):
                    a = random.random()
                    tmp1.append(a * (self.max_value - self.min_value) + self.min_value)
                particle_loc.append(tmp1)
            
            return particle_loc
    
    ### 2.2 计算适应度函数数值列表
        def fitness(self,particle_loc):
            '''计算适应度函数值
            input:self(object):PSOparticle_loc(list):粒子群位置列表
            output:fitness_value(list):适应度函数值列表
            '''
            fitness_value = []
            ### 1.适应度函数为RBF_SVM3_fold交叉校验平均值
            for i in range(self.particle_num):
                rbf_svm = svm.SVC(kernel = 'rbf', C = particle_loc[i][0], gamma = particle_loc[i][1])
                cv_scores = cross_validation.cross_val_score(rbf_svm,trainX,trainY,cv =3,scoring = 'accuracy')
                fitness_value.append(cv_scores.mean())
            ### 2. 当前粒子群最优适应度函数值和对应的参数
            current_fitness = 0.0
            current_parameter = []
            for i in range(self.particle_num):
                if current_fitness < fitness_value[i]:
                    current_fitness = fitness_value[i]
                    current_parameter = particle_loc[i]
    
            return fitness_value,current_fitness,current_parameter
    
    ### 2.3 粒子位置更新    
        def updata(self,particle_loc,gbest_parameter,pbest_parameters):
            '''粒子位置更新
            input:self(object):QPSOparticle_loc(list):粒子群位置列表
                  gbest_parameter(list):全局最优参数
                  pbest_parameters(list):每个粒子的历史最优值
            output:particle_loc(list):新的粒子群位置列表
            '''
            Pbest_list = pbest_parameters
            #### 2.3.1 计算mbest
            mbest = []
            total = []
            for l in range(self.particle_dim):
                total.append(0.0)
            total = np.array(total)
            
            for i in range(self.particle_num):
                total += np.array(Pbest_list[i])
            for j in range(self.particle_dim):
                mbest.append(list(total)[j] / self.particle_num)
            
            #### 2.3.2 位置更新
            ##### Pbest_list更新
            for i in range(self.particle_num):
                a = random.uniform(0,1)
                Pbest_list[i] = list(np.array([x * a for x in Pbest_list[i]]) + np.array([y * (1 - a) for y in gbest_parameter]))
            ##### particle_loc更新
            for j in range(self.particle_num):
                mbest_x = []  ## 存储mbest与粒子位置差的绝对值
                for m in range(self.particle_dim):
                    mbest_x.append(abs(mbest[m] - particle_loc[j][m]))
                u = random.uniform(0,1)
                if random.random() > 0.5:
                    particle_loc[j] = list(np.array(Pbest_list[j]) + np.array([self.alpha * math.log(1 / u) * x for x in mbest_x]))
                else:
                    particle_loc[j] = list(np.array(Pbest_list[j]) - np.array([self.alpha * math.log(1 / u) * x for x in mbest_x]))
                    
            #### 2.3.3 将更新后的量子位置参数固定在[min_value,max_value]内 
            ### 每个参数的取值列表
            parameter_list = []
            for i in range(self.particle_dim):
                tmp1 = []
                for j in range(self.particle_num):
                    tmp1.append(particle_loc[j][i])
                parameter_list.append(tmp1)
            ### 每个参数取值的最大值、最小值、平均值   
            value = []
            for i in range(self.particle_dim):
                tmp2 = []
                tmp2.append(max(parameter_list[i]))
                tmp2.append(min(parameter_list[i]))
                value.append(tmp2)
            
            for i in range(self.particle_num):
                for j in range(self.particle_dim):
                    particle_loc[i][j] = (particle_loc[i][j] - value[j][1])/(value[j][0] - value[j][1]) * (self.max_value - self.min_value) + self.min_value
                    
            return particle_loc
    
    ## 2.4 画出适应度函数值变化图
        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('QPSO_RBF_SVM parameter optimization')
            plt.show()         
    
    ## 2.5 主函数
        def main(self):
            results = []
            best_fitness = 0.0 
            ## 1、粒子群初始化
            particle_loc = self.swarm_origin()
            ## 2、初始化gbest_parameter、pbest_parameters、fitness_value列表
            ### 2.1 gbest_parameter
            gbest_parameter = []
            for i in range(self.particle_dim):
                gbest_parameter.append(0.0)
            ### 2.2 pbest_parameters
            pbest_parameters = []
            for i in range(self.particle_num):
                tmp1 = []
                for j in range(self.particle_dim):
                    tmp1.append(0.0)
                pbest_parameters.append(tmp1)
            ### 2.3 fitness_value
            fitness_value = []
            for i in range(self.particle_num):
                fitness_value.append(0.0)
            
            ## 3、迭代
            for i in range(self.iter_num):
                ### 3.1 计算当前适应度函数值列表
                current_fitness_value,current_best_fitness,current_best_parameter = self.fitness(particle_loc)
                ### 3.2 求当前的gbest_parameter、pbest_parameters和best_fitness
                for j in range(self.particle_num):
                    if current_fitness_value[j] > fitness_value[j]:
                        pbest_parameters[j] = particle_loc[j]
                if current_best_fitness > best_fitness:
                    best_fitness = current_best_fitness
                    gbest_parameter = current_best_parameter
                
                print('iteration is :',i+1,';Best parameters:',gbest_parameter,';Best fitness',best_fitness)
                results.append(best_fitness)
                ### 3.3 更新fitness_value
                fitness_value = current_fitness_value
                ### 3.4 更新粒子群
                particle_loc = self.updata(particle_loc,gbest_parameter,pbest_parameters)
            ## 4.结果展示
            results.sort()
            self.plot(results)
            print('Final parameters are :',gbest_parameter)
    

    最优适应度函数值随迭代次数的变化如下图:
    在这里插入图片描述

    参考资料

    1、https://blog.csdn.net/Luqiang_Shi/article/details/84720738
    2、郑伟博. 粒子群优化算法的改进及其应用研究[D]. 2016.

    展开全文
  • 参数寻优请教

    2021-04-22 04:00:22
    %% 参数c和g寻优选择 %GA Method ga_option.maxgen = 50; ga_option.sizepop = 10; ga_option.pCrossover = 0.4; ga_option.pMutation = 0.01; ga_option.cbound = [0.1,100]; ga_option.gbound = [0.1,100]; ga_...

    根据版主视频里的讲解我处理了自己的数据

    tic;

    close all;

    clear;

    clc;

    format compact;

    load jaking2;

    原始数据可视化

    figure;

    boxplot(train_jaking,'orientation','horizontal');

    grid on;

    title('Visualization for original data');

    figure;

    for i = 1:length(train_jaking(:,1))

    plot(train_jaking(i,1),train_jaking(i,2),'r*');

    hold on;

    end

    grid on;

    title('Visualization for 1st dimension & 2nd dimension of original data');

    %% 归一化预处理

    [train_final,test_final] = scaleForSVM(train_jaking,test_jaking,0,1);

    %% 归一化后可视化

    figure;

    for i = 1:length(train_final(:,1))

    plot(train_final(i,1),train_final(i,2),'r*');

    hold on;

    end

    grid on;

    title('Visualization for 1st dimension & 2nd dimension of scale data');

    %% 降维预处理(pca)

    [train_final,test_final] = pcaForSVM(train_final,test_final,90);

    %% 参数c和g寻优选择

    %GA Method

    ga_option.maxgen = 50;

    ga_option.sizepop = 10;

    ga_option.pCrossover = 0.4;

    ga_option.pMutation = 0.01;

    ga_option.cbound = [0.1,100];

    ga_option.gbound = [0.1,100];

    ga_option.v = 10;

    [bestacc,bestc,bestg] = gaSVMcgForClass(train_jaking_labels,train_final,ga_option);

    cmd = ['-c ',num2str(bestc),' -g ',num2str(bestg)];

    %% 分类预测

    model = svmtrain(train_jaking_labels, train_final,cmd);

    [ptrain_label, train_accuracy] = svmpredict(train_jaking_labels, train_final, model);

    train_accuracy;

    [ptest_label, test_accuracy] = svmpredict(test_jaking_labels, test_final, model);

    test_accuracy;

    %% svmplot

    % figure;

    % grid on;

    % svmplot(ptrain_label,train_jaking,model);

    % title('Train Data Set');

    %% 计时结束

    toc

    为什么会出现以下错误……

    Warning: Columns of X are linearly dependent to within machine precision.

    Using only the first 23 components to compute TSQUARED.

    > In princomp at 128

    In D:\Program Files\MATLAB\work\libsvm-mat-2.89-3[FarutoUltimate3.0pcode]\implement[by faruto]PcodeVersion\pcode\pcaForSVM.p>pcaForSVM at 27

    In jaking2_usingSVM_class at 53

    ??? Reference to non-existent field 'ggap'.

    Error in ==> D:\Program

    Files\MATLAB\work\libsvm-mat-2.89-3[FarutoUltimate3.0pcode]\implement[by

    faruto]PcodeVersion\pcode\gaSVMcgForClass.p>gaSVMcgForClass at 35

    Error in ==> jaking2_usingSVM_class at 73

    [bestacc,bestc,bestg] = gaSVMcgForClass(train_jaking_labels,train_final,ga_option);

    展开全文
  • 神经网络在永磁同步电机模型预测控制参数寻优中的应用.pdf
  • 【寻优算法】遗传算法(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

    展开全文
  • result89.txt 这段批处理代码首先调用subset.py对文件b59.txt执行1000次分层随机抽样(对数据进行80-20%分割)然后调用easy.py 进行1000次参数寻优,把记录结果写到result89.txt中 (包括1000次训练的分类准确率和参数...

    首先下载Libsvm、Python和Gnuplot:

    l         libsvm的主页http://www.csie.ntu.edu.tw/~cjlin/libsvm/上下载libsvm (我自己用2.86版本)

    l         python的主页http://www.python.org下载 python (我自己用2.5版本)

    l         gnuplot的主页http://www.gnuplot.info/下载gnuplot  (我用4.0版本)

    LIBSVM 使用的一般步骤是:

    1)按照LIBSVM软件包所要求的格式准备数据集;

    2)对数据进行简单的缩放操作;

    3)首要考虑选用RBF 核函数;

    4)采用交叉验证选择最佳参数C与g ;

    5)采用最佳参数C与g 对整个训练集进行训练获取支持向量机模型;

    6)利用获取的模型进行测试与预测。

    1)LIBSVM使用的数据格式

    该软件使用的训练数据和检验数据文件格式如下:

    [label] [index1]:[value1] [index2]:[value2] ...

    [label] [index1]:[value1] [index2]:[value2] ...

    一行一条记录数据,如:

    +1 1:0.708 2:1 3:1 4:-0.320 5:-0.105 6:-1

    这里(x,y)à((0.708,1,1, -0.320, -0.105, -1), +1)

    label 或说是class, 就是你要分类的种类,通常是一些整数。

    index 是有順序的索引,通常是连续的整数。

    value 就是用来 train 的数据,通常是一堆实数。

    2)对数据进行简单的缩放操作

    扫描数据. 因为原始数据可能范围过大或过小, svmscale可以先将数据重新scale (縮放) 到适当范围使训练与预测速度更快。

    svmscale.exe的用法:svmscale.exe feature.txt feature.scaled

    默认的归一化范围是[-1,1],可以用参数-l和-u分别调整上界和下届,feature.txt是输入特征文件名 输出的归一化特征名为feature.scaled

    3) 考虑选用RBF 核函数

    训练数据形成模型(model),实质是算出了wx+b=0中的w,b.

    Svmtrain的用法:svmtrain [options] training_set_file [model_file]

    其中options涵义如下:

    -s svm类型:设置SVM 类型,默认值为0,可选类型有:

    0 -- C- SVC

    1 -- nu - SVC

    2 -- one-class-SVM

    3 -- e - SVR

    4 -- nu-SVR

    -t 核函数类型:设置核函数类型,默认值为2,可选类型有:

    0 -- 线性核:u'*v

    1 -- 多项式核:(g*u'*v+ coef0)degree

    2 -- RBF 核:exp(-||u-v||*||u-v||/g*g)

    3 -- sigmoid 核:tanh(g*u'*v+ coef 0)

    -d degree:核函数中的degree设置,默认值为3;

    -g r(gama):核函数中的函数设置(默认1/ k);

    -r coef 0:设置核函数中的coef0,默认值为0;

    -c cost:设置C- SVC、e - SVR、n - SVR中从惩罚系数C,默认值为1;

    -n nu :设置nu - SVC、one-class-SVM 与nu - SVR 中参数nu ,默认值0.5;

    -p e :核宽,设置e - SVR的损失函数中的e ,默认值为0.1;

    -m cachesize:设置cache内存大小,以MB为单位(默认40):

    -e e :设置终止准则中的可容忍偏差,默认值为0.001;

    -h shrinking:是否使用启发式,可选值为0 或1,默认值为1;

    -b 概率估计:是否计算SVC或SVR的概率估计,可选值0 或1,默认0;

    -wi weight:对各类样本的惩罚系数C加权,默认值为1;

    -v n:n折交叉验证模式。

    其中-g选项中的k是指输入数据中的属性数。操作参数 -v 随机地将数据剖分为n 部分并计算交叉检验准确度和均方根误差。以上这些参数设置可以按照SVM 的类型和核函数所支持的参数进行任意组合,如果设置的参数在函数或SVM 类型中没有也不会产生影响,程序不会接受该参数;如果应有的参数设置不正确,参数将采用默认值。training_set_file是要进行训练的数据 集;model_file是训练结束后产生的模型文件,该参数如果不设置将采用默认的文件名,也可以设置成自己惯用的文件名。举个例子如下:

    C:\libsvm-2.85\windows>svmtrain heart_scale

    *

    optimization finished, #iter = 162

    nu = 0.431029

    obj = -100.877288, rho = 0.424462

    nSV = 132, nBSV = 107

    Total nSV = 132

    现简单对屏幕回显信息进行说明:

    #iter为迭代次数,

    nu 与前面的操作参数-n nu 相同,

    obj为SVM文件转换为的二次规划求解得到的最小值,

    rho 为判决函数的常数项b,

    nSV 为支持向量个数,

    nBSV为边界上的支持向量个数,

    Total nSV为支持向量总个数。

    训练后的模型保存为文件*.model,用记事本打开其内容如下:

    svm_type c_svc % 训练所采用的svm类型,此处为C- SVC

    kernel_type rbf %训练采用的核函数类型,此处为RBF核

    gamma 0.0769231 %设置核函数中的g ,默认值为1/ k

    nr_class 2 %分类时的类别数,此处为两分类问题

    total_sv 132 %总共的支持向量个数

    rho 0.424462 %决策函数中的常数项b

    label 1 -1%类别标签

    nr_sv 64 68 %各类别标签对应的支持向量个数

    SV %以下为支持向量

    1 1:0.166667 2:1 3:-0.333333 4:-0.433962 5:-0.383562 6:-1 7:-1 8:0.0687023 9:-1 10:-0.903226 11:-1 12:-1 13:1

    0.5104832128985164 1:0.125 2:1 3:0.333333 4:-0.320755 5:-0.406393 6:1 7:1 8:0.0839695 9:1 10:-0.806452 12:-0.333333 13:0.5

    1 1:0.333333 2:1 3:-1 4:-0.245283 5:-0.506849 6:-1 7:-1 8:0.129771 9:-1 10:-0.16129 12:0.333333 13:-1

    1 1:0.208333 2:1 3:0.333333 4:-0.660377 5:-0.525114 6:-1 7:1 8:0.435115 9:-1 10:-0.193548 12:-0.333333 13:1

    4)采用交叉验证选择最佳参数C与g

    通常而言,比较重要的参数是 gamma (-g) 跟 cost (-c) 。而 cross validation (-v)

    的参数常用5。那么如何去选取最优的参数c和g呢?libsvm 的 python 子目录下面的 grid.py 可以帮助我们。 此时。其中安装python2.5需要(一般默认安装到c:\python25

    下),将gnuplot解压。安装解压完毕后,进入\libsvm\tools目录下,用文本编辑器(记事

    本,edit都可以)修改grid.py文件,找到其中关于gnuplot路径的那项(其默认路径为

    gnuplot_exe=r"c:\tmp\gnuplot\bin\pgnuplot.exe"),根据实际路径进行修改,并保存。然

    后,将grid.py和C:\Python25目录下的python.exe文件拷贝到libsvm\windows目录下,键入以下命令:$ python grid.py train.1.scale 执行后,即可得到最优参数c和g。

    另外,至于下libsvm和python的接口的问题,在libsvm2.86中林老师已经帮助我们解决,在\libsvm\windows\python目录下自带了svmc.pyd这个文件,将该文件文件复制到

    libsvm\python目录下,同时,也将python.exe文件复制到该目录下,键入以下命令以检验效

    果(注意:.Py文件中关于gnuplot路径的那项路径一定要根据实际路径修改):

    python svm_test.py

    如果能看到程序执行结果,说明libsvm和python之间的接口已经配置完成,以后就可以直接在python程序里调用libsvm的函数了!

    5) 采用最佳参数C与g 对整个训练集进行训练获取支持向量机模型

    $ svmtrain –c x –g x –v x training_set_file [model_file]

    x为上述得到的最优参数c和g的值,v的值一般取5。

    6)利用获取的模型进行测试与预测

    使用Svmtrain训练好的模型进行测试。输入新的X值,给出SVM预测出的Y值

    $ Svmpredict  test_file  model_file  output_file

    如:./svm-predict heart_scale heart_scale.model heart_scale.out

    Accuracy = 86.6667% (234/270) (classification)

    这里显示的是结果

    一个具体使用的例子。

    以libsvm中的heart_scale作为训练数据和测试数据,同时已经将python安装至c盘,并将grid.py文件中关于gnuplot路径的默认值修改为实际解压缩后的路径,将

    heart_scale、grid.py和python.exe拷贝至\libsvm\windows文件夹下。

    ./svm-train heart_scale

    optimization finished, #iter = 162

    nu = 0.431029

    obj = -100.877288, rho = 0.424462

    nSV = 132, nBSV = 107

    Total nSV = 132

    此时,已经得到heart_scale.model,进行预测:

    ./svm-predict heart_scale  heart_scale.model  heart_scale.out

    Accuracy = 86.6667% (234/270) (classification)

    正确率为Accuracy = 86.6667%。

    ./python grid.py heart_scale

    得到最优参数c=2048,g=0.0001220703125.

    ./svm-train -c 2048 -g 0.0001220703125 heart_scale得到model后,由./svm-predict heart_scale  heart_scale.model heart_scale.out得到的正确

    率为Accuracy = 85.1852%.这块还有点迷惑?为什么正确率降低了?

    当然也可以结合subset.py 和 easy.py 实现自动化过程。

    如果要训练多次,可以写个批处理程序省好多事。

    这里举个例子:

    ::@ echo off

    cls

    :: split the data and output the results

    for /L %%i in (1,1,1000) do python subset.py b59.txt 546 b59(%%i).in8 b59(%%i).out2

    for /L %%i in (1,1,1000) do python easy.py b59(%%i).in8 b59(%%i).out2 >> result89.txt

    这段批处理代码首先调用subset.py对文件b59.txt执行1000次分层随机抽样(对数据进行80-20%分割)然后调用easy.py 进行1000次参数寻优,把记录结果写到result89.txt中

    (包括1000次训练的分类准确率和参数对)。

    还可以调用fselect.py进行特征选择,调用plotroc.py进行roc曲线绘制。

    展开全文
  • 前面介绍了参数寻优的传统方法,梯度下降,牛顿下降等,传统的参数寻优方法,都是提供了下降的方向和大小参考。如果参数非常多,成千上万个参数,很多峰谷时,有没有较好的方法去估计最优解呢。本文介绍的方法就是在...
  • 【寻优算法】粒子群算法(PSO) 参数寻优的python实现一、算法原理1、粒子群算法的名词解释2、粒子更新二、PSO算法参数寻优的python实现参考资料 粒子群优化算法(Particle swarm optimization,PSO)是模拟鸟群...
  • MATLAB中使用LIBSVM进行SVM参数寻优

    千次阅读 2019-07-08 15:43:01
    MATLAB中使用LIBSVM进行SVM参数寻优一些资源网站配置svmtrainsvmParams-t:表示选择的核函数类型-g为核函数的参数系数-c为惩罚因子系数-v为交叉验证的数,默认为5具体介绍c,g选择 一些资源网站 1、libSVM 3.23 这套...
  • 【寻优算法】交叉验证(Cross Validation)参数寻优的python实现一、交叉验证的意义二、常用的交叉验证方法1、Hold one method2、K-flod CV3、Leave-One-Out CV(LOO-CV)二、交叉验证参数寻优的python实现1、训练...
  • 因此我们通常并不会把所有的数据集都拿来训练,而是分出一部分来(这一部分不参加训练)对训练集生成的参数进行测试,相对客观的判断这些参数对训练集之外的数据的符合程度。这种思想就称为交叉验证(Cross ...
  • 模型参数寻优过程基于ARMA(2n,2n-1)模型架构依次跳阶,每阶的参数初估后运用AMPSO算法展开寻优,适应度判定标准为当前模型残差方差最小。针对齿轮箱轴承的输出扭矩进行预测,结果表明,AMPSO算法在收敛性和寻优...
  • 参数寻优 官方大大给了我们明确的提示,可以利用python和gunplot来进行参数寻优~ 翻译如下: 我们现在为不了解SVM的用户提供了一个简单的脚本(easy.py)。它使一切变得自动化-从数据缩放到参数选择。 参数选择工具...
  • 【寻优算法】交叉验证(Cross Validation)参数寻优的python实现:多参数寻优一、网格搜索原理二、网格搜索+交叉验证用于多参数寻优的python实现1、训练模型及待寻优参数2、直接循环嵌套实现网格搜索 + cross_...
  • 【寻优算法】量子遗传算法(QGA) 参数寻优的python实现:多参数寻优一、量子编码1、染色体量子编码2、量子编码转换为二进制编码二、量子进化1、全干扰交叉2、量子变异三、QGA多参数寻优的python实现1、训练模型及待...
  • 基于GA的svm参数寻优

    2021-04-22 04:00:17
    end % maxgen:最大的进化代数,默认为200,一般取值范围为[100,500] % sizepop:种群最大数量,默认为20,一般取值范围为[20,100] % cbound = [cmin,cmax],参数c的变化范围,默认为(0,100] % gbound = [gmin,gmax],参数g...
  • 参数寻优问题详细解析

    万次阅读 2015-09-29 15:55:44
    参数寻优 参数寻优背景  参数寻优问题随处可见,举几个例子。   1. 小明假期结束回校,可以坐火车,可以坐汽车,可以坐飞机,还可以走着,小明从哪条路去学校更好呢?   2. 简单的数学,一元二次方程...
  • MATLAB实现LIBSVM中的c和g的参数寻优

    千次阅读 2019-05-06 20:01:04
    引言:LIBSVM是台湾大学林智仁(Lin Chih-Jen)教授等开发设计的一个简单、...该软件对SVM所涉及的参数调节相对比较少,提供了很多的默认参数,利用这些默认参数可以解决很多问题;并提供了交互检验(Cross Validation...
  • 函数使用接口: 利用PSO参数寻优函数(分类问题);利用PSO参数寻优函数(回归问题)
  • 【计算智能】粒子群算法的参数优化
  • 提出1种融合了人工鱼群算法与 Hopfield神经网络的PID参数优化算法.该算法前期利用鱼群算法快速...将该算法用于某发动机PID控制中的参数寻优,结果表明新混合算法的整定效果好于 Hopfield神经网络,且该算法简单易实现.
  • libsvm学习记录(三)svm参数寻优

    千次阅读 2017-12-19 21:49:47
    基于GridSearch的svm参数寻优 http://www.matlabsky.com/thread-12411-1-1.html 交叉验证(Cross Validation)方法思想简介 http://www.matlabsky.com/forum-v ... -fromuid-18677.html 交叉验证(CrossValidation...
  • 果蝇参数寻优最小二乘支持向量机FOA-LSSVM的完整程序,自己写的

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,013
精华内容 4,405
关键字:

参数寻优