精华内容
下载资源
问答
  •  已知每个顾客的位置与需求量, 每台车的容量一定, 将货物送到顾客手中需要满足一定的时间约束, 要求合理安排行车路线使目标函数得到优化。 对该问题的研究引起了广大学者的关注。 它是有容量约束车辆路径...

    蚁群算法求解有时间窗约束的车辆路径问题matlab程序

    1 简介

    带时间窗的车辆路径问题(VRPTW)一般描述为从某一物流配送中心出发用多台车辆向多个顾客送货车辆完成配送任务后返回配送中心 已知每个顾客的位置与需求量 每台车的容量一定 将货物送到顾客手中需要满足一定的时间约束 要求合理安排行车路线使目标函数得到优化 对该问题的研究引起了广大学者的关注 它是有容量约束车辆路径问题的扩展 NP难题 求解算法可分为精确算法与启发式算法当顾客点数目较多时 使用精确算法很难在可接受的时间内求得全局最优解 因此 用启发式算法在可接受的时间内求得问题的满意解成为研究的重要方向

    蚁群算法是由Dorigo等首先提出来的 它的基本思想是利用一群人工蚂蚁的协作来寻找优化问题的较优解 每只蚂蚁根据问题所给的准则 从被选中的初始状态出发建立一个可行解或部分解 各个蚂蚁间通过信息素交换信息 从而达到相互协作的目的蚁群算法的思想已被应用到各个研究领域 并取得了大量的研究成果 而在VRPTW方面的研究则较少

    2 有时间窗的车辆路径问题

    为简化问题的描述,需要在构建模型前做一些基本的假设和约束:

        (1) 假设物流运输车辆状况相同;

        (2) 单车运载力要大于单个客户需求量,且每条路线上的客户需求总量不大于单车最大运载力;

        (3) 配送中心能够满足所有客户需求,无缺货;

        (4) 车辆完成配送后直接返回配送中心;

    (5) 每条路径长度不超过单车最大行程;

    (6) 车辆要在时间窗内到达相应客户点,否则会产生惩罚成本;

     

    向客户配送货物有时间限制,在此采用软时间窗的限制方法进行处理, 即对客户需求的货物在一定的时间范围内到达,若未能按时到达,则将对物流配送企业给予一定的罚金。则因不在时间窗内将产品送到客户点而产生的处罚成本用C5表示,公式如下所示:

        

    其中:分别表示车辆早于和晚于时间窗将货物卸下而带来的损失成本。为车辆到达客户 j 的时刻,为车辆在客户 j 处等待的时间。

    3 问题求解

    蚁群算法(Ant Colony Algorithm)可以很好地解决 VRP,因为该算法在满足各需求点的时间窗约束的前提下采用动态信息策略, 以保证在每次搜索中每只蚂蚁都对搜索做出贡献, 

    最快地找到最优解或满意解。简单来说,此算法是一种源于自然界中生物世界新的仿生类随机型、智能多主体搜索算法,它吸收了昆虫王国中蚂蚁的行为特性,通过其内在的搜索机制,在一系列困难的路径优化问题求解中取得了成效。所以本文打算通过 MATLAB 强大的计算功能编写蚁群算法程序来深入研究冷链物流路径优化问题。

    基本蚁群算法的思路如下:

    Begin

    初始化:

    Nc    0;Nc为迭代次数)

    对各边弧(i,j;

            常数c;(较小的正数)    0;

         Ca    L;ca为车辆的剩余载重量)

         Cb    N;Cb为车辆的剩余行驶距离)

     读入其他输入参数;

     Loop:

         将初始点放入当前的解集中;

         While(不满足停机准则)do

         begin

         对每只蚂蚁k;

             按照剩余载重量,剩余行驶路径长和转移概率选择顶点j;

             将蚂蚁k从顶点i转移到顶点j;

             将顶点i放在当前的解集中;

         end

         当所有的城市都放在解集中,就记录蚂蚁的个数M    k;

         利用局部搜索机制来优化路径;

         然后计算每只蚂蚁的目标函数值;

         并计算当前的最好解;

         For k   1toM do

         begin

             对各边(i,j,计算:;(增加的信息素)

         end

             对各边(i,j,计算:;(轨迹更新)

             对各边(i,j,;

             ;

             Nc<预定的迭代次数,则go to Loop;

         End 

    部分程序
    %     Author:    怡宝2号			博士猿工作室
    %     Use:       用蚁群算法求解有容量限制、时间窗限制的车辆路径问题;
    %                坐标视自己的具体情况而定。
    %     Illustrate:输入变量(must):     
    %                              coordinate:要求的相应点的坐标,第一行是点的横坐标,第二行是点的纵坐标
    %                                demand(1*n),n表示工厂的个数;t表示各个工厂要求运送的货物的重量
    %                                LimitW:每辆车限制的载重量
    %       Can—changed parameter: m:蚁群的规模
    %                                MAXGEN:蚁群的最大迭代代数
    %                               
    %                  输出:        bestpop:最短路程对应的路径
    %                                trace :最短路程
    %				  remark:    如有疑问请咨询qq:778961303
    clc
    clear all
    close all
    format compact
    
    %蚁群参数初始化
    Alpha = 1;        %求解选择下一个城市的概率
    Beta = 5;         %求解选择下一个城市的概率
    Rho = 0.75;       %信息素的全局更新
    Q = 200;          %信息素增加强度系数
    Elite = 1;        %精英蚂蚁数量
    
    m = 40;           %每一代有40只蚂蚁
    MAXGEN = 100;     %最大迭代代数
    Prab = 0.05;      %伪随机选择概率
    
    %读取初始数据,初始化成本函数的参数
    [F,C,P,ZETA1,ZETA2,THETA,R,S,ELTAT,COSTP,V,BETA,OMEGA1,OMEGA2,coordinate,demand,ET,LT,ST,speed, LimitW] = initial();          
    
    %求各个客户点之间的距离
    [Distance n] = CalculateD(coordinate);      %n为客户数量,包括配送中心
    
    Eta=1./Distance;        %Eta为启发因子,离散模型设为距离的倒数
    Tau=ones(n,n);          %Tau为信息素矩阵,行:前一个城市的标号;列:后一个城市的标号。
    Tabu=zeros(m,n+20);     %存储并记录路径的生成
    
    bestpop = zeros(MAXGEN,n+20);       %每代最优的蚂蚁
    trace = zeros(MAXGEN,1);            %每代最小的成本
    
    %迭代寻优开始开始
    load = 0;               %初始化载重
    NC=1;                   %迭代计数器 
    while NC<=MAXGEN
        
        Tabu(:,1)=1;        %每只蚂蚁都是从仓库(及节点1)开始出发
        
        %精英保留策略
        start = 1;
        if 2<=NC
            start = Elite + 1;
        end
        
        for i=start:m
            visited=Tabu(i,:);
            visited=visited(visited>0);
            to_visit=setdiff(1:n,visited);         %在集合论中,to_visit = (1:n) - visited
            
            actualST = zeros(n,1);                 %实际服务时间,初始化,一只蚂蚁初始化一次
            actualST(1) = ET(1);                   %对初始点的服务时间,初始化
            j=1;
            while j<=n
                if ~isempty(to_visit)              %判断所有客户点是否送完
                    %计算接下来要参观的其他城市的概率
                    for k=1:length(to_visit)
                        [Tij actualST] = CalculateT( visited(end) , to_visit(k) ,actualST,Distance,ST,speed);            %计算从客户i到达客户j的时间
                        VC = CalculateVC( visited(end) , to_visit , actualST , Distance , ST, speed, LT);                 %计算从客户i到下一个客户的潜在客户
                        x(k)=(Tau(visited(end),to_visit(k))^Alpha)*(Eta(visited(end),to_visit(k))^Beta)*...
                             1/( abs(Tij-ET(to_visit(k))) + abs(Tij-LT(to_visit(k))) )*VC;
                    end
                    
                    %伪随机选择,选择下一个城市
                    temp_pra=rand;
                    if temp_pra<Prab                %如果满足伪随机选择概率,直接选择概率最大的,这样收敛更快
                        Select=find(max(x));
                    else
                        x=x/(sum(x));               %用轮盘赌法选择下一个城市
                        xcum=cumsum(x); 
                        Select=find(xcum>=rand);
                    end                
                    
                    %计算车的载重
                    if isempty(Select)              %如果选不了下一个城市了,就回到1点
                        Select=1;
                        load=load+demand(Select);   %select=1;t(select)=0
                    else
                        load=load+demand(to_visit(Select(1)));       %select表示城市标号,to_visit(select)才表示城市
                    end
                    
                    %判断载重是否超限,并对路径表修改
                    if load>W                  %判断车是否超载,超载就回到原地
                        Select=1;
                        j=j-1;                      %j表示参观了的城市,参观的城市-1
                        load=0;                     %车辆的载重归零
                        Tabu(i,length(visited)+1)=Select(1);      %给车辆的路径信息赋值,及回到原点,要参观的客户赋值为1.
                    else
                        Tabu(i,length(visited)+1)=to_visit(Select(1));
                    end
                    
                end
                
                %对访问过的客户,和待访问的客户初始化
                visited=Tabu(i,:);
                visited=visited(visited>0);                  %已经拜访过的客户
                to_visit=setdiff(1:n,visited);
                x=[];
                if visited(end)~=1
                    Tabu(i,1:(length(visited)+1))=[visited,1];
                end
                j = j+1;
                j;
            end
            %1只蚂蚁配送路线完成
            load = 0;
        end
        %m只蚂蚁路线安排完成
        
        %计算m只蚂蚁的个体适应度
        L=zeros(m,1);               %共有m只蚂蚁
        for i=1:m 
            temp=Tabu(i,:); 
            route=temp(temp>0);     %每只蚂蚁的路径
        end
        
        %精英保留策略
        [ex index] = sort(L,'ascend');
        index = index(1:Elite);
        temp = Tabu(index,:);
        tempL = L(index);
        Tabu(1:Elite,:) = temp;
        L(1:Elite) = tempL;
        
        [mintrace index] = min(L);  %最小的成本
        temp = Tabu(index(1),:);    %最小成本对应的蚂蚁
        trace(NC) = mintrace;       %保存每代的最小成本和最小蚂蚁
        bestpop(NC,:) = temp;
        
        %更新信息素
        Delta_Tau=zeros(n,n);
        for i=1:m
            temp=Tabu(i,:); 
            route=temp(temp>0);
            for j=1:(length(route)-1) 
                Delta_Tau(route(j),route(j+1))=Delta_Tau(route(j),route(j+1))+Q/L(i);
            end
            Delta_Tau(route(n),route(1))=Delta_Tau(route(n),route(1))+Q/L(i);
        end
    %     %信息素更新
    %     Delta_Tau=zeros(n,n); 
    %     for i=1:m 
    %         temp=Tabu(i,:); 
    %         route=temp(temp>0);
    %         for j=1:(length(route)-1) 
    %             Delta_Tau(route(j),route(j+1))=Delta_Tau(route(j),route(j+1))+Q/L(i);
    %         end
    %     end
    %     Tau=(1-Rho).*Tau+Delta_Tau;
        
        %路径清零,载荷清零
        temp=zeros(m-Elite,n+20); 
        Tabu(Elite+1:m,:) = temp;
        load=0;    
        
        disp(['共迭代',num2str(MAXGEN),'次,现在为:',num2str(NC)]);
    %     NC
        NC = NC + 1;
    end
    
    %绘制寻优迭代图
    figure()
    plot(trace)
    plot(trace,'--b',...
        'LineWidth',2);
    grid off
    xlabel('迭代次数数')
    ylabel('成本')
    title('成本变化','fontsize',16)
    
    %显示路径
    [mintrace index] = min(trace);              %最小成本
    route = bestpop(index,:);                   %最小成本的路径
    route = route( route>0 );
    p=num2str(route(1));
    for i=2:length(route)
        p=[p,'->',num2str(route(i))];
    end
    display(['求解的最优路径为:',num2str(p)]);
    display(['1代表物流中心']);
    disp(['最小的成本代价为:',num2str(min(trace))]);
    
    %绘制最小成本的路径
    figure();
    DrawRoute(coordinate,route)
    
    %				  remark:    如有疑问请咨询qq:778961303

    结果





    展开全文
  • 优化算法——遗传算法

    万次阅读 多人点赞 2015-05-10 17:09:28
    与遗传算法的第一次接触 遗传算法的基本概念 基本定义 遗传算法的基本流程 遗传算法过程中的具体操作 ...求解优化问题的实例 问题描述 问题分析 算法设计 个体编码 适应值函数 选择策略 杂交算子 变异算子 参数设置

    与遗传算法的第一次接触

    遗传算法是我进入研究生阶段接触的第一个智能算法,从刚开始接触,到后来具体去研究,再到后来利用遗传算法完成了水利水电的程序设计比赛,整个过程中对遗传算法有了更深刻的理解,在此基础上,便去学习和研究了粒子群算法,人工蜂群算法等等的群体智能算法。想利用这个时间,总结下我对于遗传算法的理解,主要还是些基本的知识点的理解。

    遗传算法的基本概念

    遗传算法(Genetic Algorithm, GA)是由Holland提出来的,是受遗传学中的自然选择和遗传机制启发发展起来的一种优化算法,它的基本思想是模拟生物和人类进化的方法求解复杂的优化问题。

    基本定义

    1. 个体(individual):在遗传学中表示的是基因编码,在优化问题中指的是每一个解。
    2. 适应值(fitness):评价个体好坏的标准,在优化问题中指的是优化函数。
    3. 群体(population): 由个体组成的集合
    4. 遗传操作:遗传操作的主要目的是用于在当前的群体中产生新的群体,主要的操作包括:选择(selection)、交叉(crossover)、变异(mutation)。

    遗传算法的基本流程

    遗传算法的过程中主要包括这样几个要素:1、参数的编码。2、初始群体的设定。3、适应度函数的设计。4、遗传操作设计。5、控制参数的设定。
    基本遗传算法的具体过程如下:
    这里写图片描述

    遗传算法过程中的具体操作

    参数的编码

    遗传算法中的参数编码的方式主要有:1、二进制编码。2、Gray编码。3、实数编码。4、有序编码。

    二进制编码

    二进制编码是最原始的编码方式,遗传算法最初是在二进制编码的方式下进行运算的。二进制编码也是遗传算法中使用最为直接的运算编码方式。二进制编码是指利用 0 1对问题的解向量进行编码。例如,对于如下的优化问题:

    maxf(x1,x2)=21.5+x1sin(4πx1)+x2sin(20πx2)

    3.0x112.1;4.1x25.8

    其三维图像如下图所示:
    这里写图片描述
    在对这样的优化问题进行二进制编码的过程中,是将问题的可能解编码为二进制位串,例如问题的可能解为实数对 (x1,x2) ,首先必须将 x1 x2 分别使用二进制位串表示,然后将他们的二进制位串组合在一起。对于每一个变量的二进制位串的长度取决于变量的定义域所要求的精度。


    二进制位串的长度的计算方法如下:
    假设 ajxjbj ,所要求的精度是小数点后 t 位。这要求将区间划分为至少(bjaj)10t份。假设表示变量 xj 的位串的长度用 lj 表示,则 lj 可取为满足下列不等式的最小数 m

    (bjaj)10t2m1

    即有:

    2lj11<(bjaj)10t2lj1


    对于上述的优化问题,假设精度为小数点后 4 位,则:

    (12.1(3.0))×10000=151000

    2171<1510002181

    那么表示变量 x1 的二进制位串的长度为 l1=18
    同理,对于变量 x2
    (5.84.1)×10000=17000

    2141<170002151

    表示变量 x2 的二进制位串的长度为 l215
    此时,个体可以表示为:
    这里写图片描述
    其中,前 18 位表示的是 x1 ,后 15 位表示的是 x2

    Gray编码

    这种编码方式在求解优化问题时,本人基本上没做过任何研究。

    实数编码

    在二进制编码的过程中存在这样的一个问题,即在计算适应值的时候需要将二进制编码转换成十进制的编码进行运算,这样,很显然会想到能否直接使用十进制编码直接进行运算,如上例中的 (x1,x2) 这样的编码方式。

    有序编码

    有序编码主要使用在TSP问题中,在本文中主要涉及二进制编码和实数编码

    初始群体的设定

    在解决了个体的编码问题后,需要解决的问题是如何利用个体表示群体。在上述中,我们知道,群体是个体的集合。假设初始群体的大小为 N=20 。对于二进制编码方式与实数编码方式产生 20 个初始解。如:

    v1=(010001001011010000111110010100010)

    对应的实数编码的方式则为:
    v1=(1.052426,5.755330)

    对于二进制编码则是随机初始化 20 组这样的初始解,每组初始解随机初始化 33 位的 01 编码。而对于实数编码方式,则是在区间上随机初始化 20 组初始解。

    适应度函数的计算

    适应度函数的目的是评价个体的好坏,如上面的优化问题中,即为最终的优化目标函数。对于二进制编码,则需要先将二进制编码转换成实数编码,再进行适应值函数的计算,对于实数编码方式,则直接进行适应值函数的计算。

    遗传操作设计

    遗传操作主要包括:选择(selection)、交叉(crossover)、变异(mutation),遗传操作的主要目的是从当前的群体中产生新的群体,这样便能使得产生新的更优的个体。

    选择(selection)

    选择操作的目的是选择出父体,用于参加交叉(crossover)和变异(mutation)操作。一般使用较多的方式是轮盘赌的选择策略(Roulette Wheel Selection)。根据每个个体的适应值,计算出相对适应值大小,即:

    pi=fifi

    相对适应值又称为选择概率,将一个圆盘划分成 N 份,即群体的大小。每个扇面的面积与其选择概率成正比。轮盘如下图所示:
    这里写图片描述
    现在在[0,1]上产生一个随机数 r ,若:
    p1+p2++pi1<rp1+p2++pi

    则选择第 i 个个体。
    重复此操作N次,选择出 N 个父体。轮盘赌的算法过程如下所示:
    这里写图片描述

    交叉(crossover)

    交叉操作也称为杂交,其目的是产生新的个体。
    对于二进制编码方式,主要有单点杂交和多点杂交。单点杂交是指在二进制串中随机选择一位,交换两个父体中该位以后的二进制串,用以产生新的个体,操作如下图所示:
    这里写图片描述
    多点杂交是指在二进制串中选择某几位进行杂交,其中以两点杂交最为常见,其过程如下图所示:
    这里写图片描述
    具体的操作过程为:设定一个杂交的概率pc,对选择操作中产生的 N 个父体,每个父体产生一个[0,1]区间上的随机数 rk ,若 rk<pc ,则将第 k 个个体用于杂交,若选择出来的个体数目是奇数,则在父体集合中再随机挑选一个,以保证挑选出的是偶数个,之后进行两两杂交操作。
    对于实数编码形式,可以将实数转换成二进制编码的形式进行杂交运算,但是这样同样存在效率的问题,在实数编码中,主要采用的是算术杂交方式,算术杂交分为:部分算术杂交和整体算术杂交。部分算术杂交是指在父体向量中选择一部分分量进行算术运算,而整体算术杂交是指全部的分量都进行算术运算。我们以整体算术杂交为例:先在[0,1]生成 n 个随机数a1,a2,,an,经杂交算子后,所得到的两个后代为:

    x=(a1x1+(1a1)y1,a2x2+(1a2)y2,,anxn+(1an)yn)

    y=(a1y1+(1a1)x1,a2y2+(1a2)x2,,anyn+(1an)xn)

    变异(mutation)

    变异操作的目的是使得基因突变,在优化算法中,可以防止算法陷入局部最优,从而跳出局部最优,帮助算法找到全局最优解。
    二进制编码时的变异算子非常简单,只是依一定的概率(称为变异概率)将所选个体的位取反。即若是 1 ,则取0;若是 0 ,则取1
    具体的操作为:设定一个变异概率 pm ,对杂交操作后的 N 个父体,对父体中的每一个位产生一个[0,1]区间上的随机数 rk,j ,若 rk,j<pm ,则该位变异。
    对于实数编码方式,可以采用均匀变异和非均匀变异方式,在均匀变异中,假设 x=(x1,x2,,xn) 是要变异的个体,随机产生一个随机整数 k[1,n] ,产生新的后代 x=(x1,x2,,xk,,xn) ,其中 xk [lk,uk] 中服从均匀分布的一个随机数。
    另一种是非均匀变异,,假设 x=(x1,x2,,xn) 是要变异的个体,随机产生一个随机整数 k[1,n] ,产生新的后代 x=(x1,x2,,xk,,xn) ,其中:

    xk={xk+Δ(t,ukxk)xkΔ(t,xklk) if Random(2)=0 if Random(2)=1

    这里 t 是当前演化代数,函数Δ(t,y)返回 [0,y] 中的一个值,并且 Δ(t,y) t 的增加而趋于0的概率增大。函数 Δ(t,y) 具体形式为:
    Δ(t,y)=y(1r(1t/T)b)

    或者
    Δ(t,y)=yr(1tT)b

    其中, r [0,1]上的一个随机数, T 表示最大演化代数。b是确定非均匀度的一个参数,通常取 25

    控制参数的设定

    控制参数主要包括种群的规模 N ,演化代数T,杂交概率 pc ,变异概率 pm 等等。


    在实现遗传算法时,一个常用的方法是将到当前代为止演化的最好个体单独存放起来,在遗传算法结束后,将演化过程中发现的最好个体作为问题的最优解或近似最优解。


    求解优化问题的实例

    问题描述

    minf(x1,x2,,xn)=20exp0.21ni=1nx2iexp(1ni=1ncos(2πxi))+20+e

    其中,
    30xi30,i=1,2,,n;e=2.71828

    问题分析

    这是一道不带约束条件的函数优化的问题,既可以采用二进制编码方式,也可以采用十进制的编码方式,在本题的解决过程中,采用十进制的编码方式。首先通过Matlab得到的函数图像大致如下,从图像中可以观察到当 n=2 时,我们可以在 (0,0) 附近取得函数的最小值。
    这里写图片描述

    算法设计

    基于以上的分析,当 n=2 时,以下分别从个体的编码、适应值函数、选择策略、杂交算子、变异算子、参数设置、初始化以及终止条件这八个方面对程序的设计作简要的描述:

    个体编码

    采用实数向量编码,每一个个体是一实数对 (x1,x2)

    适应值函数

    该优化问题是一个极小化问题,可对目标函数作简单变换,同时考虑到在选择策略时选择的是轮盘赌的选择策略,轮盘赌的选择策略有一个要求就是个体的适应值要为正数,因此,可以作如下的变换: F=30f(x1,x2) ,这里的 30 是取的一个上界。这样,既保证了变换后的适应值函数式中为正,而且我们可以将极小化问题转换成一个极大值问题考虑。

    选择策略

    采用轮盘赌的选择策略,因为在计算适应值时已经作了处理,即适应值始终为正,这样就可以使用轮盘赌的选择策略。轮盘赌的选择策略是一种基于适应值比例的选择策略,适应值越大被选择到下一代的概率也会越大。

    杂交算子

    采用整体算术杂交,即给定两个父体,产生一个随机数,经杂交后得到两个后代个体, v1=(x1,x2) v2=(y1,y2) ,产生一个随机数 α[0,1] ,经杂交后得到两个后代个体: v1=(αx1+(1α)y1,αx2+(1α)y2) v2=(αy1+(1α)x1,αy2+(1α)x2)

    变异算子

    采用非均匀变异,即对于要变异的个体 x=(x1,x2) ,随机产生整数 k{1,2} ,例如 k=1 ,然后产生后代 x=(x1,x2) ,其中

    x1={x1+Δ(t,u1x1)x1Δ(t,x1l1) if Random(2)=0 if Random(2)=1

    参数设置

    • 种群规模 N=100
    • 个体长度 Size=2
    • 演化代数 T=3000
    • 杂交概率 pc=0.7
    • 变异概率 pm=0.1
    • 函数上界 Upp=30.0

    初始化

    在区间内随机初始化种群的个体,并置个体的适应值,适应值之和以及相对适应值比例为 0 <script type="math/tex" id="MathJax-Element-10633">0</script>。

    终止条件

    采用代数作为终止条件,当算法运行到指定的最大代数时,程序停止。

    实验代码

    #include<iostream>
    #include<time.h>
    #include<stdlib.h>
    #include<cmath>
    #include<fstream>
    
    using namespace std;
    
    
    const int COLONY_SIZE=100;  //个体数目
    const int Size=2;//个体的长度
    const int Generation=3000;//代数
    const double OVER=0.7;//杂交的概率
    const double MUTATE=0.1;//变异的概率
    const double UPPER=30.0;//函数的上界
    
    struct Indival
    {
        double code[Size];
        double fitness;
        double cfitness;
        double rfitness;
    }Group[COLONY_SIZE];
    
    Indival newGroup[COLONY_SIZE];
    
    Indival bestChrom;//记录最好的个体
    
    int GenNum=0;
    
    double random(double, double);
    void initiate();
    void calvalue();
    void select();
    void crossOver();
    void xOver(int,int);
    void mutate();
    double delta(int,double,double,double);
    void sort();
    
    /*****************主函数***************/
    int main()
    {
        ofstream output;
        srand((unsigned)time(NULL));
        initiate();
        calvalue();
        output.open("data.txt");
        while(GenNum<=Generation)
        {
            GenNum++;
            select();   
            crossOver();
            mutate();   
            calvalue(); 
            sort();
            if (bestChrom.fitness<Group[0].fitness)
            {
                bestChrom.code[0]=Group[0].code[0];
                bestChrom.code[1]=Group[0].code[1];
                bestChrom.fitness=Group[0].fitness;
            }
    //      output<<"gen: "<<GenNum<<"最优解为:"<<endl;
    //      output<<"x1: "<<bestChrom.code[0]<<"  x2: "<<bestChrom.code[1]<<"   函数值为: "<<(30-bestChrom.fitness)<<endl;
            output<<GenNum<<"   "<<(30-bestChrom.fitness)<<endl;
        }
        output.close();
        cout<<"运行结束!"<<endl;//提示运行结束
        return 0;
    }
    
    
    /******************************函数的实现*****************************************/
    
    
    double random(double start, double end){//随机产生区间内的随机数   
        return start+(end-start)*rand()/(RAND_MAX + 1.0);
    }
    
    void initiate()//初始化
    {
        for(int i=0;i<COLONY_SIZE;i++)
        {
            Group[i].code[0]=random(-30,30);
            Group[i].code[1]=random(-30,30);
            Group[i].fitness=0;//适应值
            Group[i].cfitness=0;//相对适应值比例之和
            Group[i].rfitness=0;//相对适应值比例
        }
    }
    
    void calvalue()//计算适应值
    {
        double x1,x2;
        double sum=0;
        double part1,part2;//将函数分成几个部分
        for(int i=0;i<COLONY_SIZE;i++)
        {
            x1=Group[i].code[0];
            x2=Group[i].code[1];
            part1=-0.2*sqrt((x1*x1+x2*x2)/Size);
            part2=(cos(2*3.1415926*x1)+cos(2*3.1415926*x2))/Size;
            Group[i].fitness=UPPER-(-20*exp(part1)-exp(part2)+20+2.71828);//适应值
            sum+=Group[i].fitness;//计算适应值之和
        }
        for(int mem=0;mem<COLONY_SIZE;mem++)//轮盘赌选择机制里所要求的几个参数
        {
            Group[mem].rfitness=Group[mem].fitness/sum;//适应值的比例
        }
        Group[0].cfitness=Group[0].rfitness;
        for(mem=1;mem<COLONY_SIZE;mem++)
        {
            Group[mem].cfitness=Group[mem-1].cfitness+Group[mem].rfitness;//模拟轮盘
        }
    
    
    }
    void select()
    {
        double p;
        for(int i=0;i<COLONY_SIZE;i++)//挑选出N个个体
        {
            p=random(0,1);//随机产生0到1之间的随机数
            if(p<Group[0].cfitness)
                newGroup[i]=Group[0];
            else
            {
                for(int j=1;j<COLONY_SIZE;j++)//往轮盘后走
                {
                    if(p>=Group[j-1].cfitness&&p<Group[j].cfitness)
                    {
                        newGroup[i]=Group[j];
                        break;
                    }
                }
            }
        }
        for(i=0;i<COLONY_SIZE;i++)//从newGroup复制到Group中
            Group[i]=newGroup[i];
    }
    void crossOver()
    {
        int mem,one;
        int first=0;//记录杂交的数目
        double x;
        for(mem=0;mem<COLONY_SIZE;mem++)
        {
            x=random(0,1);
            if(x<OVER)
            {
                ++first;
                if(first%2==0)//若为偶数
                    xOver(one,mem);
                else 
                    one=mem;
            }
        }
    }
    void xOver(int one,int two)
    {
        double point;
        point=random(0,1);
        Group[one].code[0]=Group[one].code[0]*point+Group[two].code[0]*(1-point);
        Group[one].code[1]=Group[one].code[1]*point+Group[two].code[1]*(1-point);
        Group[two].code[0]=Group[one].code[0]*(1-point)+Group[two].code[0]*point;
        Group[two].code[1]=Group[one].code[1]*(1-point)+Group[two].code[1]*point;
    }
    void mutate()
    {
        double x;
        for(int i=0;i<COLONY_SIZE;i++)
        {
            for(int j=0;j<Size;j++)
            {
                x=random(0,1);
                if (x<MUTATE)
                {
                    Group[i].code[j]=delta(GenNum,Group[i].code[0],30,-30);
                }
            }
        }
    }
    
    
    double delta(int t,double x,double u,double l)
    {
        double temp1;
        double temp2;
        double y;
        double r=random(0,1);
        temp1=pow((1-t/Generation),4);
        temp2=pow(r,temp1);
        int a=(int)random(0,2);
        if(a==0)
        {
            y=u-x;
            return (x+y*(1-temp2));
        }else
        {
            y=x-l;
            return (x-y*(1-temp2));
        }
    }
    
    void sort()//排序
    {
        Indival temp;
        for(int i=0;i<COLONY_SIZE-1;i++)
        {
            for(int j=i+1;j<COLONY_SIZE;j++)
            {
                if(Group[i].fitness<Group[j].fitness)
                {
                    temp=Group[i];
                    Group[i]=Group[j];
                    Group[j]=temp;
                }
            }
        }
    }
    

    最终结果

    这里写图片描述

    我在这里简单介绍了遗传算法,遗传算法是一个研究较多的算法,还有利用遗传算法求解组合优化问题,带约束的优化问题,还有一些遗传算法的理论知识,如模式定理,积木块假设,在这里就不一一列举了,希望我的博文对你的学习有帮助,也欢迎转载,谢谢,有不到位的地方还请指出。

    展开全文
  • App 启动时间优化方法详解

    千次阅读 2017-11-24 15:53:31
    本文将讨论如何优化应用的启动时间,首先我们需要了解app启动的相关内容。 App 启动模式分类 应用中冷启动避免白屏、黑屏方案 Framework 层解决冷启动白屏、黑屏方案 App 启动优化原理 App 启动优化简介 Ap.....

    用户希望APP 能够快速响应并加载。 一个启动速度慢的APP 不符合用户期望,可能会令用户失望,并且可能会导致用户对您的应用程序评价不佳,甚至会卸载你的应用。

    本文将讨论如何优化应用的启动时间,首先我们需要了解app启动的相关内容。

    1. App 启动模式分类
    2. 应用中冷启动避免白屏、黑屏方案
    3. Framework 层解决冷启动白屏、黑屏方案
    4. App 启动优化原理
    5. App 启动优化简介
    6. App 启动优化方案
    7. 在 PMS中 App 启动优化方案

    欢迎关注微信公众号:程序员Android
    公众号ID:ProgramAndroid
    获取更多信息

    微信公众号:ProgramAndroid

    我们不是牛逼的程序员,我们只是程序开发中的垫脚石。
    我们不发送红包,我们只是红包的搬运工。

    1. App 启动模式分类

    App 启动模式分以下 三 类 :

    1.冷启动
    2.热启动
    3.温热启动

    • 1.冷启动

    app 从零开始,APP 启动之前,系统没有为此 app 创建独立进程。比如:设备启动后,app第一次 Launch 或者app被Kill 掉后的重启。这种类型的启动优化存在很大挑战,因为Android 系统或应用还有其他更多的后台进程在运行。

    启动流程大致如下:

    点击Launcher 上的 icon开加载app -->立即显示白屏或黑屏等 --> Application onCreate --> Activity Init----> Activity onCreate ---> 初始化数据,填充显示View ---> Activity onResume等,详细请看下图:

    App启动进程优化

      1. 热启动

    APP 的热启动要比 冷启动简单得多,内存开销也更低。APP热启动时候,所有的系统都是把你的Activity带到前台。如果APP的所有Activity 仍驻留在内存中,则APP 可以避免重复对象初始化、布局绘制和显示等工作。
    如果APP 在内存中被清理掉,比如调用ontrimmemory(),当响应热启动时,这些对象将重新被创建。

    热启动与冷启动相同的屏幕行为:
    系统进程会显示一个空白屏幕,直到应用程序完成渲染后将此空白屏幕移除掉,此屏幕创建会在加载app时候立即创建,如需查看创建流程,需要查看PhoneWindosMangerAddWindows方法。

      1. 温热启动

    处于冷启动与热启动之间,既包含一些冷启动的操作,又含有部分热启动的功能。例如以下两种状态:

    1. 用户退出APP后重新Launch。

    此时此APP的进程可能会存在,然鹅,Activity 必须重新创建并调用onCreate方法

    1. APP 被缓存中清理掉时。

    此时用户重新Launch APP时,此app的进程和Activity都需要重新创建,但是任务栈中会保存部分APP实例数据(bundle类型)传递个Activity onCreate方法

    2. App 启动时间测量与分析

    为了更加准确的测量 APP 启动的耗时,请务必使用User版本进行验证。UserDebug 或者eng 版本会开很多调试开关影响测试的正常结果。

    如何获取app 启动时间,请看以下测量方法

    主要: 以下测试方法请在Android 4.4(含) 以上的版本进行

    1.通过 adb 命令测量APP 冷启动时间

    使用adb 命令直接启动app 进而测量app 启动耗时 的方法如下:

    adb shell am start -W [packageName]/[packageName.MainActivity]


    adb [-d|-e|-s <serialNumber>] shell am start -S -W [packageName]/[packageName.MainActivity] -c android.intent.category.LAUNCHER -a android.intent.action.MAIN
    如要测量的app没有源码,比如:QQ,请用以下命令获取, 当前获取焦点的Activity ,方法信息如下:

    adb shell dumpsys activity |findstr "mFocused"

    APP 启动时间详情 请看以下图片中椭圆 红框区域内容。

    测量APP冷启动时间的方法

    2.通过 adb logcat 查看APP 启动时间

    在Log中,主要是 通过分析 logcat中app 在 ActivityManager: Displayed的时间值 ,此时间值包含以下时间综合信息:

    1. Launch 进程
    2. 初始化对象
    3. 创建并初始化Activity
    4. 填充布局
    5. 第一次绘制app 内容

    比如下图:ProgramAndroid程序启动时间 700ms

    adb logcat 查看APP 启动时间

    3. 在代码中测量app启动性能的方法如下:

    在Activity 代码用调用 reportFullyDrawn(); 方法,将绘制完成后信息反馈到Log上,此方法跟logcat中查看的时间相似。
    比如自己运行ProgramAndrod app的启动时间信息如下

    11-24 11:47:00.363   982  1191 I ActivityManager: Fully drawn com.programandroid/.MainActivity: +998ms
    

    reportFullyDrawn()方法告知系统app Launch 成功时间

    4. 使用Systrace 工具分析app启动时间

    当然如果感觉上述方法比较麻烦,可以使用 Systrace 工具进行分析,工具分析情况,下次贴出。

    在代码中测量app启动性能的方法,使用工具分析

    2. 应用中冷启动避免白屏、黑屏方案

    手机中 App 首次启动(未在最近任务列表中,或已经运行过,但在最近任务列表中已清除启动记录)称为冷启动,此时打开app时候回闪白屏或黑屏,特别是当系统主题为黑色或白色时候比较明显。

    在应用端规避掉打开app 闪白屏、黑屏问题,主要是从android:windowIsTranslucent上让白屏变透明,进而不让用户看到白屏、黑屏现象。

    但是,此解决方案会导致在Launcher 中点击app icon 是会有轻微的卡顿现象,此现象会让用户误认为手机卡,app启动慢,从而将打开app 闪白屏的黑锅甩给手机制造厂商。

    1. 透明样式Theme 解决方案如下:

      1. 自定义透明样式
        在res/values/style.xml 中自定义样式

    自定义透明样式

      1. App 启动入口Activity 中使用自定义样式

    App 启动入口Activity 中使用自定义样式

    注意: windowDisablePreview =false 属性可以不让白屏显示,失去中间白屏过度,会给用户带来不是太好的体验,比如点击后需要稍微等一下才会打开app,会让用户错误的怀疑自己是否成功点击过icon。Google 很不推荐此种做法。

    2. 使用app logo等图片样式使用方法如下

    1. 自定义Theme
    <layer-list xmlns:android="http://schemas.android.com/apk/res/android" android:opacity="opaque">
      <!-- The background color, preferably the same as your normal theme -->
      <item android:drawable="@android:color/white"/>
      <!-- Your product logo - 144dp color version of your app icon -->
      <item>
        <bitmap
          android:src="@drawable/product_logo_144dp"
          android:gravity="center"/>
      </item>
    </layer-list>
    
    1. 为 要启动的Activity设置自定义样式
    <activity ...
    android:theme="@style/AppTheme.Launcher" />
    
    1. 同样也可以在Java类中的 设置样式
    public class MyMainActivity extends AppCompatActivity {
      @Override
      protected void onCreate(Bundle savedInstanceState) {
        // Make sure this is before calling super.onCreate
        setTheme(R.style.Theme_MyApp);
        super.onCreate(savedInstanceState);
        // ...
      }
    }
    

    此方法也是Google 推荐的方法,建议大家可以用自定义Theme 替换掉系统中的白屏,当然也可以搞成什么广告页面等等。

    3. Framework 层解决冷启动白屏、黑屏方案

    打开app 闪黑屏、白屏的根本原因在于PhonewindowManger中的addStartingWindow 方法。

    addStartingWindow方法

    自定义填充Window 背景

    Framwork 上 这样修改后,会将白色屏幕替换成我们客制化的颜色,此修改会影响到所有app的启动。

    4. App 启动优化原理

    L版本之后,手机上所有APP都要经过dex2oat处理之后,才能运行.
    dex2oat 是将原来的dex文件预先的翻译处理,从而加快APP运行的时间,但由于某些APP比较复杂,优化的时间可能会比较长,进而给用户感觉运行卡顿。

    dex2oat 优化是以dex文件中的method为单位,dex2oat 会根据需要优化一定量的method,也就是说并不是优化的method都会被翻译成oat模式。

    根据优化的method的量的多少,可以分为如下的几种模式:

    Android 虚拟机优化模式

     

    5. App 启动优化简介

    Android L之后的版本,如无特殊处理,app启动模式为Speed模式,此模式性能较好,但优化之后的文件占用空间比较大。不同模式可以看上面MTK 提供的参考标准。

    对App 的优化是通过dex2oat 去执行的,优化模式的参数是有外界调用dex2oat方法传递的参数控制,如无传递参数,默认参数Speed

    那么调用dex2oat的路径有哪些呢?

    • 1.安装APP时

    通过 Framework 下的PackageManagerService 将参数传递给 mAppInstallDir,然后mAppInstallDir 调用dex2oat,因此此种方式的优化模式通过PMS控制。

    此种模式是将APP的路径,优化之后的oat存放路径,传递给dex2oat
    但是由于内容可能发生改变,我们有可能无法在dex2oatAPP加以识别,所以,这时候,可以在installd或者PMS中加以判断,是否是我们认为安装比较慢的APP,如果是的话,则改变其优化模式。

      1. APP自身优化插件时

    此种模式往往会指定模式为speed模式或者不指定,在优化之后的保存路径中,携带APP的包名。

    intall.jpg

    目前有些 apk 像 Facebook、微信 WeChat 等 apk,应用本身较大且代码复杂度高,可能会出现安装失败,安装慢等问题。

    安装失败是由于dex2oat进程编译时间过久打到了timeout
    安装慢当然就是dex2oat做的compiler久的原因。

    另外,像 微信 WeChat 这种apk在启动应用的时候是会优化插件的(而不是在安装的时候优化),这样就会导致应用lunch时间过久,给用户的感觉就是很晚才入,手机卡顿等锅,让手机厂商背负。在需更改优化的模式,加快安装的时间时,请注意此修改会降低 APP运行的性能。

    注意:
    app 安装 / lunch时间的长短取决于CPU核心数,8 核CPU 肯定比 4 核 CPU优化要快,除此之外,还取决于EMMC的性能 ,memory等系统因素。

    6. App 启动优化方案

    对于app 优化目前有3个地方可以进行处理。

      1. PackageManagerService中

    这个地方是安装APP必经之路,代码存放地址如下:

     

    PackageManagerService 代码路径

      1. installd的commands.cpp中

    这也是安装APP的必经之路 ,代码存放地址如下:

     

    commands.cpp代码存放路径

      1. dex2oat 中

    ex2oat是所有APP或者jar包的必经之路,但是由于传递给dex2oat的参数有限,所以可能无法识别。

    因此,对于安装APP可以在PMS中修改,而对于jar包可以在dex2oat当中修改。
    因为PMS中我们可以知道APP的pkg信息,这个是每一个APP唯一的。
    而对jar包来说,由于每一个APP在优化的时候,喜欢把优化之后的jar包放在自己安装的APP路径下面。所以,可以利用这个特性进行判断 。

    7. 在 PMS中 App 启动优化方案

    此解决方案适用于Android N版本

    主要修改PackageDexOptimizer.java文件的 performDexOptLI方法中进行优化。

    image.png

    在这函数中,可以判断传递下来的pkg是否是我们需要的app,如果是的话,将targetCompilerFilter设置为speed-profile
    speed-profile 会在安装的时候采用 interperter-only,然后,运行一段时间之后,会将那些常用的方法优化成为speed模式。也就是说是有选择性的优化。

    优化 app 启动模式

    至此,本篇已结束,如有不对的地方,欢迎您的建议与指正。同时期待您的关注,感谢您的阅读,谢谢!

    如有侵权,请联系小编,小编对此深感抱歉,届时小编会删除文章,立即停止侵权行为,请您多多包涵。

    既然都看到这里,领两个红包在走吧!
    以下两个红包每天都可以领取

    1.支付宝搜索 522398497,或扫码支付宝红包海报。

    支付宝扫一扫,每天领取大红包

    2.微信红包,微信扫一扫即可领取红包

     

    微信扫一扫,每天领取微信红包

    小礼物走一走,来简书关注我

    展开全文
  • 优化理论与方法

    千次阅读 2019-04-23 12:28:47
    优化问题 :eg:,其中x在控制问题中被称为为控制决策变量;在数学优化中叫做决策量。无论是最优控制还是数学优化(数学规划)都是优化问题,即都是这样的形式。 1. 优化的两个基本问题 确定一个优化的必要或/和...

    优化问题 :eg:{min}_xf\left ( x \right ) st. x\in D,其中x在控制问题中被称为为控制决策变量;在数学优化中叫做决策量。无论是最优控制还是数学优化(数学规划)都是优化问题,即都是{min}_xf\left ( x \right ) st. x\in D这样的形式。

    1. 优化的两个基本问题

    • 确定一个优化的必要或/和充分的条件(建模)。
    • 设计一个数值程序(算法的设计+程序的实现)。

    遗传算法在弱优化或无约束优化问题中应用较好。

    2. 优化的相关概念

    静态    vs    动态    数学优化\leftrightarrow最优控制;

    连续    vs   离散    数学优化的离散与连续问题\leftrightarrow控制问题的连续与离散问题;

    凸   vs   非凸   既可能与目标有关,又可能与约束有关;

    完美   vs   满意   结果的完美解与满意解;

    严格   vs   启发   方法在数学上是否严格收敛到最优与否。

    2.1 静态优化(参数优化、数学规划等方法)

    • 对变量进行优化;
    • 约束条件与目标为代数方程或不等式。

    2.2 动态优化(变分问题、最优控制)

    • 对函数进行优化(例如最优决策路径)(函数未知)
    • 目标为积分型泛函;
    • 约束条件包含微分方程。

    2.3 连续优化与离散优化

    • 可行域(决策空间)
    •     0-1规划
    •     整数规划
    • 时间序列
    •     离散时间的动态规划——差分描述
    •     连续时间的动态规划——微分描述

    2.4 确定性优化与随机优化

    • DP 动态优化 确定性;
    • MDP Markov决策过程 随机性

    2.5 凸与非凸

    • 凸集;
    • 凸函数

    2.6 启发与随机化搜索

    • 启发式+随机化=高级启发或超级启发(遗传算法、模拟退火算法、蚁群算法);

    2.7 完美解与满意解

    • 一般需要对满意解进行评价

    3 优化方法

    迭代    vs   解析    计算机喜爱迭代方法,并且这种方法效率高;

    串行    vs    并行    

    求导    vs    搜索

    点对点    vs    集到集

    解析    vs    启发

    注:结构知识绝对重要,搜索方法应当在结构信息的指导下进行搜索。启发、学习、人的才智以及软优化在求解方法中占有重要地位。

    一些常用的迭代方法

    • 梯度法(利用了梯度结构信息)
    • 牛顿法(利用了梯度+Hessen矩阵等结构信息)
    • BFGS (共轭梯度结构信息)
    展开全文
  • 如何优化网站的响应时间

    千次阅读 2016-09-20 23:10:03
    优化网站的响应时间,主要有以下几个方法: 1. 减少HTTP请求 下载一个CSS文件或者图片需要一个独立的HTTP请求,而解析HTTP协议的过程需要时间。处于相对顶层的HTTP协议占用更多传输量,所以减少HTTP请求可以...
  • MySQL优化技巧

    万次阅读 多人点赞 2017-09-10 14:14:00
    MySQL优化三大方向① 优化MySQL所在服务器内核(此优化一般由运维人员完成)。② 对MySQL配置参数进行优化(my.cnf)此优化需要进行压力测试来进行参数调整。③ 对SQL语句以及表优化。MySQL参数优化1:MySQL 默认的最大...
  • 数据库的查询优化方法

    万次阅读 多人点赞 2018-09-06 15:26:07
    1.对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引。 2.应尽量避免在 where 子句中对字段进行 null 值判断,否则将导致引擎放弃使用索引而进行全表扫描,如:select id ...
  • sql优化的几种方法

    万次阅读 多人点赞 2018-03-04 21:50:25
    在sql查询中为了提高查询效率,我们常常会采取一些措施对查询语句进行sql优化,下面总结的一些方法,有需要的可以参考参考。1.对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立...
  • 梯度下降算法针对凸优化问题原则上是可以收敛到全局最优的,因为此时只有唯一的局部最优点。而实际上深度学习模型是一个复杂的非线性结构,一般属于非凸问题,这意味着存在很多局部最优点(鞍点),采用梯度下降算法...
  • 常用SQL优化方法

    万次阅读 多人点赞 2018-04-10 07:55:09
    2、对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引。 3、应尽量避免在 where 子句中对字段进行 null值判断,否则将导致引擎放弃使用索引而进行全表扫描,如: select id...
  • 利用进化多目标优化算法NSGA-II求解多目标函数优化问题,选择三个多目标优化问题(包括函数表达式、决策变量取值范围)进行求解。本文选取两目标优化ZDT问题集中的三个问题,ZDT问题集均基于以下f1和f2的优化,其...
  • SEO行业种很多人都认为子域名比子目录权重高,但仍有一大部分人认为来看,搭建一个子目录比一个二级域名要好的多,网站的目录...子目录和子域名如何利用seo优化?  一个网站又数个或者N个页面,他们分别用url进行标识
  • 深度学习之参数优化方法

    千次阅读 2018-01-03 20:37:50
    优化问题:给定目标函数f(x),我们需要找到一组参数x,使得f(x)的值最小 1.Vanilla update x += - learning_rate * dx 对于训练数据集,我们首先将其...当训练数据太多时,利用整个数据集更新往往时间上不显示。batch
  • win10关闭自动更新方法集合(1909)

    千次阅读 2020-02-01 22:05:52
    为什么要禁止win10自动更新? 因为win10自动更新后有系统有几率出问题。 因为害怕在跑程序的时候自动重启更新导致程序终止。...以下方法越推荐越靠前,虽然有些已经无效了。 1.利用自带的停止更新功能 ...
  • 图像与视频处理中的优化方法

    千次阅读 2018-07-26 23:07:35
    要求使用背景建模的相关技术(最好使用优化方法),区分出前景和背景,输出为视频的每一帧对应的前景和背景。 如图[pic1]所示: 图像,左边是输入,右边是输出。 问题二:主成分提取 输入为一张由若干张小图...
  • 嵌入式 Linux 启动时间优化

    千次阅读 2018-11-01 12:40:07
    本章包含的话题有启动时间的测量、分析、人因工程(human factors)、初始化技术和优化技巧等。 产品花在启动方面的时间直接影响终端用户对该产品的第一印象。 一个消费电子设备不管如何引人注目或者设计得怎么好...
  • 无约束优化方法

    千次阅读 2018-09-15 20:50:17
    1.1问题定义 1.1.1优化问题定义 最优化问题数学上定义,最优化问题的一般形式为  (1) 其中的是自变量,f(x)是目标函数,为约束集或者说可行域。 ...可行域这个东西,有等式约束,也...1.1.2最优化方法定义 优化...
  • 对于tomcat优化,主要从2个方面,一是tomcat自身的配置,另外一个就是利用jvm虚拟机的调优。 随便找个web项目(不想找的可以私信或者评论找我要我测试的),打成war包丢到tomcat ROOT下,去mysql官网找点测试数据。...
  • 30种SQL查询语句优化方法

    千次阅读 多人点赞 2019-10-23 14:49:09
    关于mysql处理百万级以上的数据时如何提高其查询速度的方法最近一段时间由于工作需要,开始关注针对Mysql数据库的select查询语句的相关优化方法。 由于在参与的实际项目中发现当mysql表的数据量达到百万级时,普通...
  • sql优化的几种方式

    万次阅读 多人点赞 2018-11-05 10:20:46
    我们开发项目上线初期,由于业务数据量相对较少,一些SQL的执行效率对程序运行效率的影响不太明显,而开发和运维人员也无法判断SQL对程序的运行效率有多大,故很少针对SQL进行专门的优化,而随着时间的积累,业务...
  • CPU CACHE优化 性能优化方法和技巧

    千次阅读 2014-08-22 15:42:40
    性能优化方法和技巧   系列目录 性能优化方法和技巧 性能优化方法和技巧:概述 性能优化方法和技巧:代码 性能优化方法和技巧:工具 这是一个可以用一本书来讲的...
  • 机器学习的目标是给出一个模型(一般是映射函数),然后定义对这个模型好坏的...第三个问题是纯数学问题,即最优化方法。 机器学习要求解的数学模型 1.有监督学习:目标函数的极值 对于有监督学习,我们要找到一...
  • KERAS各种优化方法总结

    千次阅读 2018-03-14 23:42:08
    KERAS各种优化方法总结 SGDMOMENTUMNESTEROV http://blog.csdn.net/luo123n/article/details/48239963 前言这里讨论的优化问题指的是,给定目标函数f(x),我们需要找到一组参数x,使得f(x)的值最小。本文以下内容...
  • 下面是网络中流传最广的一篇sql查询速度慢的原因及解决方法的文章,其对于处理mysql的慢查询有借鉴作用。由于此文转载多次,很难找到最开始的原文链接,就附送本人最先看到此文的链接:...
  • 优化方法matlab实现

    万次阅读 多人点赞 2017-04-13 11:32:54
    优化问题测试函数: ... 利用Matlab的优化工具箱,可以求解线性规划、非线性规划和多目标规划问题。具体而言,包括线性、非线性最小化,最大最小化,二次规划,半无限问题,线性、非线性方
  • 离散数学在计算机科学中的应用

    万次阅读 多人点赞 2018-02-03 11:56:44
    这次离散数学的最后一题是:利用本学期学到的离散数学的知识阐释其在一个软件工程中的应用。 下面说说离散数学的应用。 离散数学在数据结构中的应用 数据结构中将操作对象间的关系分为四类:集合、线性结构、树形...
  • SQL语句优化有哪些方法

    万次阅读 多人点赞 2018-01-16 16:58:26
    当我们通过安全日志启动时,当超过超时时间时,会将超时的SQl存放在日志中,我们去分析这些sql然后进行调优.2.数据库设计要合理什么是数据库设计? 主要就是三范式1p原子性:每列不可再分,比如姓名不可分,地址有可能会在...
  • 谈谈常见的迭代优化方法

    万次阅读 2016-02-02 09:54:22
    如果学习机器学习算法,你会发现,其实机器学习的过程大概就是定义一个模型的目标函数,然后通过优化算法从数据中求取J(θ)取得极值时对应模型参数θ的过程,而学习到的参数就对应于机器学习到的知识。不管学习到的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 662,125
精华内容 264,850
关键字:

优化时间利用的方法