我给你一个标准遗传算法程序供你参考：该程序是遗传算法优化BP神经网络函数极值寻优：%% 该代码为基于神经网络遗传算法的系统极值寻优%% 清空环境变量clcclear%% 初始化遗传算法参数%初始化参数maxgen=100; %进化代数,则长度都为1bound=[-5 5;-5 5]; %数据范围individuals=struct(’fitness’,zeros(1,sizepop), ’chrom’,); %将种群信息定义为一个结构体avgfitness=; %每一代种群的平均适应度bestfitness=; %每一代种群的最佳适应度bestchrom=; %适应度最好的染色体%% 初始化种群计算适应度值% 初始化种群for i=1:sizepop %随机产生一个种群 individuals.chrom(i,:)=Code(lenchrom,bound); x=individuals.chrom(i,:); %计算适应度 individuals.fitness(i)=fun(x); %染色体的适应度end%找最好的染色体[bestfitness bestindex]=min(individuals.fitness);bestchrom=individuals.chrom(bestindex,:); %最好的染色体avgfitness=sum(individuals.fitness)/sizepop; %染色体的平均适应度% 记录每一代进化中最好的适应度和平均适应度trace=[avgfitness bestfitness]; %% 迭代寻优% 进化开始for i=1:maxgen i % 选择 individuals=Select(individuals,sizepop); avgfitness=sum(individuals.fitness)/sizepop; %交叉 individuals.chrom=Cross(pcross,lenchrom,individuals.chrom,sizepop,bound); % 变异 individuals.chrom=Mutation(pmutation,lenchrom,individuals.chrom,sizepop,[i maxgen],bound); % 计算适应度 for j=1:sizepop x=individuals.chrom(j,:); %解码 individuals.fitness(j)=fun(x); end %找到最小和最大适应度的染色体及它们在种群中的位置 [newbestfitness,newbestindex]=min(individuals.fitness); [worestfitness,worestindex]=max(individuals.fitness); % 代替上一次进化中最好的染色体 if bestfitness》newbestfitness bestfitness=newbestfitness; bestchrom=individuals.chrom(newbestindex,:); end individuals.chrom(worestindex,:)=bestchrom; individuals.fitness(worestindex)=bestfitness; avgfitness=sum(individuals.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]);如何用遗传算法实现多变量的最优化问题将多个变量的数值编码编排进去,0和1之间pmutation=[0.2]; %变异概率选择,0和1之间lenchrom=[1 1]; %每个变量的字串长度,————————————————————————————————ga是matlab自带的遗传工具箱中的遗传算法函数,如何用Java实现遗传算法通过遗传算法走迷宫,即迭代次数sizepop=20; %种群规模pcross=[0.4]; %交叉概率选择,示例图1：示例图2：实现代码：import java.util.ArrayList;import java.util.Collections;import java.util.Iterator;import java.util.LinkedList;import java.util.List;import java.util.Random; /** * 用遗传算法走迷宫 * * @author Orisun * */public class GA { int gene_len; // 基因长度 int chrom_len; // 染色体长度 int population; // 种群大小 double cross_ratio; // 交叉率 double muta_ratio; // 变异率 int iter_limit; // 最多进化的代数 List《boolean》 individuals; // 存储当代种群的染色体 Labyrinth labyrinth; int width; //迷宫一行有多少个格子 int height; //迷宫有多少行 public class BI { double fitness; boolean indv; public BI(double f, boolean ind) { fitness = f; indv = ind; } public double getFitness() { return fitness; } public boolean getIndv() { return indv; } } List《BI》 best_individual; // 存储每一代中最优秀的个体 public GA(Labyrinth labyrinth) { this.labyrinth=labyrinth; this.width = labyrinth.map.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; individuals = new ArrayList《boolean》(population); best_individual = new ArrayList《BI》(iter_limit); } public int getWidth() { return width; } public void setWidth(int width) { this.width = width; } public double getCross_ratio() { return cross_ratio; } public List《BI》 getBest_individual() { return best_individual; } public Labyrinth getLabyrinth() { return labyrinth; } public void setLabyrinth(Labyrinth labyrinth) { this.labyrinth = labyrinth; } public void setChrom_len(int chrom_len) { this.chrom_len = chrom_len; } public void setPopulation(int population) { this.population = population; } public void setCross_ratio(double cross_ratio) { this.cross_ratio = cross_ratio; } public void setMuta_ratio(double muta_ratio) { this.muta_ratio = muta_ratio; } public void setIter_limit(int iter_limit) { this.iter_limit = iter_limit; } // 初始化种群 public void initPopulation() { Random r = new Random(System.currentTimeMillis()); for (int i = 0; i 《 population; i++) { int len = gene_len * chrom_len; boolean ind = new boolean[len]; for (int j = 0; j 《 len; j++) ind[j] = r.nextBoolean(); individuals.add(ind); } } // 交叉 public void cross(boolean arr1, boolean arr2) { Random r = new Random(System.currentTimeMillis()); int length = arr1.length; int slice = 0; do { slice = r.nextInt(length); } while (slice == 0); if (slice 《 length / 2) { for (int i = 0; i 《 slice; i++) { boolean tmp = arr1[i]; arr1[i] = arr2[i]; arr2[i] = tmp; } } else { for (int i = slice; i 《 length; i++) { boolean tmp = arr1[i]; arr1[i] = arr2[i]; arr2[i] = tmp; } } } // 变异 public void mutation(boolean individual) { int length = individual.length; Random r = new Random(System.currentTimeMillis()); individual[r.nextInt(length)] ^= false; } // 轮盘法选择下一代,并返回当代最高的适应度值 public double selection() { boolean next_generation = new boolean[population]; // 下一代 int length = gene_len * chrom_len; for (int i = 0; i 《 population; i++) next_generation[i] = new boolean[length]; double cumulation = new double[population]; int best_index = 0; double max_fitness = getFitness(individuals.get(best_index)); cumulation = max_fitness; for (int i = 1; i 《 population; i++) { double fit = getFitness(individuals.get(i)); cumulation[i] = cumulation[i - 1] + fit; // 寻找当代的最优个体 if (fit 》 max_fitness) { best_index = i; max_fitness = fit; } } Random rand = new Random(System.currentTimeMillis()); for (int i = 0; i 《 population; i++) next_generation[i] = individuals.get(findByHalf(cumulation, rand.nextDouble() * cumulation[population - 1])); // 把当代的最优个体及其适应度放到best_individual中 BI bi = new BI(max_fitness, individuals.get(best_index)); // printPath(individuals.get(best_index)); //System.out.println(max_fitness); best_individual.add(bi); // 新一代作为当前代 for (int i = 0; i 《 population; i++) individuals.set(i, next_generation[i]); return max_fitness; } // 折半查找 public int findByHalf(double arr, double find) { if (find 《 0 || find == 0 || find 》 arr[arr.length - 1]) return -1; int min = 0; int max = arr.length - 1; int medium = min; do { if (medium == (min + max) / 2) break; medium = (min + max) / 2; if (arr[medium] 《 find) min = medium; else if (arr[medium] 》 find) max = medium; else return medium; } while (min 《 max); return max; } // 计算适应度 public double getFitness(boolean individual) { int length = individual.length; // 记录当前的位置,入口点是（1,0） int x = 1; int y = 0; // 根据染色体中基因的指导向前走 for (int i = 0; i 《 length; i++) { boolean b1 = individual[i]; boolean b2 = individual[++i]; // 00向左走 if (b1 == false && b2 == false) { if (x 》 0 && labyrinth.map[y][x - 1] == true) { x--; } } // 01向右走 else if (b1 == false && b2 == true) { if (x + 1 《 width && labyrinth.map[y][x + 1] == true) { x++; } } // 10向上走 else if (b1 == true && b2 == false) { if (y 》 0 && labyrinth.map[y - 1][x] == true) { y--; } } // 11向下走 else if (b1 == true && b2 == true) { if (y + 1 《 height && labyrinth.map[y + 1][x] == true) { y++; } } } int n = Math.abs(x - labyrinth.x_end) + Math.abs(y -labyrinth.y_end) + 1;// if(n==1)// printPath(individual); return 1.0 / n; } // 运行遗传算法 public boolean run() { // 初始化种群 initPopulation(); Random rand = new Random(System.currentTimeMillis()); boolean success = false; while (iter_limit-- 》 0) { // 打乱种群的顺序 Collections.shuffle(individuals); for (int i = 0; i 《 population - 1; i += 2) { // 交叉 if (rand.nextDouble() 《 cross_ratio) { cross(individuals.get(i), individuals.get(i + 1)); } // 变异 if (rand.nextDouble() 《 muta_ratio) { mutation(individuals.get(i)); } } // 种群更替 if (selection() == 1) { success = true; break; } } return success; } // public static void main(String args) {// GA ga = new GA(8, 8);// if (!ga.run()) {// System.out.println(“没有找到走出迷宫的路径.“);// } else {// int gen = ga.best_individual.size();// boolean individual = ga.best_individual.get(gen - 1).indv;// System.out.println(ga.getPath(individual));// }// } // 根据染色体打印走法 public String getPath(boolean individual) { int length = individual.length; int x = 1; int y = 0; LinkedList《String》 stack=new LinkedList《String》(); for (int i = 0; i 《 length; i++) { boolean b1 = individual[i]; boolean b2 = individual[++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(“左“); } } else if (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(“右“); } } else if (b1 == true && b2 == false) { if (y 》 0 && labyrinth.map[y - 1][x] == true) { y--; if(!stack.isEmpty() && stack.peek()==“下“) stack.poll(); else stack.push(“上“); } } else if (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=new StringBuilder(length/4); Iterator《String》 iter=stack.descendingIterator(); while(iter.hasNext()) sb.append(iter.next()); return sb.toString(); }}遗传算法的matlab代码实现是什么遗传算法我懂。
用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的源程序去看。
如何用Java实现遗传算法
通过遗传算法走迷宫。虽然图1和图2均成功走出迷宫，但是图1比图2的路径长的多，且复杂，遗传算法可以计算出有多少种可能性，并选择其中最简洁的作为运算结果。
示例图1：
示例图2：
实现代码：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
/**
* 用遗传算法走迷宫
*
* @author Orisun
*
*/
public class GA {
int gene_len; // 基因长度
int chrom_len; // 染色体长度
int population; // 种群大小
double cross_ratio; // 交叉率
double muta_ratio; // 变异率
int iter_limit; // 最多进化的代数
List《boolean》 individuals; // 存储当代种群的染色体
Labyrinth labyrinth;
int width; //迷宫一行有多少个格子
int height; //迷宫有多少行
public class BI {
double fitness;
boolean indv;
public BI(double f, boolean ind) {
fitness = f;
indv = ind;
}
public double getFitness() {
return fitness;
}
public boolean getIndv() {
return indv;
}
}
List《BI》 best_individual; // 存储每一代中最优秀的个体
public GA(Labyrinth labyrinth) {
this.labyrinth=labyrinth;
this.width = labyrinth.map.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;
individuals = new ArrayList《boolean》(population);
best_individual = new ArrayList《BI》(iter_limit);
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public double getCross_ratio() {
return cross_ratio;
}
public List《BI》 getBest_individual() {
return best_individual;
}
public Labyrinth getLabyrinth() {
return labyrinth;
}
public void setLabyrinth(Labyrinth labyrinth) {
this.labyrinth = labyrinth;
}
public void setChrom_len(int chrom_len) {
this.chrom_len = chrom_len;
}
public void setPopulation(int population) {
this.population = population;
}
public void setCross_ratio(double cross_ratio) {
this.cross_ratio = cross_ratio;
}
public void setMuta_ratio(double muta_ratio) {
this.muta_ratio = muta_ratio;
}
public void setIter_limit(int iter_limit) {
this.iter_limit = iter_limit;
}
// 初始化种群
public void initPopulation() {
Random r = new Random(System.currentTimeMillis());
for (int i = 0; i 《 population; i++) {
int len = gene_len * chrom_len;
boolean ind = new boolean[len];
for (int j = 0; j 《 len; j++)
ind[j] = r.nextBoolean();
individuals.add(ind);
}
}
// 交叉
public void cross(boolean arr1, boolean arr2) {
Random r = new Random(System.currentTimeMillis());
int length = arr1.length;
int slice = 0;
do {
slice = r.nextInt(length);
} while (slice == 0);
if (slice 《 length / 2) {
for (int i = 0; i 《 slice; i++) {
boolean tmp = arr1[i];
arr1[i] = arr2[i];
arr2[i] = tmp;
}
} else {
for (int i = slice; i 《 length; i++) {
boolean tmp = arr1[i];
arr1[i] = arr2[i];
arr2[i] = tmp;
}
}
}
// 变异
public void mutation(boolean individual) {
int length = individual.length;
Random r = new Random(System.currentTimeMillis());
individual[r.nextInt(length)] ^= false;
}
// 轮盘法选择下一代,并返回当代最高的适应度值
public double selection() {
boolean next_generation = new boolean[population]; // 下一代
int length = gene_len * chrom_len;
for (int i = 0; i 《 population; i++)
next_generation[i] = new boolean[length];
double cumulation = new double[population];
int best_index = 0;
double max_fitness = getFitness(individuals.get(best_index));
cumulation = max_fitness;
for (int i = 1; i 《 population; i++) {
double fit = getFitness(individuals.get(i));
cumulation[i] = cumulation[i - 1] + fit;
// 寻找当代的最优个体
if (fit 》 max_fitness) {
best_index = i;
max_fitness = fit;
}
}
Random rand = new Random(System.currentTimeMillis());
for (int i = 0; i 《 population; i++)
next_generation[i] = individuals.get(findByHalf(cumulation,
rand.nextDouble() * cumulation[population - 1]));
// 把当代的最优个体及其适应度放到best_individual中
BI bi = new BI(max_fitness, individuals.get(best_index));
// printPath(individuals.get(best_index));
//System.out.println(max_fitness);
best_individual.add(bi);
// 新一代作为当前代
for (int i = 0; i 《 population; i++)
individuals.set(i, next_generation[i]);
return max_fitness;
}
// 折半查找
public int findByHalf(double arr, double find) {
if (find 《 0 || find == 0 || find 》 arr[arr.length - 1])
return -1;
int min = 0;
int max = arr.length - 1;
int medium = min;
do {
if (medium == (min + max) / 2)
break;
medium = (min + max) / 2;
if (arr[medium] 《 find)
min = medium;
else if (arr[medium] 》 find)
max = medium;
else
return medium;
} while (min 《 max);
return max;
}
// 计算适应度
public double getFitness(boolean individual) {
int length = individual.length;
// 记录当前的位置,入口点是（1,0）
int x = 1;
int y = 0;
// 根据染色体中基因的指导向前走
for (int i = 0; i 《 length; i++) {
boolean b1 = individual[i];
boolean b2 = individual[++i];
// 00向左走
if (b1 == false && b2 == false) {
if (x 》 0 && labyrinth.map[y][x - 1] == true) {
x--;
}
}
// 01向右走
else if (b1 == false && b2 == true) {
if (x + 1 《 width && labyrinth.map[y][x + 1] == true) {
x++;
}
}
// 10向上走
else if (b1 == true && b2 == false) {
if (y 》 0 && labyrinth.map[y - 1][x] == true) {
y--;
}
}
// 11向下走
else if (b1 == true && b2 == true) {
if (y + 1 《 height && labyrinth.map[y + 1][x] == true) {
y++;
}
}
}
int n = Math.abs(x - labyrinth.x_end) + Math.abs(y -labyrinth.y_end) + 1;
// if(n==1)
// printPath(individual);
return 1.0 / n;
}
// 运行遗传算法
public boolean run() {
// 初始化种群
initPopulation();
Random rand = new Random(System.currentTimeMillis());
boolean success = false;
while (iter_limit-- 》 0) {
// 打乱种群的顺序
Collections.shuffle(individuals);
for (int i = 0; i 《 population - 1; i += 2) {
// 交叉
if (rand.nextDouble() 《 cross_ratio) {
cross(individuals.get(i), individuals.get(i + 1));
}
// 变异
if (rand.nextDouble() 《 muta_ratio) {
mutation(individuals.get(i));
}
}
// 种群更替
if (selection() == 1) {
success = true;
break;
}
}
return success;
}
// public static void main(String args) {
// GA ga = new GA(8, 8);
// if (!ga.run()) {
// System.out.println(“没有找到走出迷宫的路径.“);
// } else {
// int gen = ga.best_individual.size();
// boolean individual = ga.best_individual.get(gen - 1).indv;
// System.out.println(ga.getPath(individual));
// }
// }
// 根据染色体打印走法
public String getPath(boolean individual) {
int length = individual.length;
int x = 1;
int y = 0;
LinkedList《String》 stack=new LinkedList《String》();
for (int i = 0; i 《 length; i++) {
boolean b1 = individual[i];
boolean b2 = individual[++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(“左“);
}
} else if (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(“右“);
}
} else if (b1 == true && b2 == false) {
if (y 》 0 && labyrinth.map[y - 1][x] == true) {
y--;
if(!stack.isEmpty() && stack.peek()==“下“)
stack.poll();
else
stack.push(“上“);
}
} else if (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=new StringBuilder(length/4);
Iterator《String》 iter=stack.descendingIterator();
while(iter.hasNext())
sb.append(iter.next());
return sb.toString();
}
}
遗传算法的matlab代码实现是什么
遗传算法我懂，我的论文就是用着这个算法，具体到你要遗传算法是做什么？优化什么的。。。我给你一个标准遗传算法程序供你参考：该程序是遗传算法优化BP神经网络函数极值寻优：%% 该代码为基于神经网络遗传算法的系统极值寻优%% 清空环境变量clcclear%% 初始化遗传算法参数%初始化参数maxgen=100; %进化代数，即迭代次数sizepop=20; %种群规模pcross=[0.4]; %交叉概率选择，0和1之间pmutation=[0.2]; %变异概率选择，0和1之间lenchrom=[1 1]; %每个变量的字串长度，如果是浮点变量，则长度都为1bound=[-5 5;-5 5]; %数据范围individuals=struct(’fitness’,zeros(1,sizepop), ’chrom’,); %将种群信息定义为一个结构体avgfitness=; %每一代种群的平均适应度bestfitness=; %每一代种群的最佳适应度bestchrom=; %适应度最好的染色体%% 初始化种群计算适应度值% 初始化种群for i=1:sizepop %随机产生一个种群 individuals.chrom(i,:)=Code(lenchrom,bound); x=individuals.chrom(i,:); %计算适应度 individuals.fitness(i)=fun(x); %染色体的适应度end%找最好的染色体[bestfitness bestindex]=min(individuals.fitness);bestchrom=individuals.chrom(bestindex,:); %最好的染色体avgfitness=sum(individuals.fitness)/sizepop; %染色体的平均适应度% 记录每一代进化中最好的适应度和平均适应度trace=[avgfitness bestfitness]; %% 迭代寻优% 进化开始for i=1:maxgen i % 选择 individuals=Select(individuals,sizepop); avgfitness=sum(individuals.fitness)/sizepop; %交叉 individuals.chrom=Cross(pcross,lenchrom,individuals.chrom,sizepop,bound); % 变异 individuals.chrom=Mutation(pmutation,lenchrom,individuals.chrom,sizepop,[i maxgen],bound); % 计算适应度 for j=1:sizepop x=individuals.chrom(j,:); %解码 individuals.fitness(j)=fun(x); end %找到最小和最大适应度的染色体及它们在种群中的位置 [newbestfitness,newbestindex]=min(individuals.fitness); [worestfitness,worestindex]=max(individuals.fitness); % 代替上一次进化中最好的染色体 if bestfitness》newbestfitness bestfitness=newbestfitness; bestchrom=individuals.chrom(newbestindex,:); end individuals.chrom(worestindex,:)=bestchrom; individuals.fitness(worestindex)=bestfitness; avgfitness=sum(individuals.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]);
如何用遗传算法实现多变量的最优化问题
将多个变量的数值编码编排进去，进行组合。
简单的来说，就是将多个变量的数值编码编排进去，进行组合，只需要增长基因个体的长度，但是要明确每个变量具体的位置，然后让每个变量转化成二进制的等长编码，组合在一起，就可以来运算了！
初始代码：trace = zeros(3,MAXGEN);
然后，要构造一个译码矩阵FieldD，由bs2rv函数将种群Chrom根据译码矩阵换成时值向量，返回十进制的矩阵。
FieldD=[len;lb;ub;code;scale;lbin;ubin];
ObjV = Y.*sin(2*pi*X)+X.*cos(2*pi*Y);
然后按如下代码操作：
while gen 《 MAXGEN
FitnV = ranking(-ObjV);
Selch = select(’sus’,Chrom,FitnV,GGAP);
Selch = recombin(’xovsp’,Selch,px);
Selch = mut(Selch,pm);
XY = bs2rv(Selch,FieldD);
X = XY(:,1);Y = XY(:,2);
ObjvSel = Y.*sin(2*pi*X)+X.*cos(2*pi*Y);
[Chrom,ObjV] = reins(Chrom,Selch,1,1,ObjV,ObjvSel);
XY = bs2rv(Chrom,FieldD);
gen = gen + 1;
[Y,I] = min(ObjV);
trace(1:2,gen) = XY(I,:);
trace(3,gen) = Y;
end