优化算法——模拟退火算法

• 模拟退火算法原理
• 模拟退火算法
  • 模拟退火算法过程
  • 模拟退火算法流程
• 模拟退火算法的Java实现
  • Java代码
  • 最后的结果

模拟退火算法原理

爬山法是一种贪婪的方法，对于一个优化问题，其大致图像(图像地址)如下图所示： 
 
其目标是要找到函数的最大值，若初始化时，初始点的位置在C处，则会寻找到附近的局部最大值A点处，由于A点出是一个局部最大值点，故对于爬山法来讲，该算法无法跳出局部最大值点。若初始点选择在D处，根据爬山法，则会找到全部最大值点B。这一点也说明了这样基于贪婪的爬山法是否能够取得全局最优解与初始值的选取由很大的关系。

模拟退火算法(Simulated Annealing, SA)的思想借鉴于固体的退火原理，当固体的温度很高的时候，内能比较大，固体的内部粒子处于快速无序运动，当温度慢慢降低的过程中，固体的内能减小，粒子的慢慢趋于有序，最终，当固体处于常温时，内能达到最小，此时，粒子最为稳定。模拟退火算法便是基于这样的原理设计而成。

模拟退火算法从某一较高的温度出发，这个温度称为初始温度，伴随着温度参数的不断下降，算法中的解趋于稳定，但是，可能这样的稳定解是一个局部最优解，此时，模拟退火算法中会以一定的概率跳出这样的局部最优解，以寻找目标函数的全局最优解。如上图中所示，若此时寻找到了A点处的解，模拟退火算法会以一定的概率跳出这个解，如跳到了D点重新寻找，这样在一定程度上增加了寻找到全局最优解的可能性。

模拟退火算法

模拟退火算法过程

(1)随机挑选一个单元k，并给它一个随机的位移，求出系统因此而产生的能量变化ΔEk。 
(2)若ΔEk⩽0，该位移可采纳，而变化后的系统状态可作为下次变化的起点； 
若ΔEk>0，位移后的状态可采纳的概率为 

Pk=11+e−ΔEk/T

式中T为温度，然后从(0,1)区间均匀分布的随机数中挑选一个数R，若R<Pk，则将变化后的状态作为下次的起点；否则，将变化前的状态作为下次的起点。 
(3)转第(1)步继续执行，知道达到平衡状态为止。

模拟退火算法流程

模拟退火算法的Java实现

求解函数最小值问题： 

F(x)=6x7+8x6+7x3+5x2−xy

其中，0≤x≤100，输入任意y值，求F(x)的最小值。

Java代码

package sa;/** * 实现模拟退火算法 * @author zzy *Email:[e-mail] */public class SATest {    public static final int T = 100;// 初始化温度    public static final double Tmin = 1e-8;// 温度的下界    public static final int k = 100;// 迭代的次数，针对100个初始解进行迭代    public static final double delta = 0.98;// 温度的下降率    public static double getX() {        return Math.random() * 100;    }    /**     * 求得函数的值     *      * @param x目标函数中的一个参数     * @param y目标函数中的另一个参数     * @return函数值     */    public static double getFuncResult(double x, double y) {        double result = 6 * Math.pow(x, 7) + 8 * Math.pow(x, 6) + 7                * Math.pow(x, 3) + 5 * Math.pow(x, 2) - x * y;        return result;    }    /**     * 模拟退火算法的过程     * @param y目标函数中的一个参数     * @return最优解     */    public static double getSA(double y) {        double result = Double.MAX_VALUE;// 初始化最终的结果        double t = T;        double x[] = new double[k];        // 初始化初始解        for (int i = 0; i < k; i++) {            x[i] = getX();        }        // 迭代的过程        while (t > Tmin) {            for (int i = 0; i < k; i++) {                // 计算此时的函数结果                double funTmp = getFuncResult(x[i], y);                // 在邻域内产生新的解                double x_new = x[i] + (Math.random() * 2 - 1) * t;                // 判断新的x不能超出界                if (x_new >= 0 && x_new <= 100) {                    double funTmp_new = getFuncResult(x_new, y);                    if (funTmp_new - funTmp < 0) {                        // 替换                        x[i] = x_new;                    } else {                        // 以概率替换                        double p = 1 / (1 + Math                                .exp(-(funTmp_new - funTmp) / T));                        if (Math.random() < p) {                            x[i] = x_new;                        }                    }                }            }            t = t * delta;//缓慢降低温度 ，重置迭代次数        }        for (int i = 0; i < k; i++) {            result = Math.min(result, getFuncResult(x[i], y));        }        return result;    }    public static void main(String args[]) {        // 设置y的值        int y = 0;        System.out.println("最优解为：" + getSA(y));    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

最后的结果

最优解为：1.733360963664572E-16，多次运行结果不同，因为其中包含了随机的选择的过程。