精华内容
下载资源
问答
  • 非线性最优化导论

    2017-11-04 22:10:57
    最优化非线性最优化导论非线性最优化导论非线性最优化导论非线性最优化导论非线性最优化导论非线性最优化导论非线性最优化导论非线性最优化导论
  • 非线性最优化计算方法 非线性最优化计算方法 非线性最优化计算方法
  • Numerical Optimization非线性最优化
  • 非线性 最优化方法

    2013-10-24 16:24:04
    非线性 最优化方法,涵盖了高斯-牛顿法,L-M算法,trust region等非线性参数优化算法
  • 毕 业 论 文 题 目 非线性最优化计算方法与算法 学 院 数学科学学院 专 业 信息与计算科学 班 级 计算 1201 学 生 陶红 学 号 20120921104 指导教师 邢顺来 二一六年五月二十五日 摘 要 非线性规划 问题是一般形式的...
  • 非线性最优化理论和方法 90版 theory and methods for nonlinear optimization (Zhao Ruian, Wu Fang)
  • 最优化计算方法,本书主要描述最优化算法,以及非线性优化算法
  • 论文研究-非线性最优化计算方法的某些近代进展.pdf, 1981年7月,我参加了在英国剑桥召开的“非线性最优化高级研究会”(NATO Advanced Research Institute on Nonlinear Optimization)。关于这次会议的情况,已在文献...
  • 经典遗传算法(SGA)解非线性最优化问题的原理及其python代码实现
  • 无约束非线性最优化问题的算法比较研究:包括最常用的几种方法,直接法和解析法
  • 这里写自定义目录标题算法原理插入链接与图片如何插入一段漂亮的代码片KaTeX数学公式 算法原理 二分法 插入链接与图片 链接: link. 图片: 带尺寸的图片: ...此函数为测试课本《非线性最优化》二分法,

    算法原理

    二分法

    网上有很多对二分法的介绍,这里不再多做赘述。

    本文为《非线性最优化》中二分法的Python实现。但是目前此代码仅适用于单谷凹函数,可求函数所对应导数的根、根所在区间、x为何值时函数取最值。
    稍加修改可求函数最值。

    代码展示

    from sympy import *
    
    pre_function = input('\n***注意!此函数为测试课本《非线性最优化》二分法,目前只适用于 单谷凹函数 (如函数x**2)!!***\n请输入函数:')
    
    # 求导
    x = Symbol("x")
    aft_function = diff(pre_function, x)
    
    print(f'函数{pre_function}的一阶导数为:{aft_function}')
    
    # 定义全局变量a, b
    a = 0
    b = 0
    
    
    def qiudaoshuzhi(fun, num):
        """求导数值"""
        result = float(fun.subs({x: num}))
        print(f'当前一阶导数值为:{result}')
        return result
    
    
    def suan1(t0, h, fun):
        """寻找区间1"""
        t1 = t0 + h
        result1 = qiudaoshuzhi(fun, t1)
        if result1 == 0:
            t = t1
            print(f'x = {t}时是此函数最值')
            exit()
        elif result1 > 0:
            global a
            global b
            a = t0
            b = t1
            return print(f'此函数的根所在区间为[{a},{b}]')
        elif result1 < 0:
            t0 = t1
            suan1(t0, h, fun)
    
    
    def suan2(t0, h, fun):
        """寻找区间2"""
        t1 = t0 - h
        result2 = qiudaoshuzhi(fun, t1)
        if result2 == 0:
            t = t1
            print(f'x = {t}时是此函数最值')
            exit()
        elif result2 < 0:
            global a    # 修改全局变量
            global b
            a = t1
            b = t0
            return print(f'此函数的根所在区间为[{a}, {b}]')
        elif result2 > 0:
            t0 = t1
            suan2(t0, h, fun)
    
    
    def suan3(num1, num2):
        """二分"""
        return float((num1 + num2)/2)
    
    
    def suan4(num1, num2, fun):
        """求局部极值x坐标"""
        e = 0.001   # 误差
        c = suan3(num1, num2)
        result3 = qiudaoshuzhi(fun, c)
        if result3 == 0:
            t = round(c)
            return print(f'x = {t}时是此函数最值')
        elif result3 < 0:
            a = c
            if abs(a-num2) < e:
                t = round(suan3(a, num2))
                return print(f'x = {t}时是此函数最值')
            else:
                suan4(a, num2, fun)
        elif result3 > 0:
            b = c
            if abs(num1-b) < e:
                t = round(suan3(num1, b))
                return print(f'x = {t}时是此函数最值')
            else:
                suan4(num1, b, fun)
    
    
    def quedingqujian(fun):
        print('---开始寻找区间----')
        t0 = 12
        h = 5
        result = qiudaoshuzhi(fun, t0)
        if result == 0:
            t = t0
            print(f'x = {t}时是此函数最值')
            exit()
        elif result < 0:
            suan1(t0, h, fun)
        elif result > 0:
            suan2(t0, h, fun)
    
    
    def dichotomy(fun):
         suan4(a, b, fun)
    
    
    quedingqujian(aft_function)
    
    print(f'{a},{b}')   # 测试全局变量
    dichotomy(aft_function)
    
    

    运行结果展示

    在这里插入图片描述

    展开全文
  • 最近在做标定手眼关系(eye in hand )中用到非线性最优化来求解方程AX=XB, 但对于非线性最优化了解不多,理解困难。 参考文中中定义函数f,对函数f进行非线性最优化 函数f定义可见附图 始终q为四元数(用来表示...
  • 非线性最优化梯度下降法牛顿法高斯牛顿法LM算法 梯度下降法 xk+1=xk−αGkx_{k+1}=x_k-{\alpha}G_kxk+1​=xk​−αGk​ 牛顿法 xk+1=xk−Hk−1Gkx_{k+1}=x_k-H_k^{-1}G_kxk+1​=xk​−Hk−1​Gk​ HkH_kHk​为海森...

    问题

    迭代求解函数极值
    每次迭代,找一个增量Δx{\Delta}x,是的f(xk+Δx)2||f(x_k+{\Delta}x)||^2达到极小值,即比上一次的迭代的值要小
    Δx{\Delta}x足够小的时候停止,否则令xk+1=xk+Δxx_{k+1}=x_k+{\Delta}x
    下面的推导过程与泰勒展开有关

    梯度下降法

    xk+1=xkαGkx_{k+1}=x_k-{\alpha}G_k
    α{\alpha}为步长,(据说是可以求得的)
    Δx=αGk{\Delta}x=-{\alpha}G_k

    牛顿法

    xk+1=xkHk1Gkx_{k+1}=x_k-H_k^{-1}G_k
    HkH_k为海森矩阵
    Δx=Hk1Gk{\Delta}x=-H_k^{-1}G_k
    牛顿法计算海森矩阵复杂,容易陷入局部最优
    看这个https://blog.csdn.net/boksic/article/details/79130509

    高斯牛顿法

    xk+1=xkHk1Gkx_{k+1}=x_k-H_k^{-1}G_k
    Hk=JTJH_k={\approx}J^TJ
    JJ为雅克比矩阵
    xk+1=xk(JTJ)1Gkx_{k+1}=x_k-(J^TJ)^{-1}G_k
    Δx=(JTJ)1Gk{\Delta}x=(J^TJ)^{-1}G_k
    高斯牛顿法利用雅克比矩阵近似海森矩阵
    (高斯牛顿方程也叫增量方程也叫正规方程)
    看这个https://blog.csdn.net/boksic/article/details/79055298

    LM算法

    信赖域的概念https://www.codelast.com
    xk+1=xkHk1Gkx_{k+1}=x_k-H_k^{-1}G_k
    Hk=JTJ+μIH_k={\approx}J^TJ+{\mu}I
    II为单位矩阵
    xk+1=xk(JTJ+μI)1Gkx_{k+1}=x_k-(J^TJ+{\mu}I)^{-1}G_k
    引入步长单位矩阵解决高斯牛顿的不可逆问题
    μ{\mu}小时相当于高斯牛顿,μ{\mu}大时相当于梯度下降
    看这个https://blog.csdn.net/boksic/article/details/79177055

    展开全文
  • 非线性最优化最佳教材

    千次阅读 2018-05-20 01:20:53
    袁亚湘2008非线性优化计算

    袁亚湘2008非线性优化计算

    展开全文
  • 非线性最优化一个可行序列等式约束二次规划算法,通过可行序列等式约束二次规划算法
  • 1.多峰非线性最优化问题 非线性优化问题 2. 经典遗传算法 2.1 遗传算法概述

    1.多峰非线性最优化问题

    非线性最优化问题一直是学者研究的热点问题之一。下面考虑两个变量的非线性最优化问题,这个问题具有多个局部解,是多峰问题。下图是采用经典遗传算法找到的最优解在目标函数的三维图形中的分布情况,由于多峰最优化问题具有多个局部解的特性,使用传统的方法非常难获得最优解。
    s.t.maxf(x1,x2)=21.5+x1sin(4pix1)+x2sin(20pix2)3.0x112.14.1x25.8 s.t. \begin{matrix} max f(x_1,x_2)=21.5+x_1sin(4*pi*x_1)+x_2sin(20*pi*x_2) \\-3.0\leqslant x_1\leqslant 12.1 \\4.1\leqslant x_2\leqslant 5.8 \end{matrix}
    在这里插入图片描述
    目标函数的python代码如下:

    #目标函数
    def aimfun(x):
        y=21.5+x[0]*math.sin(4*math.pi*x[0])+x[1]*math.sin(20*math.pi*x[1])
        return y
    

    下面我们根据此问题介绍经典的遗传算法。

    2. 经典遗传算法

    2.1 遗传算法概述

    遗传算法是一种基于生物遗传机理,即生物进化(自然淘汰,交叉,变异等)现象的随机搜索算法,它通过计算机模拟生物进化过程来进行搜索和进化,最后寻求最优解,是一种超启发式算法,其中被称为个体的染色体(即研究对象的候选解)的集合能适应外部环境(研究对象的评价函数),并基于下面的规则在每代中生成新个体集合:
    (1)越是适应性强的个体,其生存几率越高(自然选择);
    (2)以原有个体为基础通过遗传操作生成新个体(遗传现象)。
    其中(1)可看做是概率搜索法,(2)是经验搜索法。

    2.2 染色体设计(编码和解码)

    这里采用二进制字符编码法(binary-string encoding)来表示非线性优化的编码,以下是算法的伪代码,random[0,1]表示在[0,1]区间内随机产生0或者1。

    procedure:binary-string encoding
    input:no.of required bits m
    output:chromosome vk
    begin
    	for i=1 to m
    		vk(i)<--random[0,1];
    	output:chromosome vk;
    end
    

    编码(种群初始化)的python代码如下:

    #初始化种群
    def init(pop_num,chromo_len): 
        population=[]
        for i in range(pop_num):
            pop=''
            for k in chromo_len:
                for j in range(k):
                    pop=pop+str(np.random.randint(0,2))
            population.append(pop)    
        return population
    

    这里以二进制字符串来表示决策变量x1,x2x_1,x_2。例如xjx_j的定义域为[aj,bj][a_j,b_j],而要求精度的小数点后5位,这就要求xjx_j的定义域至少要划分为(bjaj)105(b_j-a_j)*10^5个空间。设变量xjx_j所需要的二进制字符串长为mjm_j,则应满足:
    2mj1&lt;(bjaj)105&lt;2mj1 2^{m_j-1}&lt;(b_j-a_j)*10^5&lt;2^{m_j}-1
    例如精度都设置为小数点后5位,则两个变量所需的串长分别为18和15,总串长为33,则设置初始染色体的长度为33位。
    获得染色体长度的python代码如下:

    #获得染色体长度
    def getchromolen(delta, upper,lower):
        maxlen=25
        chromo_len=[]
        for j in range(len(upper)):
            a=(upper[j]-lower[j])/delta[j]
            for i in range(maxlen):
                if (2**i < a) and (a < (2**(i+1))):
                    chromo_len.append(i+1)
                    break
        return chromo_len
    

    要想将变量mjm_j由二进制转为十进制,可根据定义域范围内2mj12^{m_j}-1个划分点的位置,按下式计算:
    xj=aj+decimal(substringj)(bjaj)/(2mj1) x_j=a_j+decimal(substring_j)*(b_j-a_j)/(2^{m_j}-1)
    这里decimal(substringj)decimal(substring_j)表示变量xjx_j的子串substringjsubstring_j的十进制值。
    解码的伪代码如下:

    procedure:binary-string decoding
    input:no.of bariables n,
    		no.of bits mj(j=1,2,...,n)
    		range[aj,bj] of variable xj(j=1,2,...,n)
    		chromosome vk
    output:real number xj(j=1,2,...,n)
    begin
    	s<--0,t<--0;
    	for j=1 to n
    		s<--t+1;
    		t<--t+mj;
    		xj=aj+((bj-aj)/(2^mj-1))*sum_{i=s->t}(2^(mj-i)*vk(i));
    	end
    	output:real number xj(j=1,2,...,n);
    end
    

    解码的python代码如下:

    #解码
    def decode(x,chromo_len,upper,lower):
        y=[]
        index=0
        for i in range(len(chromo_len)):
            a = lower[i]+(int(x[index:(index+chromo_len[i])],2))*(upper[i]-lower[i])/(2**chromo_len[i]-1)
            y.append(a)
            index = index+chromo_len[i]
        return y
    

    2.3 遗传操作

    2.3.1轮盘赌模型

    轮盘赌模型的基本原理是根据每个染色体的适值比例来确定该个体的选择概率或生存概率。如下面的伪代码那样,个体适应度按比例转换为轮盘的面积并旋转轮盘,最后选择球落点位置所对应的个体。(此处输入可以为父代加子代,也可直接输入子代,具体区别见后面的2.4算法流程)
    这里有一些参数说明:
    l:染色体索引号
    F:所有染色体的适值和
    vk:第k个染色体
    pk:第k个染色体的选择概率
    qk:前k个染色体的累计概率

    procedure:roulette wheel selection
    input:chromosome Pk,k=1,2,...,popsize+offsize
    output:chromosome Pk in next generation
    begin
    	计算适应度函数值eval(Pk);
    	计算累计适应度F=sum_{k=1->popsize+offsize}eval(Pk);
    	计算选择概率pk=eval(Pk)/F(k=1,2,...,popsize+offsize);
    	计算累计概率qk=sum_{i=1->k}pi(k=1,2,...,popsize+offsize);
    	for k=1 to popsize
    		r<--random[0,1]
    		if r<=q1 then
    			Pl'<--Pk;
    		else if qk-1<r<=qk then
    			Pk'<--Pk;
    	end
    	output:chromosome Pk,k=1,2,...,popsize;
    end
    

    适应度值计算和轮盘赌的python代码如下;

    #适应度函数
    def fitnessfun(population,aimfun,chromo_len,upper,lower,fun):
        value=[]
        for i in range(len(population)):
            valuea=aimfun(decode(population[i],chromo_len,upper,lower))
            value.append(valuea)
        if fun==0:
            minvalue=min(value)
            value=[(i-minvalue+0.0000001) for i in value]
        elif fun==1:
            maxvalue=max(value)
            value=[(maxvalue-i+0.0000001) for i in value]
        return value
    
    
    #轮盘赌选择
    def roulettewheel(population,value,pop_num):
        fitness_sum=[]
        value_sum=sum(value)
        fitness=[i/value_sum for i in value]
        for i in range(len(population)):##
            if i==0:
                fitness_sum.append(fitness[i])
            else:
                fitness_sum.append(fitness_sum[i-1]+fitness[i])
        population_new=[]
        for j in range(pop_num):###
            r=np.random.uniform(0,1)
            for i in range(len(fitness_sum)):###
                if i==0:
                    if r>=0 and r<=fitness_sum[i]:
                        population_new.append(population[i])
                else:
                    if r>=fitness_sum[i-1] and r<=fitness_sum[i]:
                        population_new.append(population[i])
        return population_new
    

    2.3.2单点交叉

    随机选择父母双方染色体上的一个点,并指定为“交叉点”。在该点右侧的位在两个亲本染色体之间进行交换。这样导致每个后代都携带了来自父母的一些遗传信息。此算法父代的双亲个体有可能被多次选择,也可能一次都未选到,即不满足完备性(父代中的个体不是所有都被选择)。此算法也可以让父代的双亲个体都被选择,即满足完备性。以下的算法伪代码为前者,实现的python代码为后者。
    参数说明:
    pc:交叉概率
    p:交叉点
    L:为染色体长度

    input: pc, parent Pk, k=1, 2, ..., popsize 
    output: offspring Ck
    begin
    	for k <-- 1 to popsize/2 do
    		if pc≥random[0,1] then
    			i<--0;
    			j<--0;
    			repeat
    				i<--random[1,popsize];
    				j<--random[1,popsize];
    			until(i≠j)                
    			p<--random[1,L-1]; 
    			Ck<--Pi[1:p-1]//Pj[p:L];
    			C(k+popsize/2)<--Pj[1:p-1]//Pi[p:L];
    		end
    	end
    	output:offspring Ck;
    end
    

    单点交叉的python代码如下:

    #单点交叉
    def crossover(population_new,pc,ncross):
        a=int(len(population_new)/2)
        parents_one=population_new[:a]
        parents_two=population_new[a:]
        np.random.shuffle(parents_one)
        np.random.shuffle(parents_two)
        offspring=[]
        for i in range(a):
            r=np.random.uniform(0,1)
            if r<=pc:
                point=np.random.randint(0,int(len(parents_one[i])/2))
                off_one=parents_one[i][:point]+parents_two[i][point:]
                off_two=parents_two[i][:point]+parents_one[i][point:]
                ncross = ncross+1
            else:
                off_one=parents_one[i]
                off_two=parents_two[i]
            offspring.append(off_one)
            offspring.append(off_two)
        return offspring
    

    2.3.3反转变异(单点变异)

    实现单点变异算子的常用方法1为每条染色体随机生成一个数,此数指示该染色体是否需要变异。如果该染色体需要变异,为其生成一个随机变量,此随机变量指示修改该染色体的哪一位。其算法的伪代码如下:

    procedure:mutation1
    input: pm, parent Pk, k=1, 2, ..., popsize              // pm:变异概率
    output: offspring Ck
    begin
    	for k <-- 1 to popsize do	                       
    		if pm <-- random [0, 1] then
    			point<--random[0,L-1]	          // L: 染色体长度
    			if point = 0
    				Pk <-- 1-Pk [ 0 ] // Pk[ 1: L ];	
    			else
    				Pk <-- Pk [1: point-1] // 1-Pk [ point ] // Pk[ point+1: L ];	
    			end
    		end
    		Ck =Pk;
    	end
       	output:offspring Ck;
    end
    

    反转变异1的python代码如下:

    #单点变异1
    def mutation1(offspring,pm,nmut):
        for i in range(len(offspring)):
            r=np.random.uniform(0,1)
            if r<=pm:
                point=np.random.randint(0,len(offspring[i]))
                if point==0:
                    if offspring[i][point]=='1':
                        offspring[i]='0'+offspring[i][1:]
                    else:
                        offspring[i]='1'+offspring[i][1:]
                else:
                    if offspring[i][point]=='1':
                        offspring[i]=offspring[i][:(point-1)]+'0'+offspring[i][point:]
                    else:
                        offspring[i]=offspring[i][:(point-1)]+'1'+offspring[i][point:]
                nmut = nmut+1
        return offspring
    

    实现单点变异算子的常用方法2为染色体数组中的每个位生成随机变量。此随机变量指示是否将修改特定位。其算法的伪代码如下:

    procedure:mutation2
    input: pm, parent Pk, k=1, 2, ..., popsize              // pm:变异概率
    output: offspring Ck
    begin
    	for k <-- 1 to popsize do	                       
    		for j <-- 1 to L do(基因串长度)              // L: 染色体长度
    			if pm <-- random [0, 1] then	          
    				Pk <-- Pk [1: j-1] // 1-Pk [ j ] // Pk[ j+1: L ];	
    			end
    		end
    		Ck =Pk;
    	end
        output:offspring Ck;
    end
    

    反转变异2的python代码如下:

    #单点变异2
    def mutation2(offspring,pm,nmut):
        for i in range(len(offspring)):
            for j in range(len(offspring[i])):
                r=np.random.uniform(0,1)
                if r<=pm:
                    if j==0:
                        if offspring[i][j]=='1':
                            offspring[i]='0'+offspring[i][1:]
                        else:
                            offspring[i]='1'+offspring[i][1:]
                    else:
                        if offspring[i][j]=='1':
                            offspring[i]=offspring[i][:(j-1)]+'0'+offspring[i][j:]
                        else:
                            offspring[i]=offspring[i][:(j-1)]+'1'+offspring[i][j:]
                    nmut = nmut+1
        return offspring
    

    2.4 算法流程

    应用经典遗传算法对多峰非线性问题求解的总体流程伪代码如下:(此处由于对轮盘赌操作的输入种群不同,因此列出两种代码,请读者加以区别。)
    GA的算法流程为伪代码如下:

    procedure:simple GA
    input: GA parameters
    output: the best solution
    begin
    	t<-- 0	                       // t:遗传代数
    	initialize P(t) by encoding routine;         //P(t):染色体种群 
    	fitness eval(P) by decoding routine;
    	while (not termination condition) do
    		crossover P(t) to yield C(t);     //C(t):offspring
    		mutation   P(t) to yield C(t);
    		fitness eval(C) by decoding routine;
    		select P(t+1) from P(t) and C(t);
    		t<--t+1;
    	end
        output:the best solution;
    end
    

    GA的python代码1如下(轮盘赌的输入为父代加子代):

    import numpy as np
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    import math
    #参数设置-----------------------------------------------------------------------
    gen=1000#迭代次数
    upper=[12.1,5.8]#自变量上界
    lower=[-3.0,4.1]#自变量下界
    pc=0.25#交叉概率
    pm=0.01#变异概率
    pop_num=10#种群大小
    delta=[0.0001,0.0001]#编码精度
    fun=0#0最大化,1最小化
    #初始化-------------------------------------------------------------------------
    #获得编码长度
    chromo_len = getchromolen(delta,upper,lower)
    #初始化种群
    population=init(pop_num,chromo_len)
    #初始化交叉个数
    ncross=0
    #初始化变异个数
    nmut=0
    #储存每代种群的最优值及其对应的个体
    t=[]
    best_ind=[]
    last=[]#储存最后一代个体的函数值
    realvalue=[]#储存最后一代解码后的值
    #循环---------------------------------------------------------------------------
    for i in range(gen):
        print("迭代次数:")
        print(i)
        #交叉
        offspring_c=crossover(population,pc,ncross)
        #变异
        #offspring_m=mutation1(offspring,pm,nmut)
        offspring_m=mutation2(offspring_c,pm,nmut)
        mixpopulation=population+offspring_m
        #适应度函数计算
        value = fitnessfun(mixpopulation,aimfun,chromo_len,upper,lower,fun)
        #轮盘赌选择
        population=roulettewheel(mixpopulation,value,pop_num)
        #储存当代的最优解
        result=[]
        if i==gen-1:
            for j in range(len(population)):
                bb = decode(population[j],chromo_len,upper,lower)
                result.append(aimfun(bb))
                realvalue.append(bb)
            last=result
        else:
            for j in range(len(population)):
                result.append(aimfun(decode(population[j],chromo_len,upper,lower)))
        maxre=max(result)
        h=result.index(max(result))
        #将每代的最优解加入结果种群
        t.append(maxre)
        best_ind.append(population[h])
    

    GA的python代码2如下(轮盘赌的输入为子代):

    import numpy as np
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    import math
    #参数设置-----------------------------------------------------------------------
    gen=1000#迭代次数
    upper=[12.1,5.8]#自变量上界
    lower=[-3.0,4.1]#自变量下界
    pc=0.25#交叉概率
    pm=0.01#变异概率
    pop_num=10#种群大小
    delta=[0.0001,0.0001]#编码精度
    fun=0#0最大化,1最小化
    #初始化-------------------------------------------------------------------------
    #获得编码长度
    chromo_len = getchromolen(delta,upper,lower)
    #初始化种群
    population=init(pop_num,chromo_len)
    #初始化交叉个数
    ncross=0
    #初始化变异个数
    nmut=0
    #储存每代种群的最优值及其对应的个体
    t=[]
    best_ind=[]
    last=[]#储存最后一代个体的函数值
    realvalue=[]#储存最后一代解码后的值
    #循环---------------------------------------------------------------------------
    for i in range(gen):
        print("迭代次数:")
        print(i)
        #适应度函数计算
        value = fitnessfun(population,aimfun,chromo_len,upper,lower,fun)
        #轮盘赌选择
        population=roulettewheel(population,value,pop_num)
        #交叉
        offspring_c=crossover(population,pc,ncross)
        #变异
        #offspring_m=mutation1(offspring,pm,nmut)
        offspring_m=mutation2(offspring_c,pm,nmut)
        population=offspring_m
        #储存当代的最优解
        result=[]
        if i==gen-1:
            for j in range(len(population)):
                bb = decode(population[j],chromo_len,upper,lower)
                result.append(aimfun(bb))
                realvalue.append(bb)
            last=result
        else:
            for j in range(len(population)):
                result.append(aimfun(decode(population[j],chromo_len,upper,lower)))
        maxre=max(result)
        h=result.index(max(result))
        #将每代的最优解加入结果种群
        t.append(maxre)
        best_ind.append(population[h])
    

    3. 实验结果

    本实验参数设置如下:
    1.gen=1000#迭代次数
    2.upper=[12.1,5.8]#自变量上界
    3.lower=[-3.0,4.1]#自变量下界
    4.pc=0.25#交叉概率
    5.pm=0.01#变异概率
    6.pop_num=10#种群大小
    7.delta=[0.0001,0.0001]#编码精度
    根据上述参数设置和原理分析,我们编程得到最后一代解的分布如下图所示。
    在这里插入图片描述
    其每代最优的函数值随进化代数的变化如下图所示。
    在这里插入图片描述
    很明显算法最后可以收敛到一个较好的解,如果想要得到最优的解,还需要做大量的实验从而选择较合适的参数,建议读者可以多多进行尝试。
    画图的python代码如下:(接到主程序后就行)

    #输出结果-----------------------------------------------------------------------
    best_value=max(t)
    hh=t.index(max(t))
    print(best_value)
    print(decode(best_ind[hh],chromo_len,upper,lower))
    #画出收敛曲线
    plt.plot(t)
    plt.title('The curve of the optimal function value of each generation with the number of iterations',color='#123456')
    plt.xlabel('the number of iterations')
    plt.ylabel('the optimal function value of each generation')
    #画出函数与解的分布 
    fig = plt.figure()
    ax = Axes3D(fig)
    x1 = np.arange(-3,13,0.4)
    x2 = np.arange(4,6,0.0460)
    X, Y = np.meshgrid(x1,x2)#网格的创建,这个是关键
    Z=21.5+X*np.sin(4*np.pi*X)+Y*np.sin(20*np.pi*Y)
    plt.xlabel('x1')
    plt.ylabel('x2')
    ax.set_zlabel('f(x1,x2)') 
    ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='rainbow')
    ax.scatter(np.array(realvalue)[:,0], np.array(realvalue)[:,1], np.array(last),marker='o', c='k')
    plt.show()
    

    完整的python代码如下:https://download.csdn.net/download/qq_40434430/10742475
    由于作者水平有限,以上内容难免有错误之处,如果读者有所发现,请在下面留言告知我,鄙人将不胜感激!
    [1]:(日)玄光男, 林林等著. 网络模型与多目标遗传算法[M]. 于歆杰, 梁承姬译. 北京: 清华大学出版社, 2017

    展开全文
  • 首先从简单的开始,没有约束的非线性,然后就是非线性中比较特殊的一个例子,多项式的非线性,如下图 思路:用matlab求解f的hessian矩阵,然后求解hessian矩阵的特征向量,如果都大于0,就是正定,如果是大于等于...
  • 非线性最优化算法总结

    千次阅读 2019-06-14 11:37:54
    参考: ... ... 疑问: 1、LM算法与SLAM第6讲中定义不太一样,(信赖区域的确定中ρ的定义方法) 帖子中用二阶近似定义ρ,而slam第六讲中用一阶近似来表达,两者思想较为一致,判...
  • 本文详细推导了高斯牛顿算法,从代数以及矩阵的角度,以及二范数下的高斯牛顿,最小二乘和的高斯牛顿等等。
  • 以三维衣片和二维裁片的边角特征作为放码的约束条件,构造非线性目标函数,问题转化为求解有约束的极小化问题,经过数学变换,问题最终转化为求解非线性方程组.多边形具有直角坐标和局部标架两种表示方法,充分结合...
  • 非线性最优化基础 简单易懂理解

    千次阅读 2018-01-27 12:54:15
    非线性优化中的基本概念(1). 方向导数:函数在自变量的某个方向上的导数。以一个二元函数为例,自变量有x和y,该函数在某一点方向有(x,y)这个向量组成的无穷多个。(2).梯度:梯度是一个矢量,在这个方向上的方向...
  • 关注. 最优化的研究包含理论、方法和应用.最优化理论主要研究问题解的最优性条件、灵敏度分析、... 这里简介一下线性和非线性最优化理论、方法及应用研究的发展状况. 1. 线性最优化 线性最优化, 又称线性规划, 是运筹
  • 本文介绍了一些非线性函数最优化方法,是计算机应用数学的重要部分。
  • 利用凝聚函数的一个等价形式,提出一种改进的凝聚约束同伦方法,使得初始可行域包含原问题的可行域,并从外部逐渐逼近原问题的可行域,从而克服了凝聚约束同伦方法可能无法求得一些可行域边界附近K-K-T点的问题....
  • 高斯牛顿法和Levengerg-Marquardt迭代都用来解决非线性最小二乘问题(nonlinear least square)。 From Wiki The Gauss–Newton algorithm is a method used to solve non-linear least square...
  • 在我看来,牛顿法至少有两个应用方向,1、求方程的根,2、最优化。牛顿法涉及到方程求导,下面的讨论均是在连续可微的前提下讨论。   1、求解方程。 并不是所有的方程都有求根公式,或者求根公式很复杂,导致...

空空如也

空空如也

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

非线性最优化