遺傳演算法舉例
1. 遺傳演算法中，十進制雜交誰能個舉個例子講解一下
十進制的交叉方式有兩種，一種是轉換為二進制交叉，交叉好後再轉為十進制；另一種是十進制直接交叉。
直接交叉就是利用交叉公式（運算公式）進行計算，以下為可選公式，分為十進制整型（變數不連接可調）和實型（變數連續可調）兩種。
兩個個體（個體長度為n）的十進制交叉過程如下：
1）設定交叉概率Pc；
2）隨機生成【0,1】間的數b，若b<Pc，則兩個進行交叉，轉3），否則判斷另外兩個個體是否交叉；
3）採用隨機多點交叉方式（可以選擇單點交叉和固定多點交叉，方法類似），隨機生成含n個0,1的向量y, y的每個元素對應於個體的基因（十進制數），y中為1的位置兩個十進制數按上述公式進行交叉；
4）兩個個體交叉完成，轉入下兩個個體的交叉。
例子：
設某兩個個體為
X1=[1.0132, 0.9543, 0.9888, 5, 6]
X2=[1.0224, 0.9611, 0.9754, 3, 8]
直接進入步驟3），假設生成的序列y為[1,0,0,0,1]，則說明第1個和最後一個基因進行交叉，即1.0132和1.0224按以上實型公式交叉，6和8按以上整型公式交叉：
隨機生成a，假設生成的a=0.65
1.0132的更新值為：0.65*1.0132+（1-0.65）*1.0224=1.01642
1.0224的更新值為：0.65*1.0224+（1-0.65）*1.0132=1.01918
隨機生成另外的a，假設為a=0.6（是否需要另外生成，需要對比生成與不生成兩種情況下最優解的好壞來選擇）
6的更新值為：0.6*6+（1-0.6）*8=6.8，向下取整後為6
8的更新值為：0.6*8+（1-0.6）*6=7.2，向下取整後為7
因此交叉後X1和X2變為：
X1=[1.01642, 0.9543, 0.9888, 5, 6]
X2=[1.01918, 0.9611, 0.9754, 3, 7]
以此類推。
2. 遺傳演算法實例 java
import java.util.*;
public class Tsp {
private String cityName[]={"北京","上海","天津","重慶","哈爾濱","長春","沈陽","呼和浩特","石家莊","太原","濟南","鄭州","西安","蘭州","銀川","西寧","烏魯木齊","合肥","南京","杭州","長沙","南昌","武漢","成都","貴州","福建","台北","廣州","海口","南寧","昆明","拉薩","香港","澳門"};
//private String cityEnd[]=new String[34];
private int cityNum=cityName.length; //城市個數
private int popSize = 50; //種群數量
private int maxgens = 20000; //迭代次數
private double pxover = 0.8; //交叉概率
private double pmultation = 0.05; //變異概率
private long[][] distance = new long[cityNum][cityNum];
private int range = 2000; //用於判斷何時停止的數組區間
private class genotype {
int city[] = new int[cityNum]; //單個基因的城市序列
long fitness; //該基因的適應度
double selectP; //選擇概率
double exceptp; //期望概率
int isSelected; //是否被選擇
}
private genotype[] citys = new genotype[popSize];
/**
* 構造函數，初始化種群
*/
public Tsp() {
for (int i = 0; i < popSize; i++) {
citys[i] = new genotype();
int[] num = new int[cityNum];
for (int j = 0; j < cityNum; j++)
num[j] = j;
int temp = cityNum;
for (int j = 0; j < cityNum; j++) {
int r = (int) (Math.random() * temp);
citys[i].city[j] = num[r];
num[r] = num[temp - 1];
temp--;
}
citys[i].fitness = 0;
citys[i].selectP = 0;
citys[i].exceptp = 0;
citys[i].isSelected = 0;
}
initDistance();
}
/**
* 計算每個種群每個基因個體的適應度，選擇概率，期望概率，和是否被選擇。
*/
public void CalAll(){
for( int i = 0; i< popSize; i++){
citys[i].fitness = 0;
citys[i].selectP = 0;
citys[i].exceptp = 0;
citys[i].isSelected = 0;
}
CalFitness();
CalSelectP();
CalExceptP();
CalIsSelected();
}
/**
* 填充，將多選的填充到未選的個體當中
*/
public void pad(){
int best = 0;
int bad = 0;
while(true){
while(citys[best].isSelected <= 1 && best<popSize-1)
best ++;
while(citys[bad].isSelected != 0 && bad<popSize-1)
bad ++;
for(int i = 0; i< cityNum; i++)
citys[bad].city[i] = citys[best].city[i];
citys[best].isSelected --;
citys[bad].isSelected ++;
bad ++;
if(best == popSize ||bad == popSize)
break;
}
}
/**
* 交叉主體函數
*/
public void crossover() {
int x;
int y;
int pop = (int)(popSize* pxover /2);
while(pop>0){
x = (int)(Math.random()*popSize);
y = (int)(Math.random()*popSize);
executeCrossover(x,y);//x y 兩個體執行交叉
pop--;
}
}
/**
* 執行交叉函數
* @param 個體x
* @param 個體y
* 對個體x和個體y執行佳點集的交叉，從而產生下一代城市序列
*/
private void executeCrossover(int x,int y){
int dimension = 0;
for( int i = 0 ;i < cityNum; i++)
if(citys[x].city[i] != citys[y].city[i]){
dimension ++;
}
int diffItem = 0;
double[] diff = new double[dimension];
for( int i = 0 ;i < cityNum; i++){
if(citys[x].city[i] != citys[y].city[i]){
diff[diffItem] = citys[x].city[i];
citys[x].city[i] = -1;
citys[y].city[i] = -1;
diffItem ++;
}
}
Arrays.sort(diff);
double[] temp = new double[dimension];
temp = gp(x, dimension);
for( int k = 0; k< dimension;k++)
for( int j = 0; j< dimension; j++)
if(temp[j] == k){
double item = temp[k];
temp[k] = temp[j];
temp[j] = item;
item = diff[k];
diff[k] = diff[j];
diff[j] = item;
}
int tempDimension = dimension;
int tempi = 0;
while(tempDimension> 0 ){
if(citys[x].city[tempi] == -1){
citys[x].city[tempi] = (int)diff[dimension - tempDimension];
tempDimension --;
}
tempi ++;
}
Arrays.sort(diff);
temp = gp(y, dimension);
for( int k = 0; k< dimension;k++)
for( int j = 0; j< dimension; j++)
if(temp[j] == k){
double item = temp[k];
temp[k] = temp[j];
temp[j] = item;
item = diff[k];
diff[k] = diff[j];
diff[j] = item;
}
tempDimension = dimension;
tempi = 0;
while(tempDimension> 0 ){
if(citys[y].city[tempi] == -1){
citys[y].city[tempi] = (int)diff[dimension - tempDimension];
tempDimension --;
}
tempi ++;
}
}
/**
* @param indivial 個體
* @param dimension 維數
* @return 佳點集 (用於交叉函數的交叉點） 在executeCrossover()函數中使用
*/
private double[] gp(int indivial, int dimension){
double[] temp = new double[dimension];
double[] temp1 = new double[dimension];
int p = 2 * dimension + 3;
while(!isSushu(p))
p++;
for( int i = 0; i< dimension; i++){
temp[i] = 2*Math.cos(2*Math.PI*(i+1)/p) * (indivial+1);
temp[i] = temp[i] - (int)temp[i];
if( temp [i]< 0)
temp[i] = 1+temp[i];
}
for( int i = 0; i< dimension; i++)
temp1[i] = temp[i];
Arrays.sort(temp1);
//排序
for( int i = 0; i< dimension; i++)
for( int j = 0; j< dimension; j++)
if(temp[j]==temp1[i])
temp[j] = i;
return temp;
}
/**
* 變異
*/
public void mutate(){
double random;
int temp;
int temp1;
int temp2;
for( int i = 0 ; i< popSize; i++){
random = Math.random();
if(random<=pmultation){
temp1 = (int)(Math.random() * (cityNum));
temp2 = (int)(Math.random() * (cityNum));
temp = citys[i].city[temp1];
citys[i].city[temp1] = citys[i].city[temp2];
citys[i].city[temp2] = temp;
}
}
}
/**
* 列印當前代數的所有城市序列，以及其相關的參數
*/
public void print(){
/**
* 初始化各城市之間的距離
*/
private void initDistance(){
for (int i = 0; i < cityNum; i++) {
for (int j = 0; j < cityNum; j++){
distance[i][j] = Math.abs(i-j);
}
}
}
/**
* 計算所有城市序列的適應度
*/
private void CalFitness() {
for (int i = 0; i < popSize; i++) {
for (int j = 0; j < cityNum - 1; j++)
citys[i].fitness += distance[citys[i].city[j]][citys[i].city[j + 1]];
citys[i].fitness += distance[citys[i].city[0]][citys[i].city[cityNum - 1]];
}
}
/**
* 計算選擇概率
*/
private void CalSelectP(){
long sum = 0;
for( int i = 0; i< popSize; i++)
sum += citys[i].fitness;
for( int i = 0; i< popSize; i++)
citys[i].selectP = (double)citys[i].fitness/sum;
}
/**
* 計算期望概率
*/
private void CalExceptP(){
for( int i = 0; i< popSize; i++)
citys[i].exceptp = (double)citys[i].selectP * popSize;
}
/**
* 計算該城市序列是否較優，較優則被選擇，進入下一代
*/
private void CalIsSelected(){
int needSelecte = popSize;
for( int i = 0; i< popSize; i++)
if( citys[i].exceptp<1){
citys[i].isSelected++;
needSelecte --;
}
double[] temp = new double[popSize];
for (int i = 0; i < popSize; i++) {
// temp[i] = citys[i].exceptp - (int) citys[i].exceptp;
// temp[i] *= 10;
temp[i] = citys[i].exceptp*10;
}
int j = 0;
while (needSelecte != 0) {
for (int i = 0; i < popSize; i++) {
if ((int) temp[i] == j) {
citys[i].isSelected++;
needSelecte--;
if (needSelecte == 0)
break;
}
}
j++;
}
}
/**
* @param x
* @return 判斷一個數是否是素數的函數
*/
private boolean isSushu( int x){
if(x<2) return false;
for(int i=2;i<=x/2;i++)
if(x%i==0&&x!=2) return false;
return true;
}
/**
* @param x 數組
* @return x數組的值是否全部相等，相等則表示x.length代的最優結果相同，則演算法結束
*/
private boolean isSame(long[] x){
for( int i = 0; i< x.length -1; i++)
if(x[i] !=x[i+1])
return false;
return true;
}
/**
* 列印任意代最優的路徑序列
*/
private void printBestRoute(){
CalAll();
long temp = citys[0].fitness;
int index = 0;
for (int i = 1; i < popSize; i++) {
if(citys[i].fitness<temp){
temp = citys[i].fitness;
index = i;
}
}
System.out.println();
System.out.println("最佳路徑的序列：");
for (int j = 0; j < cityNum; j++)
{
String cityEnd[]={cityName[citys[index].city[j]]};
for(int m=0;m<cityEnd.length;m++)
{
System.out.print(cityEnd[m] + " ");
}
}
//System.out.print(citys[index].city[j] + cityName[citys[index].city[j]] + " ");
//System.out.print(cityName[citys[index].city[j]]);
System.out.println();
}
/**
* 演算法執行
*/
public void run(){
long[] result = new long[range];
//result初始化為所有的數字都不相等
for( int i = 0; i< range; i++)
result[i] = i;
int index = 0; //數組中的位置
int num = 1; //第num代
while(maxgens>0){
System.out.println("----------------- 第 "+num+" 代 -------------------------");
CalAll();
print();
pad();
crossover();
mutate();
maxgens --;
long temp = citys[0].fitness;
for ( int i = 1; i< popSize; i++)
if(citys[i].fitness<temp){
temp = citys[i].fitness;
}
System.out.println("最優的解："+temp);
result[index] = temp;
if(isSame(result))
break;
index++;
if(index==range)
index = 0;
num++;
}
printBestRoute();
}
/**
* @param a 開始時間
* @param b 結束時間
*/
public void CalTime(Calendar a,Calendar b){
long x = b.getTimeInMillis() - a.getTimeInMillis();
long y = x/1000;
x = x - 1000*y;
System.out.println("演算法執行時間："+y+"."+x+" 秒");
}
/**
* 程序入口
*/
public static void main(String[] args) {
Calendar a = Calendar.getInstance(); //開始時間
Tsp tsp = new Tsp();
tsp.run();
Calendar b = Calendar.getInstance(); //結束時間
tsp.CalTime(a, b);
}
}
3. 遺傳演算法原理與應用實例的介紹
《遺傳演算法原理與應用實例》主要結合應用實例系統討論、介紹遺傳演算法原理及其應內用，主要內容容包括：遺傳演算法的基本原理和數學機理、解決連續問題優化的遺傳演算法和分布式遺傳演算法、遺傳演算法的實現技術、遺傳演算法應用實例，並給出了兩個典型的遺傳演算法源程序。《遺傳演算法原理與應用實例》在詳細介紹遺傳演算法理論與方法的同時，還給_出了基於遺傳演算法的費托合成反應動力學模型參數優化的詳細設計應用。
4. 遺傳演算法 編碼 例子
GA的編碼通常都是數字序列（好比基因^_^），具體如何編碼要看實際需求如何，例如Jeffris提到的行商問題，其編碼就是一個包括n節點數字序列（也就是一條不重復走遍所有城市的路線）。
如果你願意把你所面對的問題貼出來，或許能幫到你一些。
如果你只是在尋求多維數據結構的表現方式，很簡單，無論多少維，都可以表現為(x,y,z,...)這樣的坐標形式。不過我相信這不是你想要的啦^_^
最後，這個連接上有些內容或許會有點幫助（盡管可能性很小）http://..com/question/17393957.html
加油！
5. 如何利用遺傳演算法求解問題試舉例說明求解過程急急急！！！
遺傳演算法將目標函數轉換為適應度函數，評估，復制，交叉，變異種群中的回個體，並從答中選出適應性最強的個體，演算法的最優解就是這個個體。具體流程是：1.初始種群的產生。2.適應度函數的構造。3.選擇和繁殖。4.終止條件。
6. 如何通俗易懂地解釋遺傳演算法有什麼例子
相信遺傳演算法的官方定義你已經看過，就我個人理解
遺傳演算法的思想是物競天擇，優勝劣汰。
你可以理解為，當我們解某道數學題時，如果這個題太難我們沒法列公式算出正確答案，我們有時候也可以蒙答案去反過來看看是否滿足這道題提乾的要求，如果能滿足，說明我們蒙的答案是正確的。但是蒙對答案要試很多遍，每次隨機的去試數可能要試1000次才能蒙對。可是遺傳演算法可以讓我們科學的去蒙答案，每次蒙的答案都會比上一次蒙的更接近正確答案，這樣可能蒙十幾次我們就找到正確答案了。
希望我的回答對你理解GA有所幫助，望採納
7. 遺傳演算法能不能解決線性規劃順便舉個例子或者鏈接吧。
當然可以了，函數問題就是最簡單的線性規劃問題啊。在網路文庫上有我的一個多目標的程序，如有需要可以下載。網路直接搜「遺傳演算法程序代碼--多目標優化--函數最值問題」就行。