精华内容
下载资源
问答
  • 模拟退火算法 Matlab

    2020-12-12 22:53:06
    Matlab里面写的模拟退火算法,这个算法理解起来比较简单,也更容易局部解。网上资料很多。大家可以参考一下。和遗传算法一样都是一种优化算法,可以参考和交流。
  • 模拟退火算法 matlab code 完整版
  • 模拟退火算法MATLAB

    千次阅读 热门讨论 2018-05-07 21:24:47
    转载自:https://blog.csdn.net/pangel18/article/details/52349840模拟退火用于处理最优化问题,可以求出当目标函数取得最小值时的决策变量的值。在编写程序时需要根据具体问题设计算法算法描述为:(1)解空间...

    转载自:https://blog.csdn.net/pangel18/article/details/52349840

    模拟退火用于处理最优化问题,可以求出当目标函数取得最小值时的决策变量的值。

    在编写程序时需要根据具体问题设计算法,算法描述为:

    (1)解空间(初始解)

    (2)目标函数

    (3)新解的产生
    ① 2 变换法

    ② 3 变换法

    (4)代价函数差

    (5)接受准则

    (6)降温

    (7)结束条件

    下面MATLAB程序用于求解非线性规划:

    min f(x)=x1^2+x2^2+8

    st.

    x1^2-x2>=0

    -x1-x2^2+2=0

    x1,x2>=0

    1. clear  
    2. clc  
    3.   
    4. %生成初始解  
    5. sol_new2=1;%(1)解空间(初始解)  
    6. sol_new1=2-sol_new2^2;  
    7. sol_current1 = sol_new1;   
    8. sol_best1 = sol_new1;  
    9. sol_current2 = sol_new2;   
    10. sol_best2 = sol_new2;  
    11. E_current = inf;  
    12. E_best = inf;  
    13.   
    14. rand('state',sum(clock)); %初始化随机数发生器  
    15. t=90; %初始温度  
    16. tf=89.9; %结束温度  
    17. a = 0.99; %温度下降比例  
    18.   
    19. while t>=tf%(7)结束条件  
    20.     for r=1:1000 %退火次数  
    21.           
    22.         %产生随机扰动(3)新解的产生  
    23.         sol_new2=sol_new2+rand*0.2;  
    24.         sol_new1=2-sol_new2^2;  
    25.           
    26.         %检查是否满足约束  
    27.         if sol_new1^2-sol_new2>=0 && -sol_new1-sol_new2^2+2==0 && sol_new1>=0 &&sol_new2>=0  
    28.         else  
    29.             sol_new2=rand*2;  
    30.             sol_new1=2-sol_new2^2;  
    31.             continue;  
    32.         end  
    33.           
    34.         %退火过程  
    35.         E_new=sol_new1^2+sol_new2^2+8;%(2)目标函数  
    36.         if E_new<E_current%(5)接受准则  
    37.                 E_current=E_new;  
    38.                 sol_current1=sol_new1;  
    39.                 sol_current2=sol_new2;  
    40.                 if E_new<E_best  
    41.                     %把冷却过程中最好的解保存下来  
    42.                     E_best=E_new;  
    43.                     sol_best1=sol_new1;  
    44.                     sol_best2=sol_new2;  
    45.                 end  
    46.         else  
    47.                 if rand<exp(-(E_new-E_current)/t)%(4)代价函数差  
    48.                     E_current=E_new;  
    49.                     sol_current1=sol_new1;  
    50.                     sol_current2=sol_new2;  
    51.                 else  
    52.                     sol_new1=sol_current1;  
    53.                     sol_new2=sol_current2;  
    54.                 end  
    55.         end  
    56.         plot(r,E_best,'*')  
    57.         hold on  
    58.     end  
    59.     t=t*a;%(6)降温  
    60. end  
    61.   
    62. disp('最优解为:')  
    63. disp(sol_best1)  
    64. disp(sol_best2)  
    65. disp('目标表达式的最小值等于:')  
    66. disp(E_best)  

    1. 最优解为:  
    2.     1.0038  
    3.   
    4.     0.9981  
    5.   
    6. 目标表达式的最小值等于:  
    7.    10.0038  

    司守奎的算法大全给出了利用模拟退火求解TSP问题的MATLAB算法:

    1. clc,clear  
    2. load sj.txt %加载敌方100 个目标的数据,数据按照表格中的位置保存在纯文本  
    3. 文件sj.txt 中  
    4. x=sj(:,1:2:8);x=x(:);  
    5. y=sj(:,2:2:8);y=y(:);  
    6. sj=[x y];  
    7. d1=[70,40];  
    8. sj=[d1;sj;d1];  
    9. sj=sj*pi/180;  
    10. %距离矩阵d  
    11. d=zeros(102);  
    12. for i=1:101  
    13. for j=i+1:102  
    14. temp=cos(sj(i,1)-sj(j,1))*cos(sj(i,2))*cos(sj(j,2))+sin(sj(i,2))*sin(sj(j,2));  
    15. d(i,j)=6370*acos(temp);  
    16. end  
    17. end  
    18. d=d+d';  
    19. S0=[];Sum=inf;  
    20. rand('state',sum(clock));  
    21. for j=1:1000  
    22. S=[1 1+randperm(100),102];  
    23. temp=0;  
    24. -276-  
    25. for i=1:101  
    26. temp=temp+d(S(i),S(i+1));  
    27. end  
    28. if temp<Sum  
    29. S0=S;Sum=temp;  
    30. end  
    31. end  
    32. e=0.1^30;L=20000;at=0.999;T=1;  
    33. %退火过程  
    34. for k=1:L  
    35. %产生新解  
    36. c=2+floor(100*rand(1,2));  
    37. c=sort(c);  
    38. c1=c(1);c2=c(2);  
    39. %计算代价函数值  
    40. df=d(S0(c1-1),S0(c2))+d(S0(c1),S0(c2+1))-d(S0(c1-1),S0(c1))-d(S0(c2),S0(c2+1));  
    41. %接受准则  
    42. if df<0  
    43. S0=[S0(1:c1-1),S0(c2:-1:c1),S0(c2+1:102)];  
    44. Sum=Sum+df;  
    45. elseif exp(-df/T)>rand(1)  
    46. S0=[S0(1:c1-1),S0(c2:-1:c1),S0(c2+1:102)];  
    47. Sum=Sum+df;  
    48. end  
    49. T=T*at;  
    50. if T<e  
    51. break;  
    52. end  
    53. end  
    54. % 输出巡航路径及路径长度  
    55. S0,Sum  

    展开全文
  • 模拟退火算法 matlab 模拟退火算法matlab实现 经调试 可实现
  • 详解模拟退火算法Matlab实现

    千次阅读 多人点赞 2019-06-25 13:30:50
      目录 模拟退火算法概述 ...模拟退火算法MATLAB实现 【例1】一元/多元函数优化 【例2】TSP问题 模拟退火算法概述 模拟退火算法(Simulated Annealing,简称SA)的思想最早是由Metropolis等提...

     

    目录

    模拟退火算法概述

    算法步骤

    算法特点

    模拟退火算法MATLAB实现

    【例1】一元/多元函数优化

    【例2】TSP问题


    模拟退火算法概述

    • 模拟退火算法(Simulated Annealing,简称SA)的思想最早是由Metropolis等提出的。其出发点是基于物理中固体物质的退火过程与一般的组合优化问题之间的相似性。模拟退火法是一种通用的优化算法,其物理退火过程由以下三部分组成:

      <ul><li>
      	<p>加温过程。其目的是增强粒子的热运动,使其偏离平衡位置。当温度足够高时,固体将熔为液体,从而消除系统原先存在的非均匀状态。</p>
      	</li>
      	<li>
      	<p>等温过程。对于与周围环境交换热量而温度不变的封闭系统,系统状态的自发变化总是朝自由能减少的方向进行的,当<span style="color:#f33b45;">自由能达到最小时,系统达到平衡状态</span>。</p>
      	</li>
      	<li>
      	<p>冷却过程。使粒子热运动减弱,系统能量下降,得到晶体结构。</p>
      	</li>
      </ul></li>
      <li>
      <p>加温过程相当于对算法<span style="color:#f33b45;">设定初值</span>,等温过程对应算法的<span style="color:#f33b45;">Metropolis抽样过程</span>,冷却过程对应<span style="color:#f33b45;">控制参数的下降</span>。这里能量的变化就是<span style="color:#f33b45;">目标函数</span>,我们要得到的<span style="color:#f33b45;">最优解就是能量最低态</span>。其中Metropolis准则是SA算法收敛于全局最优解的关键所在,Metropolis准则以一定的概率接受恶化解,这样就使算法跳离局部最优的陷阱。</p>
      </li>
      <li>
      <p>SA算法的Metropolis准则允许接受一定的恶化解,具体来讲,是<span style="color:#f33b45;">以一定概率来接受非最优解</span>。举个例子,相当于保留一些“潜力股”,使解空间里有更多的可能性。对比轮盘赌法,从概率论来讲,它是对非最优解给予概率0,即全部抛弃。</p>
      </li>
      <li>
      <p>模拟退火本身是求一个最小值问题,但可以转化为求最大值问题,只需要对目标函数加个负号或者取倒数。</p>
      </li>
      

    算法步骤

    1. 初始化:取初始温度T0足够大,令T = T0,任取初始解S1。

      对比GA、ACA、PSO之类的群优化算法,需要在解空间中产生多个个体,再继续寻优。而SA算法只需要一个点即可。
    2. 对当前温度T,重复第(3)~(6)步。

    3. 对当前解S1随机扰动产生一个新解S2。

      此处随机的扰动没有定义。结合实际例子做选择。
    4. 计算S2的增量df = f(S2) - f(S1),其中f(S1)为S1的代价函数

      代价函数相当于之前群优化算法中讲的适应度函数。
    5. 若df < 0,则接受S2作为新的当前解,即S1 = S2;否则,计算S2的接受概率exp(-df/T), T是温度。随机产生(0,1)区间上均匀分布的随机数rand,若exp(-df/T) > rand,也接受S2作为新的当前解S1 = S2,否则保留当前解S1。

      这是SA算法的核心部分,即有一定概率接受非最优解。
    6. 如果满足终止条件Stop,则输出当前解S1为最优解,结束程序,终止条件Stop通常取为在连续若干个Metropolis链中新解S2都没有被接受时终止算法或者是设定结束温度。否则按衰减函数衰减T后返回第(2)步,即被接受的新的解一直在产生,则我们要对问题进行降温,使得非最优解被接受的可能不断降低,结果愈发收敛于最优解。

    算法特点

    • 与遗传算法、粒子群优化算法和蚁群算法等不同,模拟退火算法不属于群优化算法,不需要初始化种群操作。

    • 收敛速度较慢。因为1)它初始温度一般设定得很高,而终止温度设定得低,这样才符合物体规律,认为物质处于最低能量平衡点;2)它接受恶化解,并不是全程都在收敛的过程中。这一点可以类比GA中的变异,使得它不是持续在收敛的,所以耗时更多一些。

    • 温度管理(起始、终止温度)、退火速度(衰减函数)等对寻优结果均有影响。比如T的衰减速度如果太快,就会导致可能寻找不到全局最优解。

    模拟退火算法MATLAB实现

    MATLAB自带模拟退火算法工具箱。在本文中,我们采用自带工具箱来解决函数优化的问题,再使用自己编写的程序来解决一个TSP问题。

    要使用自带的工具箱,我们先安装:

    【例1】一元/多元函数优化

    我们要找:

    一元函数:x = [1,2]范围内 y = sin(10*pi*x) / x 的极值

    二元函数:在x,y都是[-5,5]范围内找z = x.^2 + y.^2 - 10*cos(2*pi*x) - 10*cos(2*pi*y) + 20 的极值

    上面是我们提前获得的ground-truth(用main.m,代码在下文)。下面我们假装不知道这个结果的,用模拟退火方法来搜索:

    首先定义我们在SA算法中需要用到的代价函数fitness.m:

    function fitnessVal = fitness( x )
    
    %一元函数优化:
    
    fitnessVal = sin(10*pi*x) / x;  %求最小值
    
    % fitnessVal = -1 * sin(10*pi*x) / x; 用模拟退火求最大值,可以加个负号或者弄个倒数!
    
    %二元函数优化:
    
    % fitnessVal = -1 * (x(1)^2 + x(2).^2 - 10*cos(2*pi*x(1)) - 10*cos(2*pi*x(2)) + 20);
    
    end
    
    

    主程序main.m,用于我们直观看图先获得ground-truth:

    %% I. 清空环境变量
    clear all
    clc
    
    %% II. 一元函数优化
    x = 1:0.01:2;
    y = sin(10*pi*x) ./ x;
    figure
    plot(x,y,'linewidth',1.5)
    ylim([-1.5, 1.5])
    xlabel('x')
    ylabel('y')
    title('y = sin(10*pi*x) / x')
    hold on
    
    %%
    % 1. 标记出最大值点
    [maxVal,maxIndex] = max(y);
    plot(x(maxIndex), maxVal, 'r*','linewidth',2)
    text(x(maxIndex), maxVal, {['    X: ' num2str(x(maxIndex))];['    Y: ' num2str(maxVal)]})
    hold on
    
    %%
    % 2. 标记出最小值点
    [minVal,minIndex] = min(y);
    plot(x(minIndex), minVal, 'ks','linewidth',2)
    text(x(minIndex), minVal, {['    X: ' num2str(x(minIndex))];['    Y: ' num2str(minVal)]})
    
    %% III. 二元函数优化
    [x,y] = meshgrid(-5:0.1:5,-5:0.1:5);
    z = x.^2 + y.^2 - 10*cos(2*pi*x) - 10*cos(2*pi*y) + 20;
    figure
    mesh(x,y,z)
    hold on
    xlabel('x')
    ylabel('y')
    zlabel('z')
    title('z =  x^2 + y^2 - 10*cos(2*pi*x) - 10*cos(2*pi*y) + 20')
    
    %%
    % 1. 标记出最大值点
    maxVal = max(z(:));
    [maxIndexX,maxIndexY] = find(z == maxVal);
    for i = 1:length(maxIndexX)
        plot3(x(maxIndexX(i),maxIndexY(i)),y(maxIndexX(i),maxIndexY(i)), maxVal, 'r*','linewidth',2)
         text(x(maxIndexX(i),maxIndexY(i)),y(maxIndexX(i),maxIndexY(i)), maxVal, {['    X: ' num2str(x(maxIndexX(i),maxIndexY(i)))];['    Y: ' num2str(y(maxIndexX(i),maxIndexY(i)))];['    Z: ' num2str(maxVal)]})
        hold on
    end
    

    现在正式开始模拟退火算法环节。在MATLAB命令中输入:optimtool,打开工具箱。

    boltzmann就是对应Metropolis准则的退火方式。

    选择可视化的输出的项目:

    对于二元函数,在工具箱中的设置方法大同小异:记得先在fitness.m中修改我们的目标函数!

    运行后即可得到结果。

    【例2】TSP问题

    这里和上一篇讲蚁群算法的博文不同,我们的TSP中城市是自己虚拟的14座城市。

    main.m:

     %% I. 清空环境变量
    clear all
    clc
    
    %% II. 导入城市位置数据
    X = [16.4700   96.1000
         16.4700   94.4400
         20.0900   92.5400
         22.3900   93.3700
         25.2300   97.2400
         22.0000   96.0500
         20.4700   97.0200
         17.2000   96.2900
         16.3000   97.3800
         14.0500   98.1200
         16.5300   97.3800
         21.5200   95.5900
         19.4100   97.1300
         20.0900   92.5500];
    
    %% III. 计算距离矩阵
    D = Distance(X);  %计算距离矩阵
    N = size(D,1);    %城市的个数
    
    %% IV. 初始化参数
    T0 = 1e10;   % 初始温度,1010次方!需要设定一个很大的温度。
    Tend = 1e-30;  % 终止温度
    L = 2;    % 各温度下的迭代次数
    q = 0.9;    %降温速率
    Time = ceil(double(solve(num2str(T0) *(0.9)^x==num2str(Tend),x)));  % 计算迭代的次数
    % Time = 132;
    count = 0;        %迭代计数
    Obj = zeros(Time,1);         %目标值矩阵初始化
    track = zeros(Time,N);       %每代的最优路线矩阵初始化
    
    %% V. 随机产生一个初始路线
    S1 = randperm(N);
    DrawPath(S1,X)
    disp('初始种群中的一个随机值:')
    OutputPath(S1);
    Rlength = PathLength(D,S1);
    disp(['总距离:',num2str(Rlength)]);
    
    %% VI. 迭代优化
    while T0 > Tend
        count = count + 1;     %更新迭代次数
        temp = zeros(L,N+1);
        %%
        % 1. 产生新解
        S2 = NewAnswer(S1);
        %%
        % 2. Metropolis法则判断是否接受新解
        [S1,R] = Metropolis(S1,S2,D,T0);  %Metropolis 抽样算法
        %%
        % 3. 记录每次迭代过程的最优路线
        if count == 1 || R < Obj(count-1)
            Obj(count) = R;           %如果当前温度下最优路程小于上一路程则记录当前路程
        else
            Obj(count) = Obj(count-1);%如果当前温度下最优路程大于上一路程则记录上一路程
        end
        track(count,:) = S1;
        T0 = q * T0;     %降温
    end
    
    %% VII. 优化过程迭代图
    figure
    plot(1:count,Obj)
    xlabel('迭代次数')
    ylabel('距离')
    title('优化过程')
    
    %% VIII. 绘制最优路径图
    DrawPath(track(end,:),X)
    
    %% IX. 输出最优解的路线和总距离
    disp('最优解:')
    S = track(end,:);
    p = OutputPath(S);
    disp(['总距离:',num2str(PathLength(D,S))]);
    

    计算距离的函数Distance.m:

    function D = Distance(citys)
    %% 计算两两城市之间的距离
    % 输入 citys  各城市的位置坐标
    % 输出 D  两两城市之间的距离
    
    n = size(citys,1);
    D = zeros(n,n);
    for i = 1:n
        for j = i+1:n
            D(i,j) = sqrt(sum((citys(i,:) - citys(j,:)).^2));
            D(j,i) = D(i,j);
        end
    end
    

    画出路径的函数DrawPath.m:

    function DrawPath(Route,citys)
    %% 画路径函数
    %输入
    % Route  待画路径   
    % citys  各城市坐标位置
    
    figure
    plot([citys(Route,1);citys(Route(1),1)],...
         [citys(Route,2);citys(Route(1),2)],'o-');
    grid on
    
    for i = 1:size(citys,1)
        text(citys(i,1),citys(i,2),['   ' num2str(i)]);
    end
    
    text(citys(Route(1),1),citys(Route(1),2),'       起点');
    text(citys(Route(end),1),citys(Route(end),2),'       终点');
    

    输出路径函数OutputPath.m:

    function p = OutputPath(R)
    %% 输出路径函数
    % 输入:R 路径
    R = [R,R(1)];
    N = length(R);
    p = num2str(R(1));
    for i = 2:N
        p = [p,'―>',num2str(R(i))];
    end
    disp(p)

    PathLength.m:

    function Length = PathLength(D,Route)
    %% 计算各个体的路径长度
    % 输入:
    % D     两两城市之间的距离
    % Route 个体的轨迹
    
    Length = 0;
    n = size(Route,2);
    for i = 1:(n - 1)
        Length = Length + D(Route(i),Route(i + 1));
    end
    Length = Length + D(Route(n),Route(1));
    

    增加随机扰动产生新解NewAnswer.m:

    function Length = PathLength(D,Route)
    %% 计算各个体的路径长度
    % 输入:
    % D     两两城市之间的距离
    % Route 个体的轨迹
    
    Length = 0;
    n = size(Route,2);
    for i = 1:(n - 1)
        Length = Length + D(Route(i),Route(i + 1));
    end
    Length = Length + D(Route(n),Route(1));
    
    

    我们的做法是随机产生两个城市让他们交换位置,从而得到一个新的路径。当然,这只是这个问题的一个做法,也有其他“增加随机扰动”的做法,而且对于多元函数问题更加简单,只要在当前解的附近增加一些小的值即可。

    Metropolis准则的实现:

    function [S,R] = Metropolis(S1,S2,D,T)
    %% 输入
    % S1:  当前解
    % S2:   新解
    % D:    距离矩阵(两两城市的之间的距离)
    % T:    当前温度
    %% 输出
    % S:   下一个当前解
    % R:   下一个当前解的路线距离
    
    R1 = PathLength(D,S1);  %计算路线长度
    N = length(S1);         %得到城市的个数
    
    R2 = PathLength(D,S2);  %计算路线长度
    dC = R2 - R1;   %计算能力之差
    if dC < 0       %如果能力降低 接受新路线
        S = S2;
        R = R2;
    elseif exp(-dC/T) >= rand   %以exp(-dC/T)概率接受新路线
        S = S2;
        R = R2;
    else        %不接受新路线
        S = S1;
        R = R1;
    end

    程序结果:

     

    参考一个写得通俗易懂的: https://www.cnblogs.com/flashhu/p/8884132.html

    展开全文
  • 模拟退火算法Matlab实现

    千次阅读 2019-05-25 17:44:14
    模拟退火算法Matlab实现模拟退火算法Matlab实现目标函数选择两个个体交配二进制转十进制适应度函数是否交叉或变异交叉变异生成随机初等行变换的单位矩阵主函数 模拟退火算法Matlab实现 目标函数 function value=...

    瞎BB

    代码

    目标函数

    function value=targetfun(x)
    value=200*exp(-0.05*x).*sin(x);
    

    选择两个个体交配

    %select two individuals
    function seln=selection(population,cumsump)
    seln=zeros(1,2);
    for i=1:2
        r=rand;
        prand=cumsump-r;
        j=1;
        %stop when cumsump>r
        while prand(j)<0
            j=j+1;
        end
        seln(i)=j;
    end
    

    二进制转十进制

    function x=transform2to10(population)
    BitLength=size(population,2);
    x=population(BitLength);
    for i=1:BitLength-1
        x=x+population(BitLength-i)*power(2,i);
    end
    

    适应度函数

    function [fitvalue,cumsump]=fitness(population)
    global BitLength
    global boundsbegin
    global boundsend
    popsize=size(population,1);
    cumsump=zeros(1,popsize);
    fitvalue=zeros(1,popsize);
    for i=1:popsize
        x=transform2to10(population(i,:));
        %tansform to range of variable
        xx=boundsbegin+x.*(boundsend-boundsbegin)./(power((boundsend),BitLength)-1);
        fitvalue(i)=targetfun(xx);
    end
    %ensure fitvalue>0
    fitvalue=fitvalue'+230;
    fsum=sum(fitvalue);
    Pperpopulation=fitvalue/fsum;
    cumsump(1)=Pperpopulation(1);
    for i=2:popsize
        cumsump(i)=cumsump(i-1)+Pperpopulation(i);
    end
    cumsump=cumsump';
    

    是否交叉或变异

    function pcc=IfCroIfMut(cro_or_mut)
    test(1:100)=0;
    l=ceil(rand()*cro_or_mut);
    test(1:l)=1;
    n=ceil(rand*100);
    pcc=test(n);
    

    交叉

    function scro=crossover(population,seln,pc)
    %seln:two individuals
    BitLength=size(population,2);
    pcc=IfCroIfMut(pc);
    if pcc==1
        %generate a random position
        chb=round(rand*(BitLength-2))+1;
        %crossover
        scro(1,:)=[population(seln(1),1:chb) population(seln(2),chb+1:BitLength)];
        scro(2,:)=[population(seln(2),1:chb) population(seln(1),chb+1:BitLength)];
    else
        scro(1,:)=population(seln(1),:);
        scro(2,:)=population(seln(2),:);
    end
    

    变异

    function snnew=mutation(snew,pmutation)
    BitLength=size(snew,2);
    snnew=snew;
    pmm=IfCroIfMut(pmutation);
    if pmm==1
        %generate a random position
        chb=round(rand*(BitLength-1))+1;
        %0to1 or 1to0
        snnew(chb)=abs(snew(chb)-1);
    end
    

    生成随机初等行变换的单位矩阵

    function f=generate_random_eye(a)
    n=size(a);
    c1=ceil(rand*n);
    c2=ceil(rand*n);
    for i=1:20
        while c1==c2
            c1=ceil(rand*n);
            c2=ceil(rand*n);
        end
        temp=a(c1,:);
        a(c1,:)=a(c2,:);
        a(c2,:)=temp;
    end
    f=a;
    

    主函数

    %max goal function value
    clc,clear
    global BitLength
    global boundsbegin
    global boundsend
    cro_mut_rate=0.01;
    %range of variable
    bounds=[-2 2];
    %begin of variable
    boundsbegin=bounds(:,1);
    %end of variable
    boundsend=bounds(:,2);
    precision=0.0001;
    %calc the BitLength
    BitLength=ceil(log2((boundsend-boundsbegin)'./precision));
    
    %init
    popsize=50;
    Generationmax=100;
    pcro=0.9;
    pmut=0.09;
    ymax=zeros(1,Generationmax+1);
    ymean=zeros(1,Generationmax+1);
    xmax=zeros(1,Generationmax+1);
    %generate random population
    population=round(rand(popsize,BitLength));
    %calc fitness return fitvalue and sum of probability
    [fitvalue,cumsump]=fitness(population);
    
    %main code
    Generation=1;
    tic
    while Generation<Generationmax+1
        for j=1:2:popsize
            %select twoindividual
            seln=selection(population,cumsump);
            %crossover
            scro=crossover(population,seln,pcro);
            scnew(j,:)=scro(1,:);
            scnew(j+1,:)=scro(2,:);
            %mutation
            smnew(j,:)=mutation(scnew(j,:),pmut);
            smnew(j+1,:)=mutation(scnew(j+1,:),pmut);
        end
        population=smnew;
        [fitvalue,cumsump]=fitness(population);
        [fmax,nmax]=max(fitvalue);
        fmean=mean(fitvalue);
        ymax(Generation)=fmax;
        ymean(Generation)=fmean;
        x=transform2to10(population(nmax,:));
        xx=boundsbegin+x.*(boundsend-boundsbegin)./(power((boundsend),BitLength)-1);
        xmax(Generation)=xx;
        Generation=Generation+1;
    end
    toc
    %Generation=Generation-1;
    Bestpopulation=xx;
    BestValue=targetfun(xx);
    
    %figure
    figure(1);
    hand1=plot(1:Generation,ymax);
    set(hand1,'linestyle','-','linewidth',1.8,'marker','*','markersize',6);
    hold on;
    hand2=plot(1:Generation,ymean);
    set(hand2,'color','r','linestyle','-','linewidth',1.8,'marker','h','markersize',6);
    %hold on;
    xlabel('Generation');ylabel('max/mean');xlim([1 Generationmax]);
    legend('fitness_max','fitness_mean');
    box off;hold off;
    
    展开全文
  • - PAGE PAGE 1 欢迎下载 MCM战备历程3模拟退火算法Matlab源程序For glory? 2007-02-03 11:20:04|?分类? \o "数学建模" 数学建模?|?标签 学习?|字号?订阅 %模拟退火算法程序 T_max=input'please input the start ...
  • 示例代码:实现模拟退火算法以优化凹凸函数参数 此代码是为 2015 年 12 月在 UTIAS 的 AER501(高级结构力学)作业开发的。 该代码由 5 个脚本组成,这些脚本使用模拟退火算法确定 2D 凹凸函数的最小值。 模拟退火...
  • 运用模拟退火算法解决十个城市间的tsp问题。已知十个城市的坐标,通过模拟退火算法,计算寻找通过十个城市的最优路径。
  • 模拟退火算法 matlab实现 一个旅行商想去某些城镇售货,最后再回到出发地,各个城镇之间的路程是已知的。问该如何安排这个旅行商的旅行路线,才能使得他经过每个城镇恰好一次并且总路程最短。旅行商问题就是要求在一...
  • 多目标优化问题中常用的模拟退火算法anneal基于MATLAB实现代码。
  • 模拟退火算法来源于固体退火原理,是一种基于概率的算法,将固体加温至充分高,再让其徐徐冷却,加温时,固体内部粒子随温升变为无序状,内能增大,而徐徐冷却时粒子渐趋有序,在每个温度都达到平衡态,最后在常温时...
  • 模拟神经算法matlab代码计算物理示例代码 关键词: 蒙特卡罗方法 复杂网络 约束优化 王兰道采样 模拟退火 编程语言 C C++ Python MATLAB 这个存储库包含一些示例代码,用于我在计算研究方面的研究。 所有代码都是...
  • 多目标优化算法之模拟退火算法(sim_anneal)MATLAB实现代码。
  • 模拟退火算法matlab求函数最大值实例 模拟退火算法的思路基本上是: 1.粒子按照不同的概率在不同的方向漂移(随机运动) 2.向目标点漂移的概率更大(趋向于能量低的点) 3.随着时间的推移粒子每次漂移的步长变短...

    模拟退火算法matlab求函数最大值实例

    模拟退火算法的思路基本上是:

    1.粒子按照不同的概率在不同的方向漂移(随机运动)

    2.向目标点漂移的概率更大(趋向于能量低的点)

    3.随着时间的推移粒子每次漂移的步长变短(温度降低)


    这里粒子的速度采用正态分布,正态分布的速度的平均值与温度成正比

    粒子运动方向随机,+-方向运动概率为0.5


    %模拟退火算法实现搜索函数最大值
    %Anneal.m
    N=20;%粒子数量
    temp=20;%初始温度
    T=200;%迭代次数
    k=0.1;%温度位移系数
    kt=0.05;%温度概率系数
    de=0.99;%温度降低速率
    minx=0;
    maxx=10;%区间
    location=10*rand(1,N);%粒子初始位置
    present_value=equation(location);%粒子当前解
    %---------------------------
    for t=1:T
        %
        dx_av=k*temp;%当前温度下粒子平均移动距离
        probability=exp(-1/(kt*temp));
        disp(probability);
        temp=temp*de;%温度变化
        for p=1:N
            dx=0.5*dx_av*randn+dx_av;%以平均移动距离为中心正态分布,
            if rand>0.5    %0.5的概率为-
                dx=-dx;
            end
            local=location(p)+dx;
            if (local<maxx)&&(local>minx)%判断是否越界
                local_value=equation(local);
                if local_value>present_value(p)
                    location(p)=local;
                    present_value(p)=local_value;
                else if rand<probability
                        location(p)=local;
                        present_value(p)=local_value;   
                    end
                    
                end
            end
        end
    end


    x=minx:0.01:maxx;
    y=equation(x);
    plot(x,y);
    hold on;
    plot(location, present_value,'*');
    disp(location);

    被搜寻的函数如下·

    function y=equation(x)
    y=10*cos(0.4*pi*x).*sin(0.1*pi*x);
    end


    展开全文
  • 模拟退火算法解决TSP问题的很好的例子,有MATLAB程序
  • 模拟退火算法Matlab程序,附相关英文文献,分享
  • 挺不错的matlab程序,适用于初学遗传模拟算法和退火算法的学生练习
  • % maxpop 给定群体规模 % pop 群体 % newpop 种群 %t0 初始温度 function [codmin,finmin]=fc0(cc,v0,t0) N=length(cc(1; %定群体规模 if N>50 maxpop=2*N-20; end if N*N; end %产生初始群体 pop=zeros(maxpop,N;...
  • 有相关源码 介绍基于模拟退火算法的多主体模型及其应用
  • 模拟退火算法MATLAB实现程序

    热门讨论 2009-07-07 12:19:12
    模拟退火算法作为计算机、控制领域广泛应用的方法之一,价值很大,而这个MATLAB软件程序可以实现算法的功能,省却比较繁杂的具体编程工作。

空空如也

空空如也

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

模拟退火算法matlab

matlab 订阅