差分进化算法代码

㈠ 多目标差分进化算法

差分进化算法(Differential Evolution, DE)是一种基于群体差异的启发式随机搜索算法，该算法是由R.Storn和K.Price为求解Chebyshev多项式而提出的。是一种用于最佳化问题的后设启发式算法。本质上说，它是一种基于实数编码的具有保优思想的贪婪遗传算法。

将问题的求解表示成"染色体"的适者生存过程，通过"染色体"群的一代代不断进化，包括复制、交叉和变异等操作，最终收敛到"最适应环境"的个体，从而求得问题的最优解或满意解。

差分进化算法类似遗传算法，包含变异，交叉操作，淘汰机制，而差分进化算法与遗传算法不同之处，在于变异的部分是随选两个解成员变数的差异，经过伸缩后加入当前解成员的变数上，因此差分进化算法无须使用概率分布产生下一代解成员。最优化方法分为传统优化方法和启发式优化方法两大类。传统的优化方法大多数都是利用目标函数的导数求解；而启发式优化方法以仿生算法为主，通过启发式搜索策略实现求解优化。启发式搜索算法不要求目标函数连续、可微等信息，具有较好的全局寻优能力，成为最优化领域的研究热点。

在人工智能领域中，演化算法是演化计算的一个分支。它是一种基于群体的元启发式优化算法，具有自适应、自搜索、自组织和隐并行性等特点。近年来，很多学者将演化算法应用到优化领域中，取得了很大的成功，并已引起了人们的广泛关注。越来越多的研究者加入到演化优化的研究之中，并对演化算法作了许多改进，使其更适合各种优化问题。目前，演化算法已广泛应用于求解无约束函数优化、约束函数优化、组合优化、多目标优化等多种优化问题中。

㈡ 进化算法的差分算法

差分进化算法(Differential Evolution, DE)是一种新兴的进化计算技术，或称为差分演化算法、微分进化算法、微分演化算法、差异演化算法。它是由Storn等人于1995年提出的，最初的设想是用于解决切比雪夫多项式问题，后来发现DE也是解决复杂优化问题的有效技术。DE与人工生命，特别是进化算法有着极为特殊的联系。
差分进化算法是基于群体智能理论的优化算法，通过群体内个体间的合作与竞争产生的群体智能指导优化搜索。但相比于进化算法，DE保留了基于种群的全局搜索策略，采用实数编码基于差分的简单变异操作和一对一的竞争生存策略，降低了遗传操作的复杂性。同时，DE特有的记忆能力使其可以动态跟踪当前的搜索情况，以调整其搜索策略，具有较强的全局收敛能力和鲁棒性，且不需要借助问题的特征信息，适于求解一些利用常规的数学规划方法所无法求解的复杂环境中的优化问题。
差分进化算法是一种基于群体进化的算法，具有记忆个体最优解和种群内信息共享的特点，即通过种群内个体间的合作与竞争来实现对优化问题的求解，其本质是一种基于实数编码的具有保优思想的贪婪遗传算法。
DE是一种用于优化问题的启发式算法。本质上说，它是一种基于实数编码的具有保优思想的贪婪遗传算法 。同遗传算法一样，DE包含变异和交叉操作，但同时相较于遗传算法的选择操作，DE采用一对一的淘汰机制来更新种群。由于DE在连续域优化问题的优势已获得广泛应用，并引发进化算法研究领域的热潮。
DE由Storn 以及Price提出，算法的原理采用对个体进行方向扰动，以达到对个体的函数值进行下降的目的，同其他进化算法一样，DE不利用目标函数的梯度信息，因此对目标的可导性甚至连续性没有要求，适用性很强。同时，算法与粒子群优化有相通之处 ，但因为DE在一定程度上考虑了多变量间的相关性，因此相较于粒子群优化在变量耦合问题上有很大的优势。算法的实现参考实现代码部分。

㈢ 谁有关于进化算法的程序用C语言写的！急用！

/************************************************/
文件名：Classifier.h

#ifndef CLASSIFIER_H
#define CLASSIFIER_H

#include <iostream>
#include <stdio.h>

#define SELF 0
#define NONSELF 1
#define MASKVALUE 2

// detector class
class Detector
{
public:
Detector(const unsigned int length);
Detector::~Detector(void);

unsigned int length;
unsigned int *value;
double threshold;
unsigned int type;

void save(FILE *outputStream);
void show(void) { save(stdout); };
};

#endif

/**********************************************/
//文件名：Classifier.cpp

#include "Classifier.h"

// detector class public methods

Detector::Detector(const unsigned int length)
{
this->length = length;
threshold = 0.0;
value = new unsigned int [length];
type = 0;
}

Detector::~Detector(void)
{
delete [] value;
}

void Detector::save(FILE *outputStream)
{
register unsigned int i;

fprintf(outputStream, \
"%-3d %-.10f %-1d\n", \
length, \
threshold, \
type \
);

for(i = 0; i < length; i++)
fprintf(outputStream, "%-1d ", value[i]);
fprintf(outputStream, "\n");

fflush(outputStream);
}

/**********************************************/
//文件名：EvolutionaryAlgorithm.h

#ifndef EVOLUTIONARYALGORITHM_H
#define EVOLUTIONARYALGORITHM_H

#include "Classifier.h"
#include <stdio.h>

// genome class
class Genome
{
public:
Genome(const unsigned int length);
~Genome(void);

unsigned int size;
unsigned int *locus;
unsigned int type;
double mutationProbability;
double crossoverProbability;
double fitness, scaledFitness;
unsigned int thresholdLength, patternLength;
double generalityBias;
double typeBias;

void Genome(Genome *genome);
void uniformCrossover(Genome *genome1, Genome *genome2);
void mutateBinary(void);
void randomiseBinary(void);
void setDetector(Detector *detector);
void save(FILE *outputStream);
void show(void) { save(stdout); };
};

// species class
class Species
{
public:
Species(const unsigned int speciesSize, const unsigned int genomeLength);
~Species(void);

unsigned int speciesSize;
Genome **genome;
unsigned int fittestIndivial;
double speciesScaledFitnessSum;
double meanSpeciesFitness;

Genome *FPSelection(void);
void randomise(void);
void Species(Species *species);
void save(FILE *outputStream);
void show(void) { save(stdout); };
};

#endif

/**********************************************************/
//文件名：EvolutionaryAlgorithm.cpp

#include "EvolutionaryAlgorithm.h"
#include <stdlib.h>

// genome class public methods
Genome::Genome(const unsigned int length)
{
thresholdLength = 8;
patternLength = length;
size = thresholdLength + 2 * patternLength;
locus = new unsigned int [size];
mutationProbability = 2.0 / double(size);
crossoverProbability = 0.6;
generalityBias = typeBias = 0.5;
fitness = 0.0;
type = 0;
}

Genome::~Genome(void)
{
delete [] locus;
}

void Genome::Genome(Genome *genome)
{
register unsigned int i = size;
register unsigned int *from = genome->locus;
register unsigned int *to = locus;

while(i--)
to[i] = from[i];
mutationProbability = genome->mutationProbability;
crossoverProbability = genome->crossoverProbability;
fitness = genome->fitness;
scaledFitness = genome->scaledFitness;
generalityBias = genome->generalityBias;
size = genome->size;
patternLength = genome->patternLength;
thresholdLength = genome->thresholdLength;
type = genome->type;
}

void Genome::uniformCrossover(Genome *genome1, Genome *genome2)
{
register unsigned int i = size;
register unsigned int *from1 = genome1->locus;
register unsigned int *from2 = genome2->locus;
register unsigned int *to = locus;
register double cp = crossoverProbability;

while(i--)
{
if(drand48() < cp)
to[i] = from1[i];
else
to[i] = from2[i];
}
if(drand48() < cp)
type = genome1->type;
else
type = genome2->type;
}

void Genome::mutateBinary(void)
{
register unsigned int i = size;
register unsigned int *loci = locus;
register double mp = mutationProbability;

while(i--)
if(drand48() < mp)
loci[i] = 1 - loci[i];
if(drand48() < mp)
type = 1 - type;
}

void Genome::randomiseBinary(void)
{
register unsigned int index, i;

index = 0;

i = thresholdLength;
while(i--)
locus[index++] = int((double(rand()) * 2.0) / double(RAND_MAX + 1.0));
i = patternLength;
while(i--)
locus[index++] = int((double(rand()) * 2.0) / double(RAND_MAX + 1.0));
i = patternLength;
while(i--)
if(drand48() < generalityBias)
locus[index++] = 0;
else
locus[index++] = 1;
if(drand48() < typeBias)
type = SELF;
else
type = NONSELF;
}

void Genome::save(FILE *outputStream)
{
register unsigned int i;
Detector *detector = new Detector(patternLength);

fprintf(outputStream, \
"%-3d %-3d %-3d %-1d %-10f %-10f %-10f %-10f %-10f %-10f\n", \
size, \
thresholdLength, \
patternLength, \
type, \
fitness, \
scaledFitness, \
mutationProbability, \
crossoverProbability, \
generalityBias, \
typeBias \
);

for(i = 0; i < size; i++)
fprintf(outputStream, "%-2d ", locus[i]);
fprintf(outputStream, "\n");

setDetector(detector);
detector->save(outputStream);

delete detector;

fflush(outputStream);
}

void Genome::setDetector(Detector *detector)
{
register unsigned int i, loci = 0, sum, lastLoci;

// set activation threshold
// gray coding for threshold gene
sum = lastLoci = locus[loci++];
while(loci < thresholdLength)
{
sum = (sum << 1) | (lastLoci ^ locus[loci]);
lastLoci = locus[loci++];
}
detector->threshold = double(sum) / 255.0; // !!!!!!!!!!!!!!!!!!!!
for(i = 0; i < patternLength; i++)
detector->value[i] = locus[loci++];
for(i = 0; i < patternLength; i++)
if(!locus[loci++])
detector->value[i] = MASKVALUE;
detector->type = type;
detector->length = patternLength;
}

// species class public methods
Species::Species(const unsigned int speciesSize, \
const unsigned int genomeLength)
{
register unsigned int i = speciesSize;

this->speciesSize = speciesSize;
fittestIndivial = 0;
speciesScaledFitnessSum = meanSpeciesFitness = 0.0;
genome = new Genome * [speciesSize];
while(i--)
genome[i] = new Genome(genomeLength);
}

Species::~Species(void)
{
register unsigned int i = speciesSize;

while(i--)
delete genome[i];
delete genome;
}

Genome *Species::FPSelection(void)
{
register unsigned int i = 0;
register double dtmp1, dtmp2;

dtmp1 = drand48() * speciesScaledFitnessSum;
dtmp2 = 0.0;
while((i < speciesSize) && ((dtmp2 = dtmp2 + genome[i]->scaledFitness) \
< dtmp1))
i++;
return((i < speciesSize) ? genome[i] : genome[i - 1]);
}

void Species::randomise(void)
{
register unsigned int i = speciesSize;

while(i--)
genome[i]->randomiseBinary();
}

void Species::save(FILE *outputStream)
{
fprintf(outputStream, \
"%-4d %-4d %-5.10f %-.10f\n", \
speciesSize, \
fittestIndivial, \
speciesScaledFitnessSum, \
meanSpeciesFitness \
);

genome[fittestIndivial]->save(outputStream);

fflush(outputStream);
}

void Species::Species(Species *species)
{
register unsigned int i = species->speciesSize;

speciesSize = i;
while(i--)
genome[i]->Genome(species->genome[i]);
fittestIndivial = species->fittestIndivial;
speciesScaledFitnessSum = species->speciesScaledFitnessSum;
meanSpeciesFitness = species->meanSpeciesFitness;
}

//补充了下，刚才少了个Classifier.cpp。

㈣ 优化算法笔记（二）优化算法的分类

（以下描述，均不是学术用语，仅供大家快乐的阅读）

在分类之前，我们先列举一下常见的优化算法（不然我们拿什么分类呢？）。
1遗传算法Genetic algorithm
2粒子群优化算法Particle Swarm Optimization
3差分进化算法Differential Evolution
4人工蜂群算法Artificial Bee Colony
5蚁群算法Ant Colony Optimization
6人工鱼群算法Artificial Fish Swarm Algorithm
7杜鹃搜索算法Cuckoo Search
8萤火虫算法Firefly Algorithm
9灰狼算法Grey Wolf Optimizer
10鲸鱼算法Whale Optimization Algorithm
11群搜索算法Group search optimizer
12混合蛙跳算法Shuffled Frog Leaping Algorithm
13烟花算法fireworks algorithm
14菌群优化算法Bacterial Foraging Optimization
以上优化算法是我所接触过的算法，没接触过的算法不能随便下结论，知之为知之，不知为不知。其实到目前为止优化算法可能已经有几百种了，我们不可能也不需要全面的了解所有的算法，而且优化算法之间也有较大的共性，深入研究几个之后再看其他优化算法上手速度会灰常的快。
优化算法从提出到现在不过50-60年（遗传算法1975年提出），虽种类繁多但大多较为相似，不过这也很正常，比较香蕉和人的基因相似度也有50%-60%。当然算法之间的相似度要比香蕉和人的相似度更大，毕竟人家都是优化算法，有着相同的目标，只是实现方式不同。就像条条大路通罗马，我们可以走去，可以坐汽车去，可以坐火车去，也可以坐飞机去，不管使用何种方式，我们都在去往罗马的路上，也不会说坐飞机去要比走去更好，交通工具只是一个工具，最终的方案还是要看我们的选择。

上面列举了一些常见的算法，即使你一个都没见过也没关系，后面会对它们进行详细的介绍，但是对后面的分类可能会有些许影响，不过问题不大，就先当总结看了。
再对优化算法分类之前，先介绍一下算法的模型，在笔记（一）中绘制了优化算法的流程，不过那是个较为简单的模型，此处的模型会更加复杂。上面说了优化算法有较大的相似性，这些相似性主要体现在算法的运行流程中。
优化算法的求解过程可以看做是一个群体的生存过程。

有一群原始人，他们要在野外中寻找食物，一个原始人是这个群体中的最小单元，他们的最终目标是寻找这个环境中最容易获取食物的位置，即最易存活下来的位置。每个原始人都去独自寻找食物，他们每个人每天获取食物的策略只有采集果实、制作陷阱或者守株待兔，即在一天之中他们不会改变他们的位置。在下一天他们会根据自己的策略变更自己的位置。到了某一天他们又聚在了一起，选择了他们到过的最容易获取食物的位置定居。
一群原始人=优化算法中的种群、群体；
一个原始人=优化算法中的个体；
一个原始人的位置=优化算法中个体的位置、基因等属性；
原始人变更位置=优化算法中总群的更新操作；
该位置获取食物的难易程度=优化算法中的适应度函数；
一天=优化算法中的一个迭代；
这群原始人最终的定居位置=优化算法所得的解。
优化算法的流程图如下：

对优化算法分类得有个标准，按照不同的标准分类也会得到不一样的结果。首先说一下我所使用的分类标准（动态更新，有了新的感悟再加）：

按由来分类比较好理解，就是该算法受何种现象启发而发明，本质是对现象分类。

可以看出算法根据由来可以大致分为有人类的理论创造而来，向生物学习而来，受物理现象启发。其中向生物学习而来的算法最多，其他类别由于举例有偏差，不是很准确，而且物理现象也经过人类总结，有些与人类现象相交叉，但仍将其独立出来。
类别分好了，那么为什么要这么分类呢？

当然是因为要凑字数啦，啊呸，当然是为了更好的理解学习这些算法的原理及特点。
向动物生存学习而来的算法一定是一种行之有效的方法，能够保证算法的效率和准确性，因为，如果使用该策略的动物无法存活到我们可以对其进行研究，我们也无法得知其生存策略。（而这也是一种幸存者偏差，我们只能看到行之有效的策略，但并不是我们没看到的策略都是垃圾，毕竟也发生过小行星撞地球这种小概率毁灭性事件。讲个冷笑话开cou心一shu下:一只小恐龙对他的小伙伴说，好开心，我最喜欢的那颗星星越来越亮了（完）。）但是由于生物的局限性，人们所创造出的算法也会有局限性：我们所熟知的生物都生存在三维空间，在这些环境中，影响生物生存的条件比较有限，反应到算法中就是这些算法在解决较低维度的问题时效果很好，当遇到超高维（维度>500）问题时，结果可能不容乐观，没做过实验，我也不敢乱说。

按更新过程分类相对复杂一点，主要是根据优化算法流程中更新位置操作的方式来进行分类。更新位置的操作按我的理解可大致分为两类：1.跟随最优解；2.不跟随最优解。
还是上面原始人的例子，每天他有一次去往其他位置狩猎的机会，他们采用何种方式来决定今天自己应该去哪里呢？
如果他们的策略是“跟随最优解”，那么他们选取位置的方式就是按一定的策略向群体已知的最佳狩猎位置（历史最佳）或者是当前群体中的最佳狩猎位置（今天最佳）靠近，至于是直线跑过去还是蛇皮走位绕过去，这个要看他们群体的策略。当然，他们的目的不是在最佳狩猎位置集合，他们的目的是在过去的途中看是否能发现更加好的狩猎位置，去往已经到过的狩猎地点再次狩猎是没有意义的，因为每个位置获取食物的难易程度是固定的。有了目标，大家都会朝着目标前进，总有一日，大家会在谋个位置附近相聚，相聚虽好但不利于后续的觅食容易陷入局部最优。
什么是局部最优呢？假设在当前环境中有一“桃花源”，拥有上帝视角的我们知道这个地方就是最适合原始人们生存的，但是此地入口隐蔽“山有小口，仿佛若有光”、“初极狭，才通人。”，是一个难以发现的地方。如果没有任何一个原始人到达了这里，大家向着已知的最优位置靠近时，也难以发现这个“桃源之地”，而当大家越聚越拢之后，“桃源”被发现的可能性越来越低。虽然原始人们得到了他们的解，但这并不是我们所求的“桃源”，他们聚集之后失去了寻求“桃源”的可能，这群原始人便陷入了局部最优。

如果他们的策略是“不跟随最优解”，那么他们的策略是什么呢？我也不知道，这个应该他们自己决定。毕竟“是什么”比“不是什么”的范围要小的多。总之不跟随最优解时，算法会有自己特定的步骤来更新个体的位置，有可能是随机在自己附近找，也有可能是随机向别人学习。不跟随最优解时，原始人们应该不会快速聚集到某一处，这样一来他们的选择更具多样性。
按照更新过程对上面的算法分类结果如下

可以看出上面不跟随最优解的算法只有遗传算法和差分进化算法，他们的更新策略是与进化和基因的重组有关。因此这些不跟随最优解的算法，他们大多依据进化理论更新位置（基因）我把他们叫做进化算法，而那些跟随群体最优解的算法，他们则大多依赖群体的配合协作，我把这些算法叫做群智能算法。

目前我只总结了这两种，分类方法，如果你有更加优秀的分类方法，我们可以交流一下：

目录
上一篇 优化算法笔记（一）优化算法的介绍
下一篇 优化算法笔记（三）粒子群算法（1）

㈤ sko搴扑腑镄勫嚑绉崭紭鍖栫畻娉

璁╂垜浠娣卞叆鎺㈣╯ko搴扑腑镄勫嚑绉崭紭鍖栫畻娉曪纴杩欎簺绠楁硶鐘瑰傛帰绱㈡湭鐭ラ嗗烟镄勬帰闄╁讹纴镊村姏浜庡绘垒鍑芥暟涓镄勬渶浼樿В銆傞栧厛锛屾垜浠瀵煎叆蹇呰佺殑宸ュ叿:

import sko
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

瀹氢箟涓涓阍堢姸鍑芥暟锛屽畠镄勭洰镙囨槸瀵绘垒鍦0鍒100镄勬ｆ柟褰㈠尯锘熷唴镄勬渶灏忓硷纴杩欎釜鍑芥暟鍏锋湁涓涓闅愯棌镄勬写鎴樼偣锛(50, 50)銆傛垜浠镄勪换锷℃槸镓惧埌涓涓鎺ヨ繎杩欎釜镣圭殑瑙:

def pin_func(p):
x, y = p
r = np.square((x - 50)**2 + (y - 50)**2) + np.exp(1)
t = np.sin(r) / r + 1
return -1 * t

鎺ヤ笅𨱒ワ纴鎴戜滑鐢╯ko搴扑腑镄勫嚑绉崭紭鍖栫畻娉曟潵瑙ｅ喅杩欎釜闂棰:

1. 阆椾紶绠楁硶

from sko.GA import GA
o_GA = GA(func=pin_func, n_dim=2, size_pop=50, max_iter=800, prob_mut=0.001, lb=[0, 0], ub=[100, 100], precision=1e-7)

阃氲繃阆椾紶绠楁硶锛屾垜浠瀵绘垒鐩镙囧嚱鏁扮殑链灏忓硷纴寰楀埌涓缁勬帴杩戞渶浼樿В镄(x, y)鍧愭爣:

A_GA_x, A_GA_y = o_GA.run()
print(f"阆椾紶绠楁硶链灏忓: X = {A_GA_x}, Y = {A_GA_y}")

2. 绮掑瓙缇ょ畻娉

from sko.PSO import PSO
A_pso = PSO(func=pin_func, dim=2, pop=400, max_iter=200, w=1, c1=2, c2=2)
A_pos_x, A_pos_y = A_pso.run()
print(f"绮掑瓙缇ょ畻娉曡В: x = {A_pos_x}, y = {A_pos_y}")

3. 宸鍒呜繘鍖栫畻娉

from sko.DE import DE
A_DE = DE(func=pin_func, n_dim=2, size_pop=50, max_iter=800, prob_mut=0.3)
A_DE_x, A_DE_y = A_DE.run()
print(f"宸鍒呜繘鍖栫畻娉曡В: x = {A_DE_x}, y = {A_DE_y}")

4. 妯℃嫙阃𨱔绠楁硶

from sko.SA import SA
A_sa = SA(func=pin_func, x0=[1, 1], T_max=1, T_min=1e-9, L=300, max_stay_counter=150, lb=[0, 0], ub=[100, 100])
A_sa_x, A_sa_y = A_sa.run()
print(f"妯℃嫙阃𨱔绠楁硶瑙: x = {A_sa_x}, y = {A_sa_y}")

5. 楸肩兢绠楁硶

from sko.AFSA import AFSA
afsa = AFSA(func=pin_func, n_dim=2, size_pop=50, max_iter=300, max_try_num=100, step=5, visual=0.3, q=0.98, delta=1)
best_x, best_y = afsa.run()
print(f"楸肩兢绠楁硶链浼樿В: x = {best_x}, y = {best_y}")

姣忕岖畻娉曢兘浠ョ嫭鐗圭殑鏂瑰纺鎺㈢储鍑芥暟绌洪棿锛屾彮绀哄嚭闅愯棌镄勬渶浼樿В锛屽𪾢绀轰简sko搴撶殑寮哄ぇ浼桦寲鑳藉姏銆傞氲繃杩欎簺绠楁硶锛屾垜浠鍙浠ユ洿娣卞叆鍦扮悊瑙ｅ备綍鍦ㄥ嶆潅闂棰树腑镓惧埌链浣崇瓥鐣ャ