版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/a19990412/article/details/84900775
概念
生物进化中的概念 | 遗传算法中的作用 |
---|---|
环境 | 适应函数 |
适应性 | 适应函数值 |
适者生存 | 适应值大的解被保留的概率大 |
个体 | 问题的一个解 |
染色体 | 解的编码 |
基因 | 编码的元素 |
群体 | 被选定的一组解 |
种群 | 按适应函数选择的一组解(编码表示) |
交配 | 以一定的方式由双亲产生后代的过程 |
变异 | 编码的某些分量发生变化的过程 |
三个生成过程
- select 自然选择
- crossover 交叉(交配)
- mutation 变异
把每个数据想象成染色体,然后从染色体到人的映射就是object function,也就是这里的适应函数。
当然可以映射到更深的程度,比如考虑人的身高之类的(可以被量化的东西)
- 染色体 这样的比喻,会很容易理解crossover这个步骤。
- 变异这个也很好理解,避免进入到局部极小值,被控制住了。
- 自然选择,这个根据evolutionary theory,也很容易理解
简单遗传算法框架
一般终止条件是:过了很久最优的适应值都不发生变化
整数编码问题
因为如果是二进制编码的话,会简单很多,这里就不讲了。
难点其实还是在整数编码上。
整数编码(简单的实例):
(有些问题不是排序的问题,就可以类似于之前的二进制来实现)
对于父母分别是 0 到 9整数的排序【加上长度均为10】:
要求子代也必须是这样的排序。
- 自然选择:不会产生子代,只是筛选子代,所以不受这个问题影响
- 交叉(crossover):会产生子代。这里只考虑排序时候的情况
- 基于次序的交配法: 在父代1找到几个位置,之后,找到这些数字在父代2的位置。并删除(用空白填充)。之后这些空白按照父代1的中这些数字的顺序排好。(非常简单的方法)
- 基于位置的交配法: 在父代1找到几个位置,父代2的数值直接替代上去,只会,冲突的位置(不在之前选的位置上冲突的位置),按顺序从父代1替代。
- 部分映射的交配法: 任意选两个位置,在父代1,2直接这两个位置之间的序列构建序列对。然后,按照这样的序列对的映射方式,在父代1或者父代2上做映射交换。就可以得到子代1或子代2。
- 变异(mutation):会产生子代。
- 基于位置的变异: 随机产生两个变异位,然后将第二个变异位上的基因移动到第一个变异位之前。
- 基于次序的变异: 随机的产生两个变异位,然后交换这两个变异位上的基因。
- 打乱变异: 随机寻去染色体上的一段,然后打乱在该段内的基因次序。逆序交换方式是打乱变异的一个特例。
TSP问题
TSP,是货郎担问题,也就是中国邮递员问题(少数世界级问问题,用中国人命名的问题hhh)。
就是n个点直接连通需要不同的代价,如果想要找到不重复的经历完所有点,然后在回到初始点的用的代价最小。
用遗传算法解决TSP问题
#include <iostream>
#include <cmath>
#include <ctime>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <algorithm>
using namespace std;
// 随机整数[b, e)
#define RAND(b, e) (rand() % ((e)-(b)) + (b))
// 随机浮点数 0,1
#define RANDFLOAT() ((double)rand() / double(RAND_MAX))
// 种群数量
int LEN = 10;
int tempLEN = 3 * LEN;
// 交配的概率,编译的概率
double pc = 0.8, pm = 0.8;
// 种群的所有路径
int **Paths;
int **tempPaths;
int temp_index = 0;
double **Mat;
double *Value, *tempValue;
int globalValue_index, stay_in_global_times = 0;
double globalValue;
int *globalPath;
// TSP节点数量
int N = 0;
// 适应值函数
double CalValue(int *p) { // read only
double t = 0;
for (int i = 1; i < N; ++i) {
t += Mat[p[i - 1]][p[i]];
}
t += Mat[p[N - 1]][0];
return t;
}
void initialPath(int *Path, int j);
void initialPaths();
void find_min(int first = 1);
// 自然选择
void select();
// 交配
void crossover(int *p1, int* p2);
// 变异
void mutation(int *Path);
//
void preserve(int *p1, int *p2, int v1, int v2);
int main() {
srand((unsigned)time(NULL));
ifstream cin("data.txt");
cin >> N;
Mat = new double *[N];
for (int i = 0; i < N; ++i) {
Mat[i] = new double[N];
}
// read data from data.txt
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
cin >> Mat[i][j];
}
}
// new Path...
Paths = new int*[LEN];
for (int i = 0; i < LEN; ++i) {
Paths[i] = new int[N];
}
tempPaths = new int*[tempLEN];
for (int i = 0; i < tempLEN; ++i) {
tempPaths[i] = new int[N];
}
Value = new double[LEN];
tempValue = new double[tempLEN];
globalPath = new int[N];
// end new Path...
initialPaths(); // initialize paths
while (true) {
temp_index = 0;
for (int i = 0; i < LEN; i += 2) {
if (temp_index >= tempLEN) break;
preserve(Paths[i], Paths[i + 1], Value[i], Value[i + 1]);
if (temp_index >= tempLEN) break;
if (RANDFLOAT() < pc) crossover(Paths[i], Paths[i + 1]);
}
for (int i = 0; i < LEN; ++i) {
if (temp_index >= tempLEN) break;
if (RANDFLOAT() < pm) mutation(Paths[i]);
}
select();
if (stay_in_global_times == 1000) { break; }
}
cout << globalValue << endl;
for (int i = 0; i < N; ++i) {
cout << globalPath[i] << " --> ";
}
// delete Path...
delete[]tempValue;
delete[]Value;
for (int i = 0; i < tempLEN; ++i) {
delete[]tempPaths[i];
}
delete[] tempPaths;
for (int i = 0; i < LEN; ++i) {
delete[]Paths[i];
}
delete[] Paths;
for (int i = 0; i < N; ++i) {
delete[] Mat[i];
}
delete[]Mat;
system("pause");
}
// preserve the parents.
void preserve(int *p1, int *p2, int v1, int v2) {
for (int i = 0; i < N; ++i) {
tempPaths[temp_index][i] = p1[i];
}
tempValue[temp_index] = v1;
//if (tempValue[temp_index] < 0) cout << "wrong\n";
temp_index++;
if (p2 != NULL) {
for (int i = 0; i < N; ++i) {
tempPaths[temp_index][i] = p2[i];
}
tempValue[temp_index] = v2;
//if (tempValue[temp_index] < 0) cout << "wrong\n";
temp_index++;
}
}
struct enumate{
double data;
int index;
bool operator < (const enumate& e) const {
return data < e.data;
}
};
vector<int> argsort_temp_value() {
enumate * data = new enumate[temp_index];
for (int i = 0; i < temp_index; ++i) {
data[i].data = tempValue[i];
data[i].index = i;
}
sort(data, data +temp_index);
vector<int> ans(temp_index);
for (int i = 0; i < temp_index; ++i) ans[i] = data[i].index;
delete[]data;
return ans;
}
void select() {
vector<int> id = argsort_temp_value();
for (int i = 0; i < temp_index; ++i) if (tempValue[i] < 0)cout << tempValue[i] << endl;
for (int i = 0; i < LEN; ++i) {
Value[i] = tempValue[id[i]];
for (int j = 0; j < N; ++j) {
Paths[i][j] = tempPaths[id[i]][j];
}
}
if (Value[0] < globalValue) {
for (int i = 0; i < N; ++i) globalPath[i] = Paths[0][i];
stay_in_global_times = 0;
globalValue = Value[0];
}
else if (Value[0] == globalValue) {
stay_in_global_times++;
}
else {
cout << "Something wrong" << Value[0]<< endl;
}
}
// 基于次序的交配方式
void crossover(int * p1, int * p2)
{
// generate son from p1 and p2
int crossn = RAND(0, N-1);
if (crossn == 0) return;
int * indexs = new int[crossn];
for (int i = 0; i < crossn; ++i) {
if (i == 0) indexs[i] = RAND(1, N - crossn + 1);
else {
indexs[i] = RAND(indexs[i - 1] + 1, N - crossn + i + 1);
}
}
// copy from p2
for (int i = 0; i < N; ++i) {
tempPaths[temp_index][i] = p2[i];
}
int use_count = 0;
for (int i = 0; i < N; ++i) {
if (use_count == crossn) break;
for (int j = 0; j < crossn; ++j) {
if (tempPaths[temp_index][i] == p1[indexs[j]]) {
tempPaths[temp_index][i] = p1[indexs[use_count]];
use_count++;
break;
}
}
}
// cal value
tempValue[temp_index] = CalValue(tempPaths[temp_index]);
temp_index++;
// copy from p1
for (int i = 0; i < N; ++i) {
tempPaths[temp_index][i] = p1[i];
}
use_count = 0;
for (int i = 0; i < N; ++i) {
if (use_count == crossn) break;
for (int j = 0; j < crossn; ++j) {
if (tempPaths[temp_index][i] == p2[indexs[j]]) {
tempPaths[temp_index][i] = p2[indexs[use_count]];
use_count++;
break;
}
}
}
tempValue[temp_index] = CalValue(tempPaths[temp_index]);
temp_index++;
delete[] indexs;
}
// 基于次序的变异
void mutation(int * Path)
{
int a = RAND(1, N), b, t;
if (a == N - 1) {
b = RAND(1, N - 1);
t = a;
a = b;
b = t;
}
else {
b = RAND(a + 1, N);
}
for (int i = 0; i < N; ++i) {
if (i == a)
tempPaths[temp_index][i] = Path[b];
else if ( i == b )
tempPaths[temp_index][i] = Path[a];
else tempPaths[temp_index][i] = Path[i];
}
tempValue[temp_index] = CalValue(tempPaths[temp_index]);
temp_index++;
}
void initialPaths() {
for (int i = 0; i < LEN; ++i)
initialPath(Paths[i], i);
find_min();
}
void find_min(int first)
{
int temp = 0;
for (int i = 1; i < LEN; ++i)
if (Value[temp] > Value[i]) temp = i;
if (first) {
globalValue = Value[temp];
for (int i = 0; i < N; ++i)
globalPath[i] = Paths[temp][i];
}
else if (Value[temp] < globalValue) {
globalValue = Value[temp];
for (int i = 0; i < N; ++i)
globalPath[i] = Paths[temp][i];
}
}
void initialPath(int *Path, int j) {
for (int i = 0; i < N; ++i) {
Path[i] = i;
}
// Path[i]表示路上第i个点的标记为Path[i]
// Path[0] = 0
int tx, t;
for (int i = 1; i < N - 1; ++i) {
tx = RAND(i, N);
if (tx != i) { // swap
t = Path[i];
Path[i] = Path[tx];
Path[tx] = t;
}
}
Value[j] = CalValue(Path);
}
这里用的数据跟之前的用退火算法的结果是一样的。
模拟退火算法理论+Python解决函数极值+C++实现解决TSP问题
- 结果是也是一样的,对于这个,我们可以设置重复多少次来停止来控制这个精度。
- 为了避免到局部最优解,也可以使用提高变异概率来设计。
- 结果是大概率收敛到较好的结果。
244
0 --> 6 --> 2 --> 8 --> 9 --> 7 --> 5 --> 1 --> 3 --> 4 -->
改进版本代码
- 改进点:交配的尝试会在每人之间都相互试试看。提高了随机性,所以会更稳定的收敛到结果。因此就不用太多次的停滞就可以控制住。
#include <iostream>
#include <cmath>
#include <ctime>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <algorithm>
using namespace std;
// 随机整数[b, e)
#define RAND(b, e) (rand() % ((e)-(b)) + (b))
// 随机浮点数 0,1
#define RANDFLOAT() ((double)rand() / double(RAND_MAX))
// 种群数量
int LEN = 22;
int tempLEN = LEN * LEN;
// 交配的概率,编译的概率
double pc = 0.8, pm = 0.9;
// 种群的所有路径
int **Paths;
int **tempPaths;
int temp_index = 0;
double **Mat;
double *Value, *tempValue;
int globalValue_index, stay_in_global_times = 0;
double globalValue;
int *globalPath;
// TSP节点数量
int N = 0;
// 适应值函数
double CalValue(int *p) { // read only
double t = 0;
for (int i = 1; i < N; ++i) {
t += Mat[p[i - 1]][p[i]];
}
t += Mat[p[N - 1]][0];
return t;
}
void initialPath(int *Path, int j);
void initialPaths();
void find_min(int first = 1);
// 自然选择
void select();
// 交配
void crossover(int *p1, int* p2);
// 变异
void mutation(int *Path);
//
void preserve(int *p1, int *p2, int v1, int v2);
int main() {
srand((unsigned)time(NULL));
ifstream cin("data.txt");
cin >> N;
Mat = new double *[N];
for (int i = 0; i < N; ++i) {
Mat[i] = new double[N];
}
// read data from data.txt
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
cin >> Mat[i][j];
}
}
// new Path...
Paths = new int*[LEN];
for (int i = 0; i < LEN; ++i) {
Paths[i] = new int[N];
}
tempPaths = new int*[tempLEN];
for (int i = 0; i < tempLEN; ++i) {
tempPaths[i] = new int[N];
}
Value = new double[LEN];
tempValue = new double[tempLEN];
globalPath = new int[N];
// end new Path...
initialPaths(); // initialize paths
while (true) {
temp_index = 0;
for (int i = 0; i < LEN; i++) {
if (temp_index >= tempLEN) break;
preserve(Paths[i], NULL, Value[i], NULL);
for (int j = i+1; j < LEN; ++j) {
if (temp_index >= tempLEN) break;
if (RANDFLOAT() < pc) crossover(Paths[i], Paths[j]);
}
}
for (int i = 0; i < LEN; ++i) {
if (temp_index >= tempLEN) break;
if (RANDFLOAT() < pm) mutation(Paths[i]);
}
select();
if (stay_in_global_times == 10) { break; }
}
cout << globalValue << endl;
for (int i = 0; i < N; ++i) {
cout << globalPath[i] << " --> ";
}
// delete Path...
delete[]tempValue;
delete[]Value;
for (int i = 0; i < tempLEN; ++i) {
delete[]tempPaths[i];
}
delete[] tempPaths;
for (int i = 0; i < LEN; ++i) {
delete[]Paths[i];
}
delete[] Paths;
for (int i = 0; i < N; ++i) {
delete[] Mat[i];
}
delete[]Mat;
system("pause");
}
// preserve the parents.
void preserve(int *p1, int *p2, int v1, int v2) {
for (int i = 0; i < N; ++i) {
tempPaths[temp_index][i] = p1[i];
}
tempValue[temp_index] = v1;
//if (tempValue[temp_index] < 0) cout << "wrong\n";
temp_index++;
if (p2 != NULL) {
for (int i = 0; i < N; ++i) {
tempPaths[temp_index][i] = p2[i];
}
tempValue[temp_index] = v2;
//if (tempValue[temp_index] < 0) cout << "wrong\n";
temp_index++;
}
}
struct enumate{
double data;
int index;
bool operator < (const enumate& e) const {
return data < e.data;
}
};
vector<int> argsort_temp_value() {
enumate * data = new enumate[temp_index];
for (int i = 0; i < temp_index; ++i) {
data[i].data = tempValue[i];
data[i].index = i;
}
sort(data, data +temp_index);
vector<int> ans(temp_index);
for (int i = 0; i < temp_index; ++i) ans[i] = data[i].index;
delete[]data;
return ans;
}
void select() {
vector<int> id = argsort_temp_value();
for (int i = 0; i < temp_index; ++i) if (tempValue[i] < 0)cout << tempValue[i] << endl;
for (int i = 0; i < LEN; ++i) {
Value[i] = tempValue[id[i]];
for (int j = 0; j < N; ++j) {
Paths[i][j] = tempPaths[id[i]][j];
}
}
if (Value[0] < globalValue) {
for (int i = 0; i < N; ++i) globalPath[i] = Paths[0][i];
stay_in_global_times = 0;
globalValue = Value[0];
}
else if (Value[0] == globalValue) {
stay_in_global_times++;
}
else {
cout << "Something wrong" << Value[0]<< endl;
}
}
// 基于次序的交配方式
void crossover(int * p1, int * p2)
{
// generate son from p1 and p2
int crossn = RAND(0, N-1);
if (crossn == 0) return;
int * indexs = new int[crossn];
for (int i = 0; i < crossn; ++i) {
if (i == 0) indexs[i] = RAND(1, N - crossn + 1);
else {
indexs[i] = RAND(indexs[i - 1] + 1, N - crossn + i + 1);
}
}
// copy from p2
for (int i = 0; i < N; ++i) {
tempPaths[temp_index][i] = p2[i];
}
int use_count = 0;
for (int i = 0; i < N; ++i) {
if (use_count == crossn) break;
for (int j = 0; j < crossn; ++j) {
if (tempPaths[temp_index][i] == p1[indexs[j]]) {
tempPaths[temp_index][i] = p1[indexs[use_count]];
use_count++;
break;
}
}
}
// cal value
tempValue[temp_index] = CalValue(tempPaths[temp_index]);
temp_index++;
// copy from p1
for (int i = 0; i < N; ++i) {
tempPaths[temp_index][i] = p1[i];
}
use_count = 0;
for (int i = 0; i < N; ++i) {
if (use_count == crossn) break;
for (int j = 0; j < crossn; ++j) {
if (tempPaths[temp_index][i] == p2[indexs[j]]) {
tempPaths[temp_index][i] = p2[indexs[use_count]];
use_count++;
break;
}
}
}
tempValue[temp_index] = CalValue(tempPaths[temp_index]);
temp_index++;
delete[] indexs;
}
// 基于次序的变异
void mutation(int * Path)
{
int a = RAND(1, N), b, t;
if (a == N - 1) {
b = RAND(1, N - 1);
t = a;
a = b;
b = t;
}
else {
b = RAND(a + 1, N);
}
for (int i = 0; i < N; ++i) {
if (i == a)
tempPaths[temp_index][i] = Path[b];
else if ( i == b )
tempPaths[temp_index][i] = Path[a];
else tempPaths[temp_index][i] = Path[i];
}
tempValue[temp_index] = CalValue(tempPaths[temp_index]);
temp_index++;
}
void initialPaths() {
for (int i = 0; i < LEN; ++i)
initialPath(Paths[i], i);
find_min();
}
void find_min(int first)
{
int temp = 0;
for (int i = 1; i < LEN; ++i)
if (Value[temp] > Value[i]) temp = i;
if (first) {
globalValue = Value[temp];
for (int i = 0; i < N; ++i)
globalPath[i] = Paths[temp][i];
}
else if (Value[temp] < globalValue) {
globalValue = Value[temp];
for (int i = 0; i < N; ++i)
globalPath[i] = Paths[temp][i];
}
}
void initialPath(int *Path, int j) {
for (int i = 0; i < N; ++i) {
Path[i] = i;
}
// Path[i]表示路上第i个点的标记为Path[i]
// Path[0] = 0
int tx, t;
for (int i = 1; i < N - 1; ++i) {
tx = RAND(i, N);
if (tx != i) { // swap
t = Path[i];
Path[i] = Path[tx];
Path[tx] = t;
}
}
Value[j] = CalValue(Path);
}