遗传算法第一次提出来是在什么文献中

《搜索、优化和机器学习中的遗传算法》。

遗传算法（Genetic Algorithm，GA）最早是由美国的 John holland于20世纪70年代提出,该算法是根据大自然中生物体进化规律而设计提出的。是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。

遗传算法的基本运算过程如下：

（1）初始化：设置进化代数计数器t=0，设置最大进化代数T，随机生成M个个体作为初始群体P(0)。

（2）个体评价：计算群体P(t)中各个个体的适应度。

（3）选择运算：将选择算子作用于群体。选择的目的是把优化的个体直接遗传到下一代或通过配对交叉产生新的个体再遗传到下一代。选择 *** 作是建立在群体中个体的适应度评估基础上的。

（4）交叉运算：将交叉算子作用于群体。遗传算法中起核心作用的就是交叉算子。

（5）变异运算：将变异算子作用于群体。即是对群体中的个体串的某些基因座上的基因值作变动。群体P(t)经过选择、交叉、变异运算之后得到下一代群体P(t+1)。

（6）终止条件判断：若t=T,则以进化过程中所得到的具有最大适应度个体作为最优解输出，终止计算。

为了方便我只求了-314到314之间的最大值，你可以自己改一下，不过范围大了之后，种群也因该扩大，我的种群只有66个

结果：极值点（-3141593，5141593）

我又算了一下-100到100之间的极大值

结果：极值点（-97399473,99394504)

-1000到1000之间的极大值

结果：（999，1001）

-2000到2000之间的极大值

结果：（1998053550，2000053163）

以上结果我用matlab画图验证了，没问题。

希望再给加点分，呵呵

//中国电子科技集团公司

//第一研究室

//呼文韬

//hu_hu605@163com

//随机初始种群

//编码方式为格雷码

//选择方法为随机遍历

//采用了精英保存策略

//采用了自适应的交叉率和变异率

//采用了与模拟退火算法相结合的尺度变换

//采用了均匀交叉法

#include <stdlibh>

#include <stdioh>

#include <mathh>

#include <iostreamh>

#include <iomaniph>

#include <timeh>

#include <windowsh>

#define IM1 2147483563

#define IM2 2147483399

#define AM (10/IM1)

#define IMM1 (IM1-1)

#define IA1 40014

#define IA2 40692

#define IQ1 53668

#define IQ2 52774

#define IR1 12211

#define IR2 3791

#define NTAB 32

#define NDIV (1+IMM1/NTAB)

#define EPS 12e-7

#define RNMX (10-EPS)

#define zhizhenjuli 0005

#define PI 314159265358

#define T0 100000//温度要取得很高才行。

#define zhongqunshu1 200

#define zuobianjie -2000

#define youbianjie 2000

unsigned int seed=0; //seed 为种子，要设为全局变量

void mysrand(long int i) //初始化种子

{

seed = -i;

}

long a[1];

//double hundun;

//double c=4;

//设置全局变量

struct individual

{

unsigned chrom; //染色体；

double geti;//变量值

double shiyingdu; //目标函数的值；

double fitness; //变换后的适应度值；

};

individual zuiyougeti;//精英保存策略

int zhongqunshu; //种群大小

individual nowpop;//当前代

individual newpop;//新一代

double sumfitness;//当代的总适应度fitness

double sumshiyingdu;//当代的总适应度shiyingdu

double maxfitness;//最大适应度

double avefitness;//平均适应度

double maxshiyingdu;//最大适应度

double avgshiyingdu;//平均适应度

float pc;//交叉概率

float pm;//变异概率

int lchrom;//染色体长度

int maxgen;//最大遗传代数

int gen;//遗传代数

//函数

int flipc(double ,double );//判断是否交叉

int flipm(double );//判断是否变异

int rnd(int low,int high);//产生low与high之间的任意数

void initialize();//遗传算法初始化

void preselectfitness(); //计算sumfiness,avefitness,maxfitness

void generation();

double suijibianli();//产生随机遍历指针

int fuzhi(float );//选择要复制的个体

void crossover(individual ,individual ,individual &,individual &);//交叉

void bianyi(individual &);//变异

void mubiaohanshu(individual &);//计算适应度

void chidubianhuan(individual &);//对shiyingdu进行尺度变换赋给fitness

double ran1(long );//随机数初始

void bianma(double bianliang,unsigned p);//编码

double yima(unsigned p);

void guanjiancanshujisuan();//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness

void jingyingbaoliu();

void glp(int n,int s,int ,int ()[1],float ()[1]);//glp生成函数

BOOL Exist(int Val, int Num, int Array);//判断一个数在前面是否出现过

int cmpfitness(const void p1,const void p2)

{

float i=((individual )p1)->shiyingdu;//现在是按照"适应度"排序，改成"个体"的话就是按照"个体"排序

float j=((individual )p2)->shiyingdu;

return i<j -1:(i==j 0:1);//现在是按升序牌排列，将1和-1互换后就是按降序排列

}

void main()

{

initialize();

cout<<zuiyougeti->geti<<" "<<zuiyougeti->shiyingdu<<endl;/////////////

for(gen=1;gen<maxgen;gen++)

{ generation();

}

jingyingbaoliu();

cout<<setiosflags(ios::fixed)<<setprecision(6)<<zuiyougeti->geti<<" "<<setiosflags(ios::fixed)<<setprecision(6)<<(zuiyougeti->shiyingdu)<<endl;////////////////

delete [] newpop;

delete [] nowpop;

delete [] zuiyougeti;

system("pause");

}

void initialize()

{

int q[zhongqunshu1][1],s=1;

float xx[zhongqunshu1][1];//生成的glp用x储存

int h[1]={1};//生成向量

zuiyougeti=new individual;//最优个体的生成

zhongqunshu=200;//种群数量

nowpop=new individual[zhongqunshu1];//当代

newpop=new individual[zhongqunshu1];//新一代

maxgen=150;//最大代数

gen=0;//起始代

lchrom=22;//基因数量的初始化

mysrand(time(0));//随机数种子

a[0]=seed;//随机数种子

//对最优个体的初始化

zuiyougeti->geti=0;

zuiyougeti->fitness=0;

zuiyougeti->shiyingdu=0;

//

glp(zhongqunshu,s,h,q,xx);

//for(int i=0;i<zhongqunshu1;i++)//产生初始种群

//{

// for(int j=0;j<s;j++)

// {

// nowpop[i]geti=zuobianjie+(youbianjie-zuobianjie)xx[i][j];

// }

//}

for(int i=0;i<zhongqunshu1;i++)//产生初始种群

{

nowpop[i]geti=zuobianjie+(youbianjie-(zuobianjie))ran1(a);

}

//nowpop[0]geti=999;//////////////////////////

guanjiancanshujisuan();

jingyingbaoliu(); //精英保留的实现

guanjiancanshujisuan();//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness

}

void jingyingbaoliu() //精英保留的实现

{

individual zuiyougetiguodu;

zuiyougetiguodu=new individual[zhongqunshu1];//建立一个过渡数组

for(int i=0;i<zhongqunshu;i++)//将当代个体复制到过渡数组中

zuiyougetiguodu[i]=nowpop[i];

qsort(zuiyougetiguodu,zhongqunshu1,sizeof(individual),&cmpfitness);//按fitness升序排序

// cout<<"zuiyougetiguodu适应度:"<<zuiyougetiguodu[zhongqunshu1-1]shiyingdu<<endl;///////////

// cout<<"zuiyougeti适应度:"<<zuiyougeti->shiyingdu<<endl;///////////////////

//system("pause");

if(zuiyougetiguodu[zhongqunshu-1]shiyingdu>zuiyougeti->shiyingdu)

{

zuiyougeti=zuiyougetiguodu[zhongqunshu1-1];//如果最优个体的fitness比当代最大的fitness小则用当代的代替之

//cout<<"zuiyougetiguodu个体:"<<zuiyougetiguodu[zhongqunshu1-1]geti<<endl;/////////////

//cout<<"zuiyougeti个体:"<<zuiyougeti->geti<<endl;/////////////

}

else

nowpop[rnd(0,(zhongqunshu1-1))]=zuiyougeti;//否则的话从当代中随机挑选一个用最优个体代替之

delete [] zuiyougetiguodu;//释放过渡数组

}

void guanjiancanshujisuan()//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness

{

for(int i=0;i<zhongqunshu;i++)//计算shiyingdu

mubiaohanshu(nowpop[i]);

for(i=0;i<zhongqunshu;i++)//对shiyingdu进行尺度变换变成fitness

chidubianhuan(nowpop[i]);

preselectfitness();//根据fitness计算sumfitness，avefitness，maxfitness

}

void mubiaohanshu(individual &bianliang)//计算shiyingdu

{

bianliangshiyingdu=(bianlianggeticos(bianlianggeti)+20);//目标函数

}

void chidubianhuan(individual &bianliang)//对shiyingdu进行尺度变换变成fitness

{

double T;//退火温度

T=T0(pow(099,(gen+1-1)));

double sum=0;

for(int j=0;j<zhongqunshu;j++)

sum+=exp(nowpop[j]shiyingdu/T);

bianliangfitness=exp(bianliangshiyingdu/T)/sum;//算出fitness

}

void preselectfitness()//根据fitness计算sumfitness，avefitness，maxfitness

{

int j;

sumfitness=0;

for(j=0;j<zhongqunshu;j++)

sumfitness+=nowpop[j]fitness;

individual guodu;

guodu=new individual[zhongqunshu1];

for(j=0;j<zhongqunshu;j++)

guodu[j]=nowpop[j];

qsort(guodu,zhongqunshu1,sizeof(individual),&cmpfitness);

maxfitness=guodu[zhongqunshu1-1]fitness;

avefitness=sumfitness/zhongqunshu1;

delete [] guodu;

}

void generation()

{

individual fuqin1,fuqin2,pipeiguodu,pipeichi;

int peiduishuzu;//用来存放产生的随机配对

pipeiguodu=new individual[zhongqunshu1];

pipeichi=new individual[zhongqunshu1];

peiduishuzu=new int[zhongqunshu1];

int member1,member2,j=0,fuzhijishu=0,i=0,temp=0,tt=0;

float zhizhen;

//随机遍历的实现

for(zhizhen=suijibianli();zhizhen<1;(zhizhen=zhizhen+zhizhenjuli))//设定指针1/66

{

pipeichi[fuzhijishu]=nowpop[fuzhi(zhizhen)];

fuzhijishu++;

}

//交叉与变异的实现

//交叉

for(i=0;i<zhongqunshu1;i++)

{

peiduishuzu[i]=-1;

}

for (i=0; i<zhongqunshu1; i++)

{

temp =rnd(0,zhongqunshu1-1); //产生值在0-zhongqunshu1-1的随机数

while(Exist(temp, i, peiduishuzu))//判断产生的随机数是否已经产生过，如果是，则再产生一个随机数

{

temp =rnd(0,zhongqunshu1-1);

}

//如果没有的话，则把产生的随机数放在peiduishuzu中

(peiduishuzu+i) = temp;

}

for(i=0;i<zhongqunshu1-1;i=i+2)

{

fuqin1=pipeichi[peiduishuzu[i]];

fuqin2=pipeichi[peiduishuzu[i+1]];

crossover(fuqin1,fuqin2,newpop[i],newpop[i+1]);

}

for(j=0;j<zhongqunshu1;j++)

{

//if(newpop[j]geti<-1000)

//cout<<"个体数值小于下界了";

nowpop[j]geti=newpop[j]geti;

}

//

guanjiancanshujisuan();

//变异的实现

for(j=0;j<zhongqunshu;j++)

{

bianyi(nowpop[j]);

}

//

guanjiancanshujisuan();

//精英保留的实现

jingyingbaoliu();

//

guanjiancanshujisuan();

delete [] peiduishuzu;

delete [] pipeichi;

delete [] pipeiguodu;

}

void crossover(individual parent1,individual parent2,individual &child1,individual &child2)//交叉

{

int j;

unsigned panduan;

panduan=new unsigned[lchrom];

parent1chrom=new unsigned[lchrom];

parent2chrom=new unsigned[lchrom];

child1chrom=new unsigned[lchrom];

child2chrom=new unsigned[lchrom];

//cout<<"jiaocha"<<endl;///////////////////////

bianma(parent1geti,parent1chrom);

bianma(parent2geti,parent2chrom);

if(flipc(parent1fitness,parent2fitness))

{

for(j=0;j<lchrom;j++)

panduan[j]=rnd(0,1);

//for(j=0;j<lchrom;j++)////////////////

// {

// cout<<panduan[j];/////////////

// }

// cout<<endl;////////////////

// system("pause");////////////////

for(j=0;j<lchrom;j++)

{

if(panduan[j]==1)

child1chrom[j]=parent1chrom[j];

else

child1chrom[j]=parent2chrom[j];

}

for(j=0;j<lchrom;j++)

{

if(panduan[j]==0)

child2chrom[j]=parent1chrom[j];

else

child2chrom[j]=parent2chrom[j];

}

//for(j=0;j<lchrom;j++)////////////////

//{

// cout<<child1chrom[j];/////////////

// }

//cout<<endl;////////////////

// system("pause");////////////////

child1geti=yima(child1chrom);

child2geti=yima(child2chrom);

delete [] child2chrom;

delete [] child1chrom;

delete [] parent2chrom;

delete [] parent1chrom;

delete [] panduan;

}

else

{

for(j=0;j<lchrom;j++)

{

child1chrom[j]=parent1chrom[j];

child2chrom[j]=parent2chrom[j];

}

child1geti=yima(child1chrom);

child2geti=yima(child2chrom);

delete [] child2chrom;

delete [] child1chrom;

delete [] parent2chrom;

delete [] parent1chrom;

delete [] panduan;

}

}

void bianyi(individual &child)//变异

{

childchrom=new unsigned[lchrom];

//cout<<"变异"<<endl;

bianma(childgeti,childchrom);

for(int i=0;i<lchrom;i++)

if(flipm(childfitness))

{

if(childchrom[i]=0)

childchrom[i]=1;

else

childchrom[i]=0;

}

childgeti=yima(childchrom);

delete [] childchrom;

}

void bianma(double bianliang,unsigned p)//编码

{

unsigned q;

unsigned gray;

q=new unsigned[lchrom];

gray=new unsigned[lchrom];

int x=0;

int i=0,j=0;

if(bianliang<zuobianjie)///////////////////

{

cout<<"bianliang:"<<bianliang<<endl;/////////

system("pause");

}

//cout<<youbianjie-(zuobianjie)<<endl;

//system("pause");

x=(bianliang-(zuobianjie))((pow(2,lchrom)-1)/(youbianjie-(zuobianjie)));

//cout<<x<<endl;///////////

if(x<0)

system("pause");///////////

for(i=0;i<lchrom;i++)

{

q[i]=0;

p[i]=0;

}

i=0;

while (x!=0&&(i!=lchrom))

{

q[i]=(unsigned)(x%2);

x=x/2;

i++;

}

// for(i=0;i<lchrom;i++)//////////////////

// cout<<q[i];///////////////

// cout<<endl;///////////

int w=lchrom-1;

if(q[w]!=0&&q[w]!=1)

system("pause");

for(j=0;j<lchrom&&w>0;j++)

{

p[j]=q[w];

w--;

}

//cout<<"yuanma"<<endl;

//for(j=0;j<lchrom;j++)///////////

// cout<<p[j];////////

//cout<<endl;////////////////////

gray[0]=p[0];

for(j=1;j<lchrom;j++)

{

if(p[j-1]==p[j])

gray[j]=0;

else if(p[j-1]!=p[j])

gray[j]=1;

}

for(j=0;j<lchrom;j++)

p[j]=gray[j];

//cout<<"geleima"<<endl;

//for(j=0;j<lchrom;j++)///////////

// cout<<p[j];////////

//cout<<endl;////////////////////

//system("pause");///////////

delete [] gray;

delete [] q;

}

double yima(unsigned p) //译码

{

int i=0;

// for(i=0;i<lchrom;i++)/////////

// {

// cout<<p[i];//////

// }

// cout<<endl;/////////

// system("pause");//////////

int x=0;

unsigned q;

q=new unsigned[lchrom];

q[0]=p[0];

// cout<<q[0]<<endl;//////////////////

// system("pause");//////////

for(int j=1;j<lchrom;j++)

{

if(q[j-1]==p[j])

q[j]=0;

else if(q[j-1]!=p[j])

q[j]=1;

}

// for(i=0;i<lchrom;i++)//////

// {

// cout<<q[i];//////////

// if(q[i]!=0&&q[i]!=1)

// {

// cout<<q[i];

// system("pause");

// }

// }

// cout<<endl;////////

// system("pause");///////////////////

for(i=0;i<lchrom;i++)

x=x+q[i]pow(2,(lchrom-i-1));

if(x<0)

{

cout<<"译码出错1"<<endl;

system("pause");

}

//cout<<"x:"<<x<<endl;

double bianliang;

//cout<<pow(2,22)<<endl;

//cout<<2000x<<endl;

//cout<<(x(2000/(pow(2,22)-1)))<<endl;

bianliang=(x((youbianjie-(zuobianjie))/(pow(2,lchrom)-1)))+zuobianjie;

if(bianliang<zuobianjie)

{

cout<<"译码出错2"<<endl;

system("pause");

}

delete [] q;

return bianliang;

}

double ran1(long idum)

{

int j;

long k;

static long idum2=123456789;

static long iy=0;

static long iv[NTAB];

float temp;

if (idum <= 0)

{

if (-(idum) < 1) idum=1;

else idum = -(idum);

idum2=(idum);

for (j=NTAB+7;j>=0;j--)

{

k=(idum)/IQ1;

idum=IA1(idum-kIQ1)-kIR1;

if (idum < 0) idum += IM1;

if (j < NTAB) iv[j] = idum;

}

iy=iv[0];

}

k=(idum)/IQ1;

idum=IA1(idum-kIQ1)-kIR1;

if (idum < 0) idum += IM1;

k=idum2/IQ2;

idum2=IA2(idum2-kIQ2)-kIR2;

if (idum2 < 0) idum2 += IM2;

j=iy/NDIV;

iy=iv[j]-idum2;

iv[j] = idum;

if (iy < 1) iy += IMM1;

if ((temp=AMiy) > RNMX) return RNMX;

else return temp;

}

double suijibianli()//随机遍历

{

double i=ran1(a);

while(i>zhizhenjuli)

{

i=ran1(a);

}

//cout<<i<<endl;//////////////

return i;

}

int fuzhi(float p)//复制

{

int i;

double sum=0;

if(sumfitness!=0)

{

for(i=0;(sum<p)&&(i<zhongqunshu);i++)

sum+=nowpop[i]fitness/sumfitness;

}

else

i=rnd(1,zhongqunshu1);

return(i-1);

}

int rnd(int low, int high) /在整数low和high之间产生一个随机整数/

{

int i;

if(low >= high)

i = low;

else

{

i =(int)((ran1(a) (high - low + 1)) + low);

if(i > high) i = high;

}

return(i);

}

int flipc(double p,double q)//判断是否交叉

{

double pc1=09,pc2=06;

if((p-q)>0)

{

if(p>=avefitness)

{

pc=pc1-(pc1-pc2)(p-avefitness)/(maxfitness-avefitness);

}

else

pc=pc1;

}

else

{

if(q>=avefitness)

{

pc=pc1-(pc1-pc2)(q-avefitness)/(maxfitness-avefitness);

}

else

pc=pc1;

}

if(ran1(a)<=pc)

return(1);

else

return(0);

}

int flipm(double p)//判断是否变异

{

double pm1=0001,pm2=00001;

if(p>=avefitness)

{

pm=(pm1-(pm1-pm2)(maxfitness-p)/(maxfitness-avefitness));

}

else

pm=pm1;

if(ran1(a)<=pm)

return(1);

else

return(0);

}

void glp(int n,int s,int h,int (q)[1],float (xx)[1])//glp

{

int i=0,j=0;

//求解q

for(i=0;i<n;i++)

{

for(j=0;j<s;j++)

{

((q+i)+j)=((i+1)((h+j)))%n;

}

}

i=n-1;

for(j=0;j<s;j++)

{

((q+i)+j)=n;

}

//求解x

for(i=0;i<n;i++)

{

for(j=0;j<s;j++)

{

((xx+i)+j)=(float)(2(((q+i)+j))-1)/(2n);

}

}

}

BOOL Exist(int Val, int Num, int Array)//判断一个数是否在一个数组的前Num个数中

{

BOOL FLAG = FALSE;

int i;

for (i=0; i<Num; i++)

if (Val == (Array + i))

{

FLAG = TRUE;

break;

}

return FLAG;

}

遗传算法也是计算机科学人工智能领域中用于解决最优化的一种搜索启发式算法，是进化算法的一种。这种启发式通常用来生成有用的解决方案来优化和搜索问题。进化算法最初是借鉴了进化生物学中的一些现象而发展起来的，这些现象包括遗传、突变、自然选择以及杂交等。

遗传算法在适应度函数选择不当的情况下有可能收敛于局部最优，而不能达到全局最优。遗传算法的这些性质，已被人们广泛地应用于组合优化、机器学习、信号处理、自适应控制和人工生命等领域。

第1章 绪论

11 神经网络在石油生产中的应用简介

12 神经网络的研究与发展历史

13 储层预测的研究与进展

14 神经网络模式识别概述

15 遗传算法研究与发展概述

16 模拟退火算法的研究和发展概况

17 支持向量机的研究与进展

18 本书的主要研究内容及章节安排

第2章 人工神经网络

21 引言

22 神经元模型

23 神经网络模型

24 感知器

25 误差回传神经网络(BP)

26 神经网络的优点

27 本章小结

第3章 改进遗传算法的径向基函数网络方法研究及应用

31 引言

32 径向基函数网络

33 遗传算法

34 自适应遗传算法(AGA)基本原理

35 基于改进遗传算法的径向基函数网络

36 改进的遗传算法径向基函数网络的应用

37 本章小结

第4章 小波变换及小波神经网络方法研究及应用

41 引言

42 小波分析

43 小波变换模极大检测地震反射界面

44 小波神经网络

45 小波神经网络的应用一

46 本章小结

第5章 模糊神经网络方法研究及应用

51 引言

52 模糊理论

53 模糊关系和模糊逻辑推理

54 模糊逻辑系统

55 模糊系统和神经网络的融合

56 模糊神经网络

57 用于火山岩储层识别预测的模糊神经网络

58 基于模糊神经网络的火山岩储层的识别与预测

59 基于模糊神经网络多传感器数据融合的海底输油管道腐蚀检测系统

51 0本章小结

第6章 改进的模拟退火人工神经网络方法研究及应用

61 引言

62 模拟退火算法及其特性

63 模拟退火算法的渐近收敛性

64 模拟退火算法与局部搜索算法比较

65 鲍威尔(P0well)算法

66 改进的模拟退火人工神经网络

67 改进的模拟退火人工神经网络应用

68 算法比较

69 本章小结

第7章 支持向量机方法研究及应用

71 引言

72 机器学习的基本问题和方法

73 统计学习理论的主要内容

74 分类支持向量机

75 回归支持向量机

76 支持向量机的应用

77 本章小结

第8章 结论

参考文献

遗传算法在很多领域都得到应用；从神经网络研究的角度上考虑，最关心的是遗传算法在神经网络的应用。在遗传算法应用中，应先明确其特点和关键问题，才能对这种算法深入了解，灵活应用，以及进一步研究开发。一、遗传算法的特点 1．遗传算法从问题解的中集开始嫂索，而不是从单个解开始。这是遗传算法与传统优化算法的极大区别。传统优化算法是从单个初始值迭代求最优解的；容易误入局部最优解。遗传算法从串集开始搜索，复盖面大，利于全局择优。 2．遗传算法求解时使用特定问题的信息极少，容易形成通用算法程序。由于遗传算法使用适应值这一信息进行搜索，并不需要问题导数等与问题直接相关的信息。遗传算法只需适应值和串编码等通用信息，故几乎可处理任何问题。 3．遗传算法有极强的容错能力遗传算法的初始串集本身就带有大量与最优解甚远的信息；通过选择、交叉、变异 *** 作能迅速排除与最优解相差极大的串；这是一个强烈的滤波过程；并且是一个并行滤波机制。故而，遗传算法有很高的容错能力。 4．遗传算法中的选择、交叉和变异都是随机 *** 作，而不是确定的精确规则。这说明遗传算法是采用随机方法进行最优解搜索，选择体现了向最优解迫近，交叉体现了最优解的产生，变异体现了全局最优解的复盖。 5．遗传算法具有隐含的并行性

种群规模是指任意一代中的个体总数，这个是人为设定的，种群规模越大越可能找到全局解，但运行时间也相对较长，一般在40-100之间取值，像我就习惯选60

至于你所处理的问题，可以对比不同的种群规模下最优解和运行时间，然后折衷取。

：

遗传算法（Genetic Algorithm，GA）最早是由美国的 John holland于20世纪70年代提出，该算法是根据大自然中生物体进化规律而设计提出的。是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。该算法通过数学的方式，利用计算机仿真运算，将问题的求解过程转换成类似生物进化中的染色体基因的交叉、变异等过程。在求解较为复杂的组合优化问题时，相对一些常规的优化算法，通常能够较快地获得较好的优化结果。遗传算法已被人们广泛地应用于组合优化、机器学习、信号处理、自适应控制和人工生命等领域。

运算过程

遗传算法的基本运算过程如下：

（1）初始化：设置进化代数计数器t=0，设置最大进化代数T，随机生成M个个体作为初始群体P(0)。

（2）个体评价：计算群体P(t)中各个个体的适应度。

（3）选择运算：将选择算子作用于群体。选择的目的是把优化的个体直接遗传到下一代或通过配对交叉产生新的个体再遗传到下一代。选择 *** 作是建立在群体中个体的适应度评估基础上的。

（4）交叉运算：将交叉算子作用于群体。遗传算法中起核心作用的就是交叉算子。[2]

（5）变异运算：将变异算子作用于群体。即是对群体中的个体串的某些基因座上的基因值作变动。群体P(t)经过选择、交叉、变异运算之后得到下一代群体P(t+1)。

（6）终止条件判断：若t=T，则以进化过程中所得到的具有最大适应度个体作为最优解输出，终止计算。

遗传 *** 作包括以下三个基本遗传算子(genetic operator):选择(selection)；交叉(crossover)；变异(mutation)。

优点：对再难的问题都可以给出一个解，即适用范围广，都能得到满意解；

缺点：速度慢，会出现早熟现象，一般获得最优解很难；

即通用算法，范围广，但效率赶不上专用算法。

为了保证在较大的搜索范围寻找最优解，必须保证种群的多样性，种群的多样性，可以从选择算子、交叉算子和变异算子做起，初学者选择算子可以用轮盘赌的较多，不过这个容易出现适应度高的个体垄断的现象，较好的选择算子有无回放随即选择（网上有资料）等；交叉算子改进的有自适应交叉算子，这个网上有；变异的有自适应变异算子；交叉算子改进的是全局搜索能力，变异算子改进的时局部搜索能力。通过设计好的上面三种算子可以保证种群多样性，避免早熟现象，从而得到满意的最优解。

以上就是关于遗传算法第一次提出来是在什么文献中全部的内容，包括:遗传算法第一次提出来是在什么文献中、求助：人工智能“遗传算法求解f(x)=xcosx+2的最大值”、遗传算法属于哪种人工智能技术范畴等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！