遺傳演算法軟體實現

1. 用matlab實現的遺傳演算法

f=inline('-(x+10*sin(5*x)+7*cos(4*x))');
[x,val]=ga(f,1,[],[],[],[],0,9);
x,val=-val%註：由於遺傳法的不確定性，每次得到的解可能不同。
————————————————————————————————
ga是matlab自帶的遺傳工具箱中的遺傳演算法函數，其中已經用到了選擇、交叉、變異，你如果想知道其具體是怎麼實現的，可以自己打開ga的源程序去看。

2. 遺傳演算法——理論·應用與軟體實現

遺傳演算法——理論、應用與軟體實現
王小平、曹立明著
西安交通大學出版社
有一份PDF的，掃描版，不算很清晰，
需要的讀者話可以聯系：[email protected] ···

3. 關於遺傳演算法的問題可以在什麼軟體中實現謝謝各位高手

使用matlab平台的邏輯演算法軟體包
參考以下地址：
http://www.pudn.com/downloads60/sourcecode/math/detail209338.html

4. 利用matlab軟體實現遺傳演算法，解決生產調度問題

對於遺傳演算法，matlab自己內置了工具箱函數，你完全不用編碼，只需要弄懂裡面的參數設置問題就行。

matlab的遺傳演算法實現函數是ga（），對應的設置參數的函數是gaoptimset。有哪些參數可以設置可以直接在命令窗口輸入gaoptimset。ga的用法可以在命令窗口輸入doc ga 查看，祝好。

5. 遺傳演算法的matlab代碼實現是什麼

遺傳演算法我懂，我的論文就是用著這個演算法，具體到你要遺傳演算法是做什麼？優化什麼的。。。我給你一個標准遺傳演算法程序供你參考：
該程序是遺傳演算法優化BP神經網路函數極值尋優：
%% 該代碼為基於神經網路遺傳演算法的系統極值尋優
%% 清空環境變數
clc
clear

%% 初始化遺傳演算法參數
%初始化參數
maxgen=100; %進化代數，即迭代次數
sizepop=20; %種群規模
pcross=[0.4]; %交叉概率選擇，0和1之間
pmutation=[0.2]; %變異概率選擇，0和1之間

lenchrom=[1 1]; %每個變數的字串長度，如果是浮點變數，則長度都為1
bound=[-5 5;-5 5]; %數據范圍

indivials=struct('fitness',zeros(1,sizepop), 'chrom',[]); %將種群信息定義為一個結構體
avgfitness=[]; %每一代種群的平均適應度
bestfitness=[]; %每一代種群的最佳適應度
bestchrom=[]; %適應度最好的染色體

%% 初始化種群計算適應度值
% 初始化種群
for i=1:sizepop
%隨機產生一個種群
indivials.chrom(i,:)=Code(lenchrom,bound);
x=indivials.chrom(i,:);
%計算適應度
indivials.fitness(i)=fun(x); %染色體的適應度
end
%找最好的染色體
[bestfitness bestindex]=min(indivials.fitness);
bestchrom=indivials.chrom(bestindex,:); %最好的染色體
avgfitness=sum(indivials.fitness)/sizepop; %染色體的平均適應度
% 記錄每一代進化中最好的適應度和平均適應度
trace=[avgfitness bestfitness];

%% 迭代尋優
% 進化開始
for i=1:maxgen
i
% 選擇
indivials=Select(indivials,sizepop);
avgfitness=sum(indivials.fitness)/sizepop;
%交叉
indivials.chrom=Cross(pcross,lenchrom,indivials.chrom,sizepop,bound);
% 變異
indivials.chrom=Mutation(pmutation,lenchrom,indivials.chrom,sizepop,[i maxgen],bound);

% 計算適應度
for j=1:sizepop
x=indivials.chrom(j,:); %解碼
indivials.fitness(j)=fun(x);
end

%找到最小和最大適應度的染色體及它們在種群中的位置
[newbestfitness,newbestindex]=min(indivials.fitness);
[worestfitness,worestindex]=max(indivials.fitness);
% 代替上一次進化中最好的染色體
if bestfitness>newbestfitness
bestfitness=newbestfitness;
bestchrom=indivials.chrom(newbestindex,:);
end
indivials.chrom(worestindex,:)=bestchrom;
indivials.fitness(worestindex)=bestfitness;

avgfitness=sum(indivials.fitness)/sizepop;

trace=[trace;avgfitness bestfitness]; %記錄每一代進化中最好的適應度和平均適應度
end
%進化結束

%% 結果分析
[r c]=size(trace);
plot([1:r]',trace(:,2),'r-');
title('適應度曲線','fontsize',12);
xlabel('進化代數','fontsize',12);ylabel('適應度','fontsize',12);
axis([0,100,0,1])
disp('適應度 變數');
x=bestchrom;
% 窗口顯示
disp([bestfitness x]);

6. 遺傳演算法用什麼工具可以實現

用matlab的工具箱可以實現，對於matlab7.0,它自帶了遺傳演算法的工具箱GA，對於不是7.0的，如6.5，需要自己添加工具箱GAOT，然後指定路徑到GAOT，工具箱GAOT到網上都可以搜到的，不需要自己編程。

7. 遺傳演算法程序運行這個該用什麼軟體能運行

MATLAB用於圖像建模演算法的設計和運行
這個用MATLAB實現可以運行。

8. 遺傳演算法都可以用什麼軟體做啊 程序怎麼編寫

大家都用c或matlab語言，你怎麼這有想法
,matlab，vb，c我也學過，但是我還是勸你用matlab，他比較靈活，再一個用遺傳演算法算的一般都是需建模矩陣

9. 如何用java實現遺傳演算法

通過遺傳演算法走迷宮。雖然圖1和圖2均成功走出迷宮，但是圖1比圖2的路徑長的多，且復雜，遺傳演算法可以計算出有多少種可能性，並選擇其中最簡潔的作為運算結果。

示例圖1：

實現代碼：

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.Iterator;

importjava.util.LinkedList;

importjava.util.List;

importjava.util.Random;

/**

* 用遺傳演算法走迷宮

*

* @author Orisun

*

*/

publicclassGA {

intgene_len;// 基因長度

intchrom_len;// 染色體長度

intpopulation;// 種群大小

doublecross_ratio;// 交叉率

doublemuta_ratio;// 變異率

intiter_limit;// 最多進化的代數

List<boolean[]> indivials;// 存儲當代種群的染色體

Labyrinth labyrinth;

intwidth;//迷宮一行有多少個格子

intheight;//迷宮有多少行

publicclassBI {

doublefitness;

boolean[] indv;

publicBI(doublef,boolean[] ind) {

fitness = f;

indv = ind;

}

publicdoublegetFitness() {

returnfitness;

}

publicboolean[] getIndv() {

returnindv;

}

}

List<BI> best_indivial;// 存儲每一代中最優秀的個體

publicGA(Labyrinth labyrinth) {

this.labyrinth=labyrinth;

this.width = labyrinth.map[0].length;

this.height = labyrinth.map.length;

chrom_len =4* (width+height);

gene_len =2;

population =20;

cross_ratio =0.83;

muta_ratio =0.002;

iter_limit =300;

indivials =newArrayList<boolean[]>(population);

best_indivial =newArrayList<BI>(iter_limit);

}

publicintgetWidth() {

returnwidth;

}

publicvoidsetWidth(intwidth) {

this.width = width;

}

publicdoublegetCross_ratio() {

returncross_ratio;

}

publicList<BI> getBest_indivial() {

returnbest_indivial;

}

publicLabyrinth getLabyrinth() {

returnlabyrinth;

}

publicvoidsetLabyrinth(Labyrinth labyrinth) {

this.labyrinth = labyrinth;

}

publicvoidsetChrom_len(intchrom_len) {

this.chrom_len = chrom_len;

}

publicvoidsetPopulation(intpopulation) {

this.population = population;

}

publicvoidsetCross_ratio(doublecross_ratio) {

this.cross_ratio = cross_ratio;

}

publicvoidsetMuta_ratio(doublemuta_ratio) {

this.muta_ratio = muta_ratio;

}

publicvoidsetIter_limit(intiter_limit) {

this.iter_limit = iter_limit;

}

// 初始化種群

publicvoidinitPopulation() {

Random r =newRandom(System.currentTimeMillis());

for(inti =0; i < population; i++) {

intlen = gene_len * chrom_len;

boolean[] ind =newboolean[len];

for(intj =0; j < len; j++)

ind[j] = r.nextBoolean();

indivials.add(ind);

}

}

// 交叉

publicvoidcross(boolean[] arr1,boolean[] arr2) {

Random r =newRandom(System.currentTimeMillis());

intlength = arr1.length;

intslice =0;

do{

slice = r.nextInt(length);

}while(slice ==0);

if(slice < length /2) {

for(inti =0; i < slice; i++) {

booleantmp = arr1[i];

arr1[i] = arr2[i];

arr2[i] = tmp;

}

}else{

for(inti = slice; i < length; i++) {

booleantmp = arr1[i];

arr1[i] = arr2[i];

arr2[i] = tmp;

}

}

}

// 變異

publicvoidmutation(boolean[] indivial) {

intlength = indivial.length;

Random r =newRandom(System.currentTimeMillis());

indivial[r.nextInt(length)] ^=false;

}

// 輪盤法選擇下一代,並返回當代最高的適應度值

publicdoubleselection() {

boolean[][] next_generation =newboolean[population][];// 下一代

intlength = gene_len * chrom_len;

for(inti =0; i < population; i++)

next_generation[i] =newboolean[length];

double[] cumulation =newdouble[population];

intbest_index =0;

doublemax_fitness = getFitness(indivials.get(best_index));

cumulation[0] = max_fitness;

for(inti =1; i < population; i++) {

doublefit = getFitness(indivials.get(i));

cumulation[i] = cumulation[i -1] + fit;

// 尋找當代的最優個體

if(fit > max_fitness) {

best_index = i;

max_fitness = fit;

}

}

Random rand =newRandom(System.currentTimeMillis());

for(inti =0; i < population; i++)

next_generation[i] = indivials.get(findByHalf(cumulation,

rand.nextDouble() * cumulation[population -1]));

// 把當代的最優個體及其適應度放到best_indivial中

BI bi =newBI(max_fitness, indivials.get(best_index));

// printPath(indivials.get(best_index));

//System.out.println(max_fitness);

best_indivial.add(bi);

// 新一代作為當前代

for(inti =0; i < population; i++)

indivials.set(i, next_generation[i]);

returnmax_fitness;

}

// 折半查找

publicintfindByHalf(double[] arr,doublefind) {

if(find <0|| find ==0|| find > arr[arr.length -1])

return-1;

intmin =0;

intmax = arr.length -1;

intmedium = min;

do{

if(medium == (min + max) /2)

break;

medium = (min + max) /2;

if(arr[medium] < find)

min = medium;

elseif(arr[medium] > find)

max = medium;

else

returnmedium;

}while(min < max);

returnmax;

}

// 計算適應度

publicdoublegetFitness(boolean[] indivial) {

intlength = indivial.length;

// 記錄當前的位置,入口點是（1,0）

intx =1;

inty =0;

// 根據染色體中基因的指導向前走

for(inti =0; i < length; i++) {

booleanb1 = indivial[i];

booleanb2 = indivial[++i];

// 00向左走

if(b1 ==false&& b2 ==false) {

if(x >0&& labyrinth.map[y][x -1] ==true) {

x--;

}

}

// 01向右走

elseif(b1 ==false&& b2 ==true) {

if(x +1< width && labyrinth.map[y][x +1] ==true) {

x++;

}

}

// 10向上走

elseif(b1 ==true&& b2 ==false) {

if(y >0&& labyrinth.map[y -1][x] ==true) {

y--;

}

}

// 11向下走

elseif(b1 ==true&& b2 ==true) {

if(y +1< height && labyrinth.map[y +1][x] ==true) {

y++;

}

}

}

intn = Math.abs(x - labyrinth.x_end) + Math.abs(y -labyrinth.y_end) +1;

// if(n==1)

// printPath(indivial);

return1.0/ n;

}

// 運行遺傳演算法

publicbooleanrun() {

// 初始化種群

initPopulation();

Random rand =newRandom(System.currentTimeMillis());

booleansuccess =false;

while(iter_limit-- >0) {

// 打亂種群的順序

Collections.shuffle(indivials);

for(inti =0; i < population -1; i +=2) {

// 交叉

if(rand.nextDouble() < cross_ratio) {

cross(indivials.get(i), indivials.get(i +1));

}

// 變異

if(rand.nextDouble() < muta_ratio) {

mutation(indivials.get(i));

}

}

// 種群更替

if(selection() ==1) {

success =true;

break;

}

}

returnsuccess;

}

// public static void main(String[] args) {

// GA ga = new GA(8, 8);

// if (!ga.run()) {

// System.out.println("沒有找到走出迷宮的路徑.");

// } else {

// int gen = ga.best_indivial.size();

// boolean[] indivial = ga.best_indivial.get(gen - 1).indv;

// System.out.println(ga.getPath(indivial));

// }

// }

// 根據染色體列印走法

publicString getPath(boolean[] indivial) {

intlength = indivial.length;

intx =1;

inty =0;

LinkedList<String> stack=newLinkedList<String>();

for(inti =0; i < length; i++) {

booleanb1 = indivial[i];

booleanb2 = indivial[++i];

if(b1 ==false&& b2 ==false) {

if(x >0&& labyrinth.map[y][x -1] ==true) {

x--;

if(!stack.isEmpty() && stack.peek()=="右")

stack.poll();

else

stack.push("左");

}

}elseif(b1 ==false&& b2 ==true) {

if(x +1< width && labyrinth.map[y][x +1] ==true) {

x++;

if(!stack.isEmpty() && stack.peek()=="左")

stack.poll();

else

stack.push("右");

}

}elseif(b1 ==true&& b2 ==false) {

if(y >0&& labyrinth.map[y -1][x] ==true) {

y--;

if(!stack.isEmpty() && stack.peek()=="下")

stack.poll();

else

stack.push("上");

}

}elseif(b1 ==true&& b2 ==true) {

if(y +1< height && labyrinth.map[y +1][x] ==true) {

y++;

if(!stack.isEmpty() && stack.peek()=="上")

stack.poll();

else

stack.push("下");

}

}

}

StringBuilder sb=newStringBuilder(length/4);

Iterator<String> iter=stack.descendingIterator();

while(iter.hasNext())

sb.append(iter.next());

returnsb.toString();

}

}

10. 遺傳演算法主要實現的軟體都有什麼，除了MATLAB還有什麼

遺傳演算法（Genetic Algorithm）是模擬達爾文生物進化論的自然選擇和遺傳學機理的生物進化過程的計算模型，是一種通過模擬自然進化過程搜索最優解的方法。遺傳演算法是從代表問題可能潛在的解集的一個種群（population）開始的，而一個種群則由經過基因（gene）編碼的一定數目的個體(indivial)組成。