人工智慧遺傳演算法

❶ 求助：人工智慧「遺傳演算法求解f(x)=xcosx+2的最大值」

為了方便我只求了-3.14到3.14之間的最大值，你可以自己改一下，不過范圍大了之後，種群也因該擴大，我的種群只有66個

結果：極值點（-3.141593，5.141593）

我又算了一下-100到100之間的極大值

結果：極值點（-97.399473,99.394504)

-1000到1000之間的極大值

結果：（999，1001）

-2000到2000之間的極大值

結果：（1998.053550，2000.053163）

以上結果我用matlab畫圖驗證了，沒問題。
希望再給加點分，呵呵

//中國電子科技集團公司

//第一研究室

//呼文韜

//[email protected]

//隨機初始種群
//編碼方式為格雷碼
//選擇方法為隨機遍歷
//採用了精英保存策略
//採用了自適應的交叉率和變異率
//採用了與模擬退火演算法相結合的尺度變換
//採用了均勻交叉法

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <iostream.h>
#include <iomanip.h>
#include <time.h>
#include <windows.h>
#define IM1 2147483563
#define IM2 2147483399
#define AM (1.0/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 1.2e-7
#define RNMX (1.0-EPS)
#define zhenjuli 0.005
#define PI 3.14159265358
#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 hunn;
//double c=4;
//設置全局變數
struct indivial
{
unsigned *chrom; //染色體；
double geti;//變數值
double shiying; //目標函數的值；
double fitness; //變換後的適應度值；
};
indivial *zuiyougeti;//精英保存策略
int zhongqunshu; //種群大小
indivial *nowpop;//當前代
indivial *newpop;//新一代
double sumfitness;//當代的總適應度fitness
double sumshiying;//當代的總適應度shiying
double maxfitness;//最大適應度
double avefitness;//平均適應度
double maxshiying;//最大適應度
double avgshiying;//平均適應度
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 fu(float );//選擇要復制的個體
void crossover(indivial ,indivial ,indivial &,indivial &);//交叉
void bianyi(indivial &);//變異
void mubiaohanshu(indivial &);//計算適應度
void chibianhuan(indivial &);//對shiying進行尺度變換賦給fitness
double ran1(long *);//隨機數初始
void bianma(double bianliang,unsigned *p);//編碼
double yima(unsigned *p);
void guanjiancanshujisuan();//計算shiying,根據shiying計算sumshiying,對shiying進行尺度變換變成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=((indivial *)p1)->shiying;//現在是按照"適應度"排序，改成"個體"的話就是按照"個體"排序
float j=((indivial *)p2)->shiying;
return i<j ? -1:(i==j ? 0:1);//現在是按升序牌排列，將1和-1互換後就是按降序排列
}
void main()
{
initialize();
cout<<zuiyougeti->geti<<" "<<zuiyougeti->shiying<<endl;/////////////
for(gen=1;gen<maxgen;gen++)
{ generation();
}
jingyingbaoliu();
cout<<setiosflags(ios::fixed)<<setprecision(6)<<zuiyougeti->geti<<" "<<setiosflags(ios::fixed)<<setprecision(6)<<(zuiyougeti->shiying)<<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 indivial;//最優個體的生成
zhongqunshu=200;//種群數量
nowpop=new indivial[zhongqunshu1];//當代
newpop=new indivial[zhongqunshu1];//新一代
maxgen=150;//最大代數
gen=0;//起始代
lchrom=22;//基因數量的初始化
mysrand(time(0));//隨機數種子
a[0]=seed;//隨機數種子
//對最優個體的初始化
zuiyougeti->geti=0;
zuiyougeti->fitness=0;
zuiyougeti->shiying=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();//計算shiying,根據shiying計算sumshiying,對shiying進行尺度變換變成fitness,根據fitness計算sumfitness，avefitness，maxfitness
}
void jingyingbaoliu() //精英保留的實現
{
indivial *zuiyougetiguo;
zuiyougetiguo=new indivial[zhongqunshu1];//建立一個過渡數組
for(int i=0;i<zhongqunshu;i++)//將當代個體復制到過渡數組中
zuiyougetiguo[i]=nowpop[i];
qsort(zuiyougetiguo,zhongqunshu1,sizeof(indivial),&cmpfitness);//按fitness升序排序
// cout<<"zuiyougetiguo適應度:"<<zuiyougetiguo[zhongqunshu1-1].shiying<<endl;///////////
// cout<<"zuiyougeti適應度:"<<zuiyougeti->shiying<<endl;///////////////////
//system("pause");
if(zuiyougetiguo[zhongqunshu-1].shiying>zuiyougeti->shiying)
{
*zuiyougeti=zuiyougetiguo[zhongqunshu1-1];//如果最優個體的fitness比當代最大的fitness小則用當代的代替之
//cout<<"zuiyougetiguo個體:"<<zuiyougetiguo[zhongqunshu1-1].geti<<endl;/////////////
//cout<<"zuiyougeti個體:"<<zuiyougeti->geti<<endl;/////////////
}
else
nowpop[rnd(0,(zhongqunshu1-1))]=*zuiyougeti;//否則的話從當代中隨機挑選一個用最優個體代替之
delete [] zuiyougetiguo;//釋放過渡數組
}
void guanjiancanshujisuan()//計算shiying,根據shiying計算sumshiying,對shiying進行尺度變換變成fitness,根據fitness計算sumfitness，avefitness，maxfitness
{
for(int i=0;i<zhongqunshu;i++)//計算shiying
mubiaohanshu(nowpop[i]);
for(i=0;i<zhongqunshu;i++)//對shiying進行尺度變換變成fitness
chibianhuan(nowpop[i]);
preselectfitness();//根據fitness計算sumfitness，avefitness，maxfitness
}
void mubiaohanshu(indivial &bianliang)//計算shiying
{
bianliang.shiying=(bianliang.geti*cos(bianliang.geti)+2.0);//目標函數
}
void chibianhuan(indivial &bianliang)//對shiying進行尺度變換變成fitness
{
double T;//退火溫度
T=T0*(pow(0.99,(gen+1-1)));
double sum=0;
for(int j=0;j<zhongqunshu;j++)
sum+=exp(nowpop[j].shiying/T);
bianliang.fitness=exp(bianliang.shiying/T)/sum;//算出fitness
}
void preselectfitness()//根據fitness計算sumfitness，avefitness，maxfitness
{
int j;
sumfitness=0;
for(j=0;j<zhongqunshu;j++)
sumfitness+=nowpop[j].fitness;
indivial *guo;
guo=new indivial[zhongqunshu1];
for(j=0;j<zhongqunshu;j++)
guo[j]=nowpop[j];
qsort(guo,zhongqunshu1,sizeof(indivial),&cmpfitness);
maxfitness=guo[zhongqunshu1-1].fitness;
avefitness=sumfitness/zhongqunshu1;
delete [] guo;
}
void generation()
{
indivial fuqin1,fuqin2,*pipeiguo,*pipeichi;
int *peiishuzu;//用來存放產生的隨機配對
pipeiguo=new indivial[zhongqunshu1];
pipeichi=new indivial[zhongqunshu1];
peiishuzu=new int[zhongqunshu1];
int member1,member2,j=0,fujishu=0,i=0,temp=0,tt=0;
float zhen;
//隨機遍歷的實現
for(zhen=suijibianli();zhen<1;(zhen=zhen+zhenjuli))//設定指針1/66
{
pipeichi[fujishu]=nowpop[fu(zhen)];
fujishu++;
}

//交叉與變異的實現
//交叉
for(i=0;i<zhongqunshu1;i++)
{
peiishuzu[i]=-1;
}
for (i=0; i<zhongqunshu1; i++)
{
temp =rnd(0,zhongqunshu1-1); //產生值在0-zhongqunshu1-1的隨機數
while(Exist(temp, i, peiishuzu))//判斷產生的隨機數是否已經產生過，如果是，則再產生一個隨機數
{
temp =rnd(0,zhongqunshu1-1);
}
//如果沒有的話，則把產生的隨機數放在peiishuzu中
*(peiishuzu+i) = temp;
}
for(i=0;i<zhongqunshu1-1;i=i+2)
{
fuqin1=pipeichi[peiishuzu[i]];
fuqin2=pipeichi[peiishuzu[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 [] peiishuzu;
delete [] pipeichi;
delete [] pipeiguo;
}
void crossover(indivial parent1,indivial parent2,indivial &child1,indivial &child2)//交叉
{
int j;
unsigned *panan;
panan=new unsigned[lchrom];
parent1.chrom=new unsigned[lchrom];
parent2.chrom=new unsigned[lchrom];
child1.chrom=new unsigned[lchrom];
child2.chrom=new unsigned[lchrom];
//cout<<"jiaocha"<<endl;///////////////////////
bianma(parent1.geti,parent1.chrom);
bianma(parent2.geti,parent2.chrom);
if(flipc(parent1.fitness,parent2.fitness))
{
for(j=0;j<lchrom;j++)
panan[j]=rnd(0,1);
//for(j=0;j<lchrom;j++)////////////////
// {
// cout<<panan[j];/////////////
// }
// cout<<endl;////////////////
// system("pause");////////////////
for(j=0;j<lchrom;j++)
{
if(panan[j]==1)
child1.chrom[j]=parent1.chrom[j];
else
child1.chrom[j]=parent2.chrom[j];
}
for(j=0;j<lchrom;j++)
{
if(panan[j]==0)
child2.chrom[j]=parent1.chrom[j];
else
child2.chrom[j]=parent2.chrom[j];
}
//for(j=0;j<lchrom;j++)////////////////
//{
// cout<<child1.chrom[j];/////////////
// }
//cout<<endl;////////////////
// system("pause");////////////////
child1.geti=yima(child1.chrom);
child2.geti=yima(child2.chrom);
delete [] child2.chrom;
delete [] child1.chrom;
delete [] parent2.chrom;
delete [] parent1.chrom;
delete [] panan;
}
else
{
for(j=0;j<lchrom;j++)
{
child1.chrom[j]=parent1.chrom[j];
child2.chrom[j]=parent2.chrom[j];
}
child1.geti=yima(child1.chrom);
child2.geti=yima(child2.chrom);
delete [] child2.chrom;
delete [] child1.chrom;
delete [] parent2.chrom;
delete [] parent1.chrom;
delete [] panan;
}
}
void bianyi(indivial &child)//變異
{
child.chrom=new unsigned[lchrom];
//cout<<"變異"<<endl;
bianma(child.geti,child.chrom);
for(int i=0;i<lchrom;i++)
if(flipm(child.fitness))
{
if(child.chrom[i]=0)
child.chrom[i]=1;
else
child.chrom[i]=0;
}
child.geti=yima(child.chrom);
delete [] child.chrom;
}
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<<2000*x<<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 *im)
{
int j;
long k;
static long im2=123456789;
static long iy=0;
static long iv[NTAB];
float temp;
if (*im <= 0)
{
if (-(*im) < 1) *im=1;
else *im = -(*im);
im2=(*im);
for (j=NTAB+7;j>=0;j--)
{
k=(*im)/IQ1;
*im=IA1*(*im-k*IQ1)-k*IR1;
if (*im < 0) *im += IM1;
if (j < NTAB) iv[j] = *im;
}
iy=iv[0];
}
k=(*im)/IQ1;
*im=IA1*(*im-k*IQ1)-k*IR1;
if (*im < 0) *im += IM1;
k=im2/IQ2;
im2=IA2*(im2-k*IQ2)-k*IR2;
if (im2 < 0) im2 += IM2;
j=iy/NDIV;
iy=iv[j]-im2;
iv[j] = *im;
if (iy < 1) iy += IMM1;
if ((temp=AM*iy) > RNMX) return RNMX;
else return temp;
}
double suijibianli()//隨機遍歷
{
double i=ran1(a);
while(i>zhenjuli)
{
i=ran1(a);
}
//cout<<i<<endl;//////////////
return i;
}
int fu(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=0.9,pc2=0.6;
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=0.001,pm2=0.0001;
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)/(2*n);
}
}
}
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;
}

❷ 人工智慧的實現方法有哪些

人工智慧在計算機上實現時有2種不同的方式：

一種是採用傳統的編程技術，使系統呈現智能的效果，而不考慮所用方法是否與人或動物機體所用的方法相同。這種方法叫工程學方法(ENGINEERING APPROACH)，它已在一些領域內作出了成果，如文字識別、電腦下棋等。

另一種是模擬法(MODELING APPROACH)，它不僅要看效果，還要求實現方法也和人類或生物機體所用的方法相同或相類似。

遺傳演算法(GENERIC ALGORITHM，簡稱GA)和人工神經網路(ARTIFICIAL NEURAL NETWORK，簡稱ANN)均屬後一類型。遺傳演算法模擬人類或生物的遺傳-進化機制，人工神經網路則是模擬人類或動物大腦中神經細胞的活動方式。為了得到相同智能效果，兩種方式通常都可使用。採用前一種方法，需要人工詳細規定程序邏輯，如果游戲簡單，還是方便的。如果游戲復雜，角色數量和活動空間增加，相應的邏輯就會很復雜(按指數式增長)，人工編程就非常繁瑣，容易出錯。而一旦出錯，就必須修改原程序，重新編譯、調試，最後為用戶提供一個新的版本或提供一個新補丁，非常麻煩。採用後一種方法時，編程者要為每一角色設計一個智能系統(一個模塊)來進行控制，這個智能系統(模塊)開始什麼也不懂，就像初生嬰兒那樣，但它能夠學習，能漸漸地適應環境，應付各種復雜情況。這種系統開始也常犯錯誤，但它能吸取教訓，下一次運行時就可能改正，至少不會永遠錯下去，用不到發布新版本或打補丁。利用這種方法來實現人工智慧，要求編程者具有生物學的思考方法，入門難度大一點。但一旦入了門，就可得到廣泛應用。由於這種方法編程時無須對角色的活動規律做詳細規定，應用於復雜問題，通常會比前一種方法更省力。

❸ 人工智慧之進化演算法

進化計算的三大分支包括：遺傳演算法(Genetic Algorithm ，簡稱GA)、進化規劃(Evolu-tionary Programming，簡稱EP)和進化策略(Evolution Strategies ，簡稱ES)。這三個分支在演算法實現方面具有一些細微的差別，但它們具有一個共同的特點，即都是藉助生物進化的思想和原理來解決實際問題。

遺傳演算法是一類通過模擬生物界自然選擇和自然遺傳機制的隨機化搜索演算法，由美國Holand J教授於1975年首次提出。它是利用某種編碼技術作用於稱為染色體的二進制數串，其基本思想是模擬由這些串組成的種群的進化過程，通過有組織的、然而是隨機的信息交換來重新組合那些適應性好的串。遺傳演算法對求解問題的本身一無所知，它所需要的僅是對演算法所產生的每個染色體進行評價，並根據適應性來選擇染色體，使適應性好的染色體比適應性差的染色體有更多的繁殖機會。遺傳演算法尤其適用於處理傳統搜索方法難於解決的復雜的非線性問題，可廣泛用於組合優化、機器學習、自適應控制、規劃設計和人工生命等領域，是21世紀有關智能計算中的關鍵技術之一。

1964年，由德國柏林工業大學的RechenbergI等人提出。在求解流體動力學柔性彎曲管的形狀優化問題時，用傳統的方法很難在優化設計中描述物體形狀的參數，然而利用生物變異的思想來隨機地改變參數值並獲得了較好效果。隨後，他們便對這種方法進行了深入的研究和發展，形成了進化計算的另一個分支——進化策略。

進化策略與遺傳演算法的不同之處在於：進化策略直接在解空間上進行操作，強調進化過程中從父體到後代行為的自適應性和多樣性，強調進化過程中搜索步長的自適應性調節;而遺傳演算法是將原問題的解空間映射到位串空間之中，然後再施行遺傳操作，它強調個體基因結構的變化對其適應度的影響。

進化策略主要用於求解數值優化問題。

進化規劃的方法最初是由美國人Fogel LJ等人在20世紀60年代提出的。他們在人工智慧的研究中發現，智能行為要具有能預測其所處環境的狀態，並按照給定的目標做出適當的響應的能力。在研究中，他們將模擬環境描述成是由有限字元集中符號組成的序列。

進化演算法與傳統的演算法具有很多不同之處，但其最主要的特點體現在下述兩個方面：

進化計算的智能性包括自組織、自適應和自學習性等。應用進化計算求解問題時，在確定了編碼方案、適應值函數及遺傳運算元以後，演算法將根據「適者生存、不適應者淘汰"的策略，利用進化過程中獲得的信息自行組織搜索，從而不斷地向最佳解方向逼近。自然選擇消除了傳統演算法設計過程中的-一個最大障礙：即需要事先描述問題的全部特點，並說明針對問題的不同特點演算法應採取的措施。於是，利用進化計算的方法可以解決那些結構尚無人能理解的復雜問題。

進化計算的本質並行性表現在兩個方面：

一是進化計算是內在並行的，即進化計算本身非常適合大規模並行。

二是進化計算的內含並行性，由於進化計算採用種群的方式組織搜索，從而它可以同時搜索解空間內的多個區域，並相互交流信息，這種搜索方式使得進化計算能以較少的計算獲得較大的收益。

❹ 網上經常所說的遺傳演算法與基因演算法是一回事嗎有什麼不同各自的用途用在什麼地方

遺傳演算法
GA是一種基於自然群體遺傳演化機制的高效探索演算法，它是美國學者Holland於1975年首先提出來的。

它摒棄了傳統的搜索方式，模擬自然界生物進化過程，採用人工進化的方式對目標空間進行隨機化搜索。它將問題域中的可能解看作是群體的一個個體或染色體，並將每一個體編碼成符號串形式，模擬達爾文的遺傳選擇和自然淘汰的生物進化過程，對群體反復進行基於遺傳學的操作（遺傳，交叉和變異），根據預定的目標適應度函數對每個個體進行評價，依據適者生存，優勝劣汰的進化規則，不斷得到更優的群體，同時以全局並行搜索方式來搜索優化群體中的最優個體，求得滿足要求的最優解。

Holland創建的遺傳演算法是一種概率搜索演算法，它是利用某種編碼技術作用於稱為染色體的數串，其基本思想是模擬由這些組成的進化過程。跗演算法通過有組織地然而是隨機地信息交換重新組合那些適應性好的串，在每一代中，利用上一代串結構中適應好的位和段來生成一個新的串的群體；作為額外增添，偶爾也要在串結構中嘗試用新的位和段來替代原來的部分。

遺傳演算法是一類隨機化演算法，但是它不是簡單的隨機走動，它可以有效地利用已經有的信息處理來搜索那些有希望改善解質量的串，類似於自然進化，遺傳演算法通過作用於染色體上的基因，尋找好的染色體來求解問題。與自然界相似，遺傳演算法對待求解問題本身一無所知，它所需要的僅是對演算法所產生的每個染色體進行評價，並基於適應度值來造反染色體，使適用性好的染色體比適應性差的染色體有更多的繁殖機會。

基因：組成染色體的單元，可以表示為一個二進制位，一個整數或一個字元等。

染色體或個體：表示待求解問題的一個可能解，由若干基因組成，是GA操作的基本對象。

群體：一定數量的個體組成了群體，表示GA的遺傳搜索空間。

適應度或適度：代表一個個體所對應解的優劣，通常由某一適應度函數表示。

選擇：GA的基本操作之一，即根據個體的適應度，在群體中按照一定的概論選擇可以作為父本的個體，選擇依據是適應度大的個體被選中的概率高。選擇操作體現了適者生存，優勝劣汰的進化規則。

交叉：GA的基本操作之一，即將父本個體按照一定的概率隨機地交換基因形成新的個體。

變異：GA的基本操作之一，即即按一定概率隨機改變某個體的基因值。

基因演算法是一種生物進化的演算法,實際上是一種多目標的探索法.能夠用於計劃與排程.它是非常新的技術,目前,還沒有在商業中實際運用.
採用生物基因技術高級演算法,處理日益復雜的現實世界,也是人工智慧上,高級約束演算法上的挑戰. 基因演算法是一種搜索技術，它的目標是尋找最好的解決方案。這種搜索技術是一種優化組合，它以模仿生物進化過程為基礎。基因演算法的基本思想是，進化就是選擇了最優種類。基因演算法將應用APS上，以獲得「最優」的解決方案。

❺ 人工智慧演算法

推薦教程：Python教程

人工智慧英文簡稱AI。它是研究、開發用於模擬、延伸和擴展人的智能的理論、方法、技術及應用系統的一門新的技術科學。



人工智慧演算法也被稱之為軟計算 ，它是人們受自然界規律的啟迪，根據其原理模擬求解問題的演算法。



目前的人工智慧演算法有人工神經網路遺傳演算法、模擬退火演算法、群集智能蟻群演算法和例子群算等等。



隨著人工智慧演算法的不斷優化，可以不僅可以幫助我們提高工作效率、改善我們的生活水平，同時也能為我們在龐大的現代信息資源中迅速的找到我們所需要的信息。

❻ 神經網路和遺傳演算法有什麼關系

遺傳演算法是一種智能優化演算法，神經網路是人工智慧演算法的一種。
可以將遺傳演算法用於神經網路的參數優化中。