模拟退火算法python

❶ 模拟退火算法解决路径优化 的源代码

我有 simulated annealing with metropolies(Monte Carlo)做的一个项目的代码，你要看看么？
void anneal(int nparam, int nstep, int nstep_per_block, double t0,

const double * param_in,

double cost_in, double * params_out, double * cost_out) {

int nblock;

int step;

int block;

int nactive;

int rank;

int n_accepted = 0;

int i, j, n;

double cost_current, cost_trial;

int * param_index;

double * param_current;

double * param_trial;

double * Q;

double * S;

double * u;

double * dp;

double * A;

FILE * fp_log_file;

char fname[FILENAME_MAX];

double temp = t0;

double tempmax = temp;

double ebar, evar, emin, eta, specific_heat;

double delta;

double chi = 0.8; // Annealing schele

double chi_s = 3.0; // Vanderbilt/Louie 'growth factor'

double rm;

double root3 = sqrt(3.0);

double p = 0.02/sqrt(3.0); //max size of annealing step

param_current = new double[nparam];

param_trial = new double[nparam];

cost_current = cost_in;

MPI_Comm_rank(MPI_COMM_WORLD, &rank);

sprintf(fname, "a_%4.4d.log", rank);

fp_log_file = fopen(fname, "a");

if (fp_log_file == (FILE *) NULL) errorMessage("fopen(log) failed\n");

// Work out the number of active parameters, and set up the

// index table of the active parameters.

// Note that the complete array of parameters (param_trial) must

// be used to evaluate the cost function.

nactive = 0;

for (n = 0; n < nparam; n++) {

param_current[n] = param_in[n];

param_trial[n] = param_in[n];

if (P.is_active[n]) nactive++;

}

param_index = new int[nactive];

i = 0;

for (n = 0; n < nparam; n++) {

if (P.is_active[n]) param_index[i++] = n;

}

// Initialise the step distribution matrix Q_ij

Q = new double[nactive*nactive];

S = new double[nactive*nactive];

u = new double[nactive];

dp = new double[nactive];

A = new double[nactive];

double * Qtmp;

Qtmp = new double[nactive*nactive];

for (i = 0; i < nactive; i++) {

for (j = 0; j < nactive; j++) {

delta = (i == j);

Q[i*nactive + j] = p*delta*param_current[param_index[j]];

}

}

// carry out annealing points

nblock = nstep/nstep_per_block;

rm = 1.0/(double) nstep_per_block;

for (block = 0; block < nblock; block++) {

// Set the schele for this block, and initialise blockwise quantities.

// We also ensure the step distribution matrix is diagonal.

temp = chi*temp;

for (i = 0; i < nactive; i++) {

A[i] = 0.0;

for (j = 0; j < nactive; j++) {

S[i*nactive + j] = 0.0;

delta = (i == j);

Q[i*nactive + j] *= delta;

}

}

ebar = 0.0;

evar = 0.0;

emin = cost_current;

for (i = 0; i < nactive; i++) {

printf("Step: %d %g\n", i, Q[i*nactive + i]);

}

for (step = 0; step < nstep_per_block; step++) {

// Set the random vector u, and compute the step size dp

for (i = 0; i < nactive; i++) {

u[i] = root3*(r_uniform()*2.0 - 1.0);

}

for (i = 0; i < nactive; i++) {

dp[i] = 0.0;

for (j = 0; j < nactive; j++) {

dp[i] += Q[i*nactive + j]*u[j];

}

}

for (i = 0; i < nactive; i++) {

n = param_index[i];

param_trial[n] = param_current[n] + dp[i];

if (param_trial[n] < P.min[n]) param_trial[n] = P.min[n];

if (param_trial[n] > P.max[n]) param_trial[n] = P.max[n];

}

// calculate new cost function score

p_model->setParameters(param_trial);

cost_trial = p_costWild->getCost();

cost_trial += p_costLHY->getCost();

cost_trial += p_costTOC1->getCost();

cost_trial += p_costAPRR->getCost();

// Metropolis

delta = cost_trial - cost_current;

if (delta < 0.0 || r_uniform() < exp(-delta/temp)) {

for (n = 0; n < nparam; n++) {

param_current[n] = param_trial[n];

}

cost_current = cost_trial;

++n_accepted;

}

// 'Energy' statistics

ebar += cost_current;

evar += cost_current*cost_current;

if (cost_current < emin) emin = cost_current;

// Per time step log

fprintf(fp_log_file, "%6d %6d %10.4f %10.4f %10.4f %10.4f\n",

block, step, temp,

cost_current, cost_trial,

(float) n_accepted / (float) (block*nstep_per_block + step));

// Accumulate average, measured covariance

for (i = 0; i < nactive; i++) {

A[i] += param_current[param_index[i]];

for (j = 0; j < nactive; j++) {

S[i*nactive + j]

+= param_current[param_index[i]]*param_current[param_index[j]];

}

}

/* Next step*/

}

// Set the previous block average and measured covariance

for (i = 0; i < nactive; i++) {

A[i] = rm*A[i];

}

for (i = 0; i < nactive; i++) {

for (j = 0; j < nactive; j++) {

S[i*nactive + j] = rm*S[i*nactive + j] - A[i]*A[j];

if (i == j) printf("Average: %d %g %g\n", i, A[i], S[i*nactive+j]);

// Set the convarience for the next iteration s = 6 chi_s S / M

S[i*nactive + j] = 6.0*chi_s*rm*S[i*nactive + j];

}

}

// Reset the step distribution matrix for the next block

i = do_cholesky(nactive, S, Q);

j = test_cholesky(nactive, S, Q);

printf("Cholesky %d %d\n", i, j);

// Block statistics

ebar = rm*ebar;

evar = rm*evar;

specific_heat = (evar - ebar*ebar) / temp*temp;

eta = (ebar - emin)/ebar;

fprintf(fp_log_file, "%d %d %f %f %f %f %f %f\n",

block, nstep_per_block, temp, ebar, evar, emin,

specific_heat, eta);

/* Next block */

}

*cost_out = cost_current;

for (n = 0; n < nparam; n++) {

params_out[n] = param_current[n];

}

fclose(fp_log_file);

delete param_index;

delete param_current;

delete param_trial;

delete Q;

delete u;

delete dp;

delete S;

delete A;

return;

}

❷ 模拟退火算法的意义

退火算法具有计算过程简单、通用、鲁棒性强、适合并行处理等优点，可用于求解复杂的非线性优化问题。缺点: 收敛速度慢，执行时间长，算法性能与初值有关，参数敏感。Pso: 进化支持计算的优点在于它能处理一些传统方法无法处理的例子，如不可微节点传递函数或其固有的梯度信息缺失。缺点是: 它在某些问题上表现不是特别好。图2。网络权重容量的编码和遗传算子的选择有时比较麻烦

❸ 模拟退火法^[1，]

模拟退火算法最早在1953年由 Metropolis等人提出。在地球物理中的最早应用是Rothman在1983年利用模拟退火算法处理地震资料的剩余静校正。模拟退火法也是类似于蒙特卡洛法的随机搜索方法。但是在产生模型的过程中引入一些规则，能有效地加快搜索速度，有时又称这类方法为启发式蒙特卡洛法。

模拟退火法概念源于统计物理学，是模拟固体熔化状态逐渐缓慢冷却最终达到能量最小的结晶状态的物理过程。对于一个熔化的金属，当处于某个温度的热平衡状态时，它的每一个分子都有它可能所处的状态，有些分子可能能量高一些，有些分子可能能量低一些，分子处于何种状态的概率由分子所具有的能量决定。设分子所有可能的能级总数为n(微观粒子的能量都是量子化的，不连续的)，则分子处于某种状态的概率满足玻尔兹曼概率分布:

地球物理反演教程

其中:Ei为第i个分子的能量;K为玻尔兹曼常数;T为绝对温度;n为分子所有可能的能级总数，分母称为配分因子;p_i为第i个分子处于能量E_i的概率。

如果把地球物理反演的模型向量看作分子，把目标函数看作分子的能量，把目标函数的极小值看成分子冷却结晶的最小能量，反演问题(最优化问题)可以模拟式(8.11)金属退火的过程，通过缓慢地减小温度进行反演，使目标函数(能量)逐渐达到极小值，这时所对应的模型(分子状态)就是反演结果。

为了改善于蒙特卡洛法的随机搜索方法，1953年 Metropolis等人在产生模型的过程中引入Metropolis接受准则，模型产生并不是完全随机，而是以前一个模型为基础随机产生。对能量减小的模型完全接受，对能量增加的模型按一定的概率接受，这样能有效地加快搜索速度，同时又有可能跳出局部极小值。具体如下:

设原来模型向量为m_i，新的模型为m_i+1(在m_i基础上随机修改产生)，各自的能量(目标函数)为E(m_i)和E(m_i+1)。如果E(m_i+1)＜E(m_i)，则目标函数在减小，新模型可以接受。如果E(m_i+1)＞E(m_i)，则目标函数在增加，按照一定概率来确定是否接受新的模型。具体规则见式(8.12):

E(m_i+1)＜E(m_i) 完全接受m_i+1为新模型

地球物理反演教程

式(8.12)就是Metropolis接受准则。它使得反演过程可以接受使目标函数增加的模型，因此也就使得模拟退火法有可能跳出局部极小，收敛于全局极小值点。由于玻尔兹曼常数K只是起到尺度因子的作用，在实际计算中K可取为1来简化公式。从式(8.12)可以看出，当温度较低时，p_i+1/p_i较小，因此接受使能量增加的新模型的可能性较小。而一般温度较低时，目标函数较小，模型比较靠近真实模型，这时基本上只接受使目标函数减小的模型，使模型尽快收敛于极小值点。

在模拟退火反演中，要求温度T随着迭代次数的增加而缓慢降温。常用的温度函数有两种。

(1)指数下降型:

T_k=T₀·exp(-ck^1/N) (8.13)

式中:k为迭代次数;c为衰减因子;N为模型参数的个数;T₀为初始温度。上式也可以改写为

地球物理反演教程

通常选择0.7≤α≤1。在实际应用中可采用0.5或1代替式(8.14)的1/N。图8.4(a)为指数降温曲线。采用参数为:T₀=200℃，α=0.99，1/N=0.9。

(2)双曲线下降型:

T=T₀α^k (8.15)

式中:T₀为初始温度;k为迭代次数;α为衰减因子，通常取0.99。初始温度T₀不能取得太高，否则增加计算时间浪费机时;T₀也不能太低，否则模型选取不能遍及整个模型空间，只是在初始模型附近选取，不能进行全局寻优。所以T₀的确定只有通过实验计算得到。图8.4(b)为双曲线降温曲线。采用参数为:T₀=200℃，α=0.99。从图8.4可以看出通过对不同温度曲线和相关参数进行选择，可以控制温度下降的方式和速度。

图8.4 模拟退火法降温曲线

模拟退火法主要有三种:

(1)MSA算法(Metropolis Simulated Annealing);

(2)HBSA算法(Heat Bath Simulated Annealing);

(3)VFSA算法(Very Fast Simulated Annealing)。

图8.5 模拟退火MSA算法程序流程图

前面介绍的利用 Metropolis接受准则的算法就是经典的模拟退火法。图8.5为模拟退火 MSA算法的程序流程图。从中可以看出 MSA算法有一套模型修改准则，依次改变模型参数，每次改变都是在原来模型基础上改变一个参数，因此容易保持已有搜索成果，持续不断地向目标函数最小值点接近，因此搜索效率比蒙特卡洛法高。此外，MSA算法允许接受使目标函数增加的模型，这样又易于跳出局部极小，达到全局极小。但 MSA算法在任何温度下和蒙特卡洛法一样都是在模型全空间进行搜索，不能根据当前温度和模型减小搜索空间，此外由于模型的修改全凭运气，所以不可能像前面介绍的最小二乘法那样目标函数基本上持续减小，而是呈不规则振荡在宏观上逐渐减小，因此效率较低。

HBSA算法与 MSA算法的不同之处是在模型的修改上。也是首先随机选择一个初始M维模型向量m₀(它具有M个参数);然后限制各个模型参数可能的取值范围，对取值离散化。假设每个模型参数都有N个可能的值，首先固定模型第2个参数m₀(2)直到第M个参数m₀(M)保持不变，只修改第1个参数m₀(1);计算m₀(1)的所有取值时的目标函数，然后按式(8.16)计算“概率”，它就是式(8.11)配分因子取1的公式。即

地球物理反演教程

选择“概率”最大的为模型第1个参数的修改值。照此依次对所有模型参数进行修改完成依次迭代计算。在每次迭代计算中保持温度不变。随着迭代次数增加，温度降低，最终达到稳定状态，获得最小能量解。这种方法的计算由于要计算某个参数的所有可能值，所以计算量也是很大的。

1989年Ingber提出了VFSA算法，由于速度较快，最为常用。它使得模拟退火法从理论走向了实际应用。VFSA算法在流程上与传统的模拟退火法相同，但是在模型修改、接受概率以及降温曲线上有所改进。

(1)模型修改:常规模拟退火法采用高斯随机分布修改模型，在任何温度下都是在模型全空间进行搜索。而Ingber提出采用依赖于温度的似cauchy分布产生新的模型。即

地球物理反演教程

y_i=Tsgn(u-0.5)[(1+1/T^|2u-1|-1](8.18)

其中:m_i为当前模型第i个参数，m'_i为修改后的模型参数;u为[0，1]的随机数;[A_i，B_i]为m_i和m'_i的取值范围;sgn( )为符号函数。

采用以上方式能在高温下进行大范围的搜索，低温时在当前模型附近搜索，而且由于似cauchy分布具有平坦的“尾巴”，使其易于迅速跳出局部极值。这一改进大大加快了模拟退火法的收敛速度。

(2)接收概率:当E(m_i+1)＞E(m_i)时，VFSA算法采用如下概率接受公式:

地球物理反演教程

上式当h→1时变为式(8.12)。h通过实验获得。

(3)降温曲线(退火计划):Ingber在1989年采用式(8.13)得出指数降温曲线。从图8.4可知，温度下降较快。

总之，VFSA算法在模型修改、接受概率以及降温曲线上的改进使得模拟退火算法收敛速度大大加快。后人在此基础上还有很多的改进，读者可以参考相关文献。

模拟退火法的优点:由于不需要计算偏导数矩阵，不需要解线性方程组(当然正演计算的除外)，结构简单，易于编程;此外，由于它搜索范围大，能接受较差模型，因此易于达到全局极小。缺点:随机搜索，计算量巨大，往往要计算成百上千次正演，这与前面的最小二乘法十几次的正演计算相比反演时间太长，因此一般应用在一维反演之中，在二维、三维等高维反演中应用较少。

❹ 模拟退火算法解决VRP问题

像这种随机算法，一般都要调试好长时间，不断地修改参数等，才能最终得到满意解。

❺ 模拟退火算法的模拟退火算法的原理

模拟退火算法来源于固体退火原理，将固体加温至充分高，再让其徐徐冷却，加温时，固体内部粒子随温升变为无序状，内能增大，而徐徐冷却时粒子渐趋有序，在每个温度都达到平衡态，最后在常温时达到基态，内能减为最小。根据Metropolis准则，粒子在温度T时趋于平衡的概率为e(-ΔE/(kT))，其中E为温度T时的内能，ΔE为其改变量，k为Boltzmann常数。用固体退火模拟组合优化问题，将内能E模拟为目标函数值f，温度T演化成控制参数t，即得到解组合优化问题的模拟退火算法：由初始解i和控制参数初值t开始，对当前解重复“产生新解→计算目标函数差→接受或舍弃”的迭代，并逐步衰减t值，算法终止时的当前解即为所得近似最优解，这是基于蒙特卡罗迭代求解法的一种启发式随机搜索过程。退火过程由冷却进度表(Cooling Schele)控制，包括控制参数的初值t及其衰减因子Δt、每个t值时的迭代次数L和停止条件S。 1模拟退火算法可以分解为解空间、目标函数和初始解三部分。
2模拟退火的基本思想:
(1) 初始化：初始温度T(充分大)，初始解状态S(是算法迭代的起点)，每个T值的迭代次数L
(2) 对k=1，……，L做第(3)至第6步：
(3) 产生新解S′
(4) 计算增量Δt′=C(S′)-C(S)，其中C(S)为评价函数
(5) 若Δt′<0则接受S′作为新的当前解，否则以概率exp(-Δt′/T)接受S′作为新的当前解.
(6) 如果满足终止条件则输出当前解作为最优解，结束程序。
终止条件通常取为连续若干个新解都没有被接受时终止算法。
(7) T逐渐减少，且T->0，然后转第2步。 模拟退火算法新解的产生和接受可分为如下四个步骤：
第一步是由一个产生函数从当前解产生一个位于解空间的新解；为便于后续的计算和接受，减少算法耗时，通常选择由当前新解经过简单地变换即可产生新解的方法，如对构成新解的全部或部分元素进行置换、互换等，注意到产生新解的变换方法决定了当前新解的邻域结构，因而对冷却进度表的选取有一定的影响。
第二步是计算与新解所对应的目标函数差。因为目标函数差仅由变换部分产生，所以目标函数差的计算最好按增量计算。事实表明，对大多数应用而言，这是计算目标函数差的最快方法。
第三步是判断新解是否被接受,判断的依据是一个接受准则，最常用的接受准则是Metropolis准则: 若Δt′<0则接受S′作为新的当前解S，否则以概率exp(-Δt′/T)接受S′作为新的当前解S。
第四步是当新解被确定接受时，用新解代替当前解，这只需将当前解中对应于产生新解时的变换部分予以实现，同时修正目标函数值即可。此时，当前解实现了一次迭代。可在此基础上开始下一轮试验。而当新解被判定为舍弃时，则在原当前解的基础上继续下一轮试验。
模拟退火算法与初始值无关，算法求得的解与初始解状态S(是算法迭代的起点)无关；模拟退火算法具有渐近收敛性，已在理论上被证明是一种以概率l 收敛于全局最优解的全局优化算法；模拟退火算法具有并行性。 s:=s0;e:=E(s)//设定目前状态为s0，其能量E(s0)k:=0//评估次数kwhilek<kmaxande>emax//若还有时间（评估次数k还不到kmax）且结果还不够好（能量e不够低）则：sn:=neighbour(s)//随机选取一临近状态snen:=Esn)//sn的能量为E(sn)ifrandom()<P(e,en,temp(k/kmax))then//决定是否移至临近状态sns:=sn;e:=en//移至临近状态snk:=k+1//评估完成，次数k加一returns//回转状态s

❻ 谁能给我举一个模拟退火算法MATLAB源代码的简单例子

clear
clc
a = 0.95
k = [5;10;13;4;3;11;13;10;8;16;7;4];
k = -k; % 模拟退火算法是求解最小值，故取负数
d = [2;5;18;3;2;5;10;4;11;7;14;6];
restriction = 46;
num = 12;
sol_new = ones(1,num); % 生成初始解
E_current = inf;E_best = inf;
% E_current是当前解对应的目标函数值（即背包中物品总价值）；
% E_new是新解的目标函数值；
% E_best是最优解的
sol_current = sol_new; sol_best = sol_new;
t0=97; tf=3; t=t0;
p=1;

while t>=tf
for r=1:100
%产生随机扰动
tmp=ceil(rand.*num);
sol_new(1,tmp)=~sol_new(1,tmp);

%检查是否满足约束
while 1
q=(sol_new*d <= restriction);
if ~q
p=~p; %实现交错着逆转头尾的第一个1
tmp=find(sol_new==1);
if p
sol_new(1,tmp)=0;
else
sol_new(1,tmp(end))=0;
end
else
break
end
end

% 计算背包中的物品价值
E_new=sol_new*k;
if E_new<E_current
E_current=E_new;
sol_current=sol_new;
if E_new<E_best
% 把冷却过程中最好的解保存下来
E_best=E_new;
sol_best=sol_new;
end
else
if rand<exp(-(E_new-E_current)./t)
E_current=E_new;
sol_current=sol_new;
else
sol_new=sol_current;
end
end
end
t=t.*a;
end

disp('最优解为：')
sol_best
disp('物品总价值等于：')
val=-E_best;
disp(val)
disp('背包中物品重量是：')
disp(sol_best * d)

❼ 请问一下遗传算法，模拟退火算法和遗传模拟退火算法的区别，最好能有根据同一个数学问题的matalb程序源代

遗传算法是种群择优，模拟退火是择优降火，里头的差别不大，就是生成新链，然后计算适应度什么的。这两种优化算法都能解决TSP问题，源代码没有，不过matlab有工具箱可以实现吧，你再找找。

❽ 模拟退火算法是什么

从代码角度来说，就是2个循环，一个总温度外循环（足够大，并逐渐减小），另一个内部循环（使其达到该特定温度下的平衡，怎么算平衡自己定义的）。很多书都说外部的总温度外循环，却忽略了内部循环，内部循环值应该多大，我也很模糊。

❾ Python怎么做最优化

一、概观
scipy中的optimize子包中提供了常用的最优化算法函数实现。我们可以直接调用这些函数完成我们的优化问题。optimize中函数最典型的特点就是能够从函数名称上看出是使用了什么算法。下面optimize包中函数的概览：
1.非线性最优化
fmin -- 简单Nelder-Mead算法
fmin_powell -- 改进型Powell法
fmin_bfgs -- 拟Newton法
fmin_cg -- 非线性共轭梯度法
fmin_ncg -- 线性搜索Newton共轭梯度法
leastsq -- 最小二乘
2.有约束的多元函数问题
fmin_l_bfgs_b ---使用L-BFGS-B算法
fmin_tnc ---梯度信息
fmin_cobyla ---线性逼近
fmin_slsqp ---序列最小二乘法
nnls ---解|| Ax - b ||_2 for x>=0
3.全局优化
anneal ---模拟退火算法
brute --强力法
4.标量函数
fminbound
brent
golden
bracket
5.拟合
curve_fit-- 使用非线性最小二乘法拟合
6.标量函数求根
brentq ---classic Brent (1973)
brenth ---A variation on the classic Brent（1980）ridder ---Ridder是提出这个算法的人名
bisect ---二分法
newton ---牛顿法
fixed_point
7.多维函数求根
fsolve ---通用
broyden1 ---Broyden’s first Jacobian approximation.
broyden2 ---Broyden’s second Jacobian approximationnewton_krylov ---Krylov approximation for inverse Jacobiananderson ---extended Anderson mixing
excitingmixing ---tuned diagonal Jacobian approximationlinearmixing ---scalar Jacobian approximationdiagbroyden ---diagonal Broyden Jacobian approximation8.实用函数
line_search ---找到满足强Wolfe的alpha值
check_grad ---通过和前向有限差分逼近比较检查梯度函数的正确性二、实战非线性最优化
fmin完整的调用形式是：
fmin(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None)不过我们最常使用的就是前两个参数。一个描述优化问题的函数以及初值。后面的那些参数我们也很容易理解。如果您能用到，请自己研究。下面研究一个最简单的问题，来感受这个函数的使用方法：f(x)=x**2-4*x+8，我们知道，这个函数的最小值是4，在x=2的时候取到。
from scipy.optimize import fmin #引入优化包def myfunc(x):
return x**2-4*x+8 #定义函数
x0 = [1.3] #猜一个初值
xopt = fmin(myfunc, x0) #求解
print xopt #打印结果
运行之后，给出的结果是：
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 16
Function evaluations: 32
[ 2.00001953]
程序准确的计算得出了最小值，不过最小值点并不是严格的2，这应该是由二进制机器编码误差造成的。
除了fmin_ncg必须提供梯度信息外，其他几个函数的调用大同小异，完全类似。我们不妨做一个对比：
from scipy.optimize import fmin,fmin_powell,fmin_bfgs,fmin_cgdef myfunc(x):
return x**2-4*x+8
x0 = [1.3]
xopt1 = fmin(myfunc, x0)
print xopt1
print
xopt2 = fmin_powell(myfunc, x0)
print xopt2
print
xopt3 = fmin_bfgs(myfunc, x0)
print xopt3
print
xopt4 = fmin_cg(myfunc,x0)
print xopt4
给出的结果是：
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 16
Function evaluations: 32
[ 2.00001953]
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 53
1.99999999997
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 12
Gradient evaluations: 4
[ 2.00000001]
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 15
Gradient evaluations: 5
[ 2.]
我们可以根据给出的消息直观的判断算法的执行情况。每一种算法数学上的问题，请自己看书学习。个人感觉，如果不是纯研究数学的工作，没必要搞清楚那些推导以及定理云云。不过，必须了解每一种算法的优劣以及能力所及。在使用的时候，不妨多种算法都使用一下，看看效果分别如何，同时，还可以互相印证算法失效的问题。
在from scipy.optimize import fmin之后，就可以使用help(fmin)来查看fmin的帮助信息了。帮助信息中没有例子，但是给出了每一个参数的含义说明，这是调用函数时候的最有价值参考。
有源码研究癖好的，或者当你需要改进这些已经实现的算法的时候，可能需要查看optimize中的每种算法的源代码。在这里：https:/ / github. com/scipy/scipy/blob/master/scipy/optimize/optimize.py聪明的你肯定发现了，顺着这个链接往上一级、再往上一级，你会找到scipy的几乎所有源码！

❿ 模拟退火算法的简介

模拟退火算法(Simulated Annealing，SA)最早的思想是由N. Metropolis 等人于1953年提出。1983 年,S. Kirkpatrick 等成功地将退火思想引入到组合优化领域。它是基于Monte-Carlo迭代求解策略的一种随机寻优算法，其出发点是基于物理中固体物质的退火过程与一般组合优化问题之间的相似性。模拟退火算法从某一较高初温出发，伴随温度参数的不断下降,结合概率突跳特性在解空间中随机寻找目标函数的全局最优解，即在局部最优解能概率性地跳出并最终趋于全局最优。模拟退火算法是一种通用的优化算法，理论上算法具有概率的全局优化性能,目前已在工程中得到了广泛应用，诸如VLSI、生产调度、控制工程、机器学习、神经网络、信号处理等领域。
模拟退火算法是通过赋予搜索过程一种时变且最终趋于零的概率突跳性，从而可有效避免陷入局部极小并最终趋于全局最优的串行结构的优化算法。