本文目录一览：
matlab遗传算法代码检查错误
发现的几处错误：
1、适应度函数里面if a[i]=4改为if a(i)==4，类似的还有if b[i]=4。不需要多解释了吧？一个是数组注意和C语言风格区别，另一个是判断相等的符号问题。
2、适应度函数应返回列向量，在fit函数最后加一句：fitness=fitness(:);
3、选择的结果是种群规模减小，不能使用固定的出示规模20，应把适应度函数里面两处循环for i=1:20改为for i=1:size(x,1)。
4、主函数里面rein应为reins。
代码写到一个M文件中：
function zd
%% 初始化遗传算法参数
%初始化参数
NIND=20;
MAXGEN=100;
NVAR=8;
PRECI=1;
GGAP=0.9;% 进化代数，即迭代次数
% 种群规模
%% 初始化种群计算适应度值
% 初始化种群
FieldD=[rep(PRECI,[1,NVAR]);rep([0;1],[1,NVAR]);rep([1;0;1;1],[1,NVAR])];
Chrom=crtbp(NIND,NVAR*PRECI);
ObjV=fit(bs2rv(Chrom,FieldD));
gen=0;
while genMAXGEN
FitnV=ranking(ObjV);
SelCh=select('sus',Chrom,FitnV,GGAP);
SelCh=recombin('xovsp',SelCh,0.7);
SelCh=mut(SelCh,0.07);
ObjVSel=fit(bs2rv(SelCh,FieldD));
[Chrom ObjV]=reins(Chrom,SelCh,1,1,ObjV,ObjVSel);
gen=gen+1
%找最好的染色体
trace(gen,1)=min(ObjV);
trace(gen,2)=sum(ObjV)/length(ObjV);
end
plot(trace(:,1)); hold on;
plot(trace(:,2)); grid;
legend('average','bestfitness');
function [fitness]=fit(x)
for i=1:size(x,1)
i
%随机产生一个种群
if (x(i,6)*x(i,7)-x(i,8)*x(i,6))*(x(i,3)*x(i,2)-x(i,4)*x(i,1))==0
x(i,:)=unidrnd(2,1,8)-1;
end%染色体的适应度
end
a=x(:,1)+x(:,2)+x(:,3)+x(:,4);
b=x(:,5)+x(:,6)+x(:,7)+x(:,8);
for i=1:size(x,1)
i
if a(i)==4
c=1;
else
c=0;
end
if b(i)==4
d=1;
else
d=0;
end
fitness(i)=c+d;
end
fitness=fitness(:);
遗传算法伪代码是什么
以下是遗传算法的伪代码。
BEGIN:
I = 0; //进化种群代数
Initialize P(I); //初始化种群
Fitness P(I); //“适者生存”遗传选择
While(not Terminate-Condition) //不满足终止条件时，循环
{
I ++; //循环
GA-Operation P(I); //遗传算法运算or操作
Fitness P(I); //“适者生存”遗传选择
}
END. //结束算法
希望对你有所帮助！
求遗传算法（GA）C语言代码
x=220;
for(i=0;i12;i++)
{
y=202+i*16;
for(j=bits [ i][0];j=bits [ i][1];j++)
if(g[j]==0)
g_text(x+(j-bits [ i][0])*16,y,4,"0");
else
g_text(x+(j-bits [ i][0])*16,y,4,"1");
}
}
}
void g_disp_char(x,y,x1,y1,x2,y2,v)
int x,y,x1,y1,x2,y2;
unsigned char v;
{
char c[10];
if(x=x1 x=x2-8 y=y1 y=y2-10)
{
switch(v)
{
case 0: strcpy(c,"0");break;
case 1: strcpy(c,"+");break;
case 2: strcpy(c,"-");break;
case 3: strcpy(c,"x");
}
g_text(x,y,15,c);
}
}
void remove_life(n) /* 消除第n个个体 */
int n;
{
iflg[n]=0;
world[iatr[n][0]][iatr[n][1]]=0;
g_disp_unit(iatr[n][0],iatr[n][1],0);
if(food_size+1=MAX_FOOD)
{
food_size++;
fatr[food_size-1][0]=iatr[n][0];
fatr[food_size-1][1]=iatr[n][1];
fatr[food_size-1][2]=1;
fatr[food_size-1][3]=0;
fflg[food_size-1]=1;
world[iatr[n][0]][iatr[n][1]]=5;
g_disp_unit(iatr[n][0],iatr[n][1],5);
}
}
void remove_food(n) /* 消除第n个食物 */
int n;
{
fflg[n]=0;
world[fatr[n][0]][fatr[n][1]]=0;
g_disp_unit(fatr[n][0],fatr[n][1],0);
}
void make_lives_and_foods() /* 设置虚拟环境中生物与食物 */
{
int x,y,i,j;
pop_size=0;
food_size=0;
for(y=0;ywy;y++)
for(x=0;xwx;x++)
{
if(world[x][y]==1||world[x][y]==2)
{
if(pop_size+1=MAX_POP)
{
pop_size++;
/* 生成遗传因子 */
gene[pop_size-1][0]=world[x][y]-1;
for(i=1;iG_LENGTH;i++)
gene[pop_size-1] [ i]=random(2);
/* 设定属性 */
iatr[pop_size-1][0]=x;
iatr[pop_size-1][1]=y;
iatr[pop_size-1][2]=70+random(30);
iatr[pop_size-1][3]=random(SL_MIN);
}
}
if(world[x][y]==3||world[x][y]==5)
{
if(food_size+1=MAX_FOOD)
{
food_size++;
/* 设定属性 */
fatr[food_size-1][0]=x;
fatr[food_size-1][1]=y;
if(world[x][y]==3)
fatr[food_size-1][2]=0;
else
fatr[food_size-1][2]=1;
fatr[food_size-1][3]=random(TL1-1)+1;
}
}
}
}
void find_empty(x,y) /* 寻找虚拟环境中的空处，返回坐标 */
int *x,*y;
{
int ok;
ok=0;
while(ok==0)
{
*x=random(wx);*y=random(wy);
if(world[*x][*y]==0) ok=1;
}
}
void make_world() /* 随机设定人工环境 */
{
int i,j,k,num,x,y;
int ok,overlap;
char choice[3];
double size;
wx=0;
while(wx10||wxMAX_WX)
{
setcolor(15);
disp_hz16("虚拟环境长度(10-60)",10,210,20);
gscanf(300,210,4,0,3,"%s",choice);
wx=atoi(choice);
}
wy=0;
while(wy10||wyMAX_WY)
{
setcolor(15);
disp_hz16("虚拟环境宽度(10-32)",10,240,20);
gscanf(300,240,4,0,3,"%s",choice);
wy=atoi(choice);
}
for(i=0;iwy;i++)
for(j=0;jwx;j++)
if(i==0||i==wy-1||j==0||j==wx-1)
world[j] [ i]=4;
else world[j] [ i]=0;
/* 设定障碍物 */
size=(double)(wx*wy);
num=(int)(size/40.0);
if(numMAX_POP) num=MAX_POP;
for(i=0;inum;i++)
{
find_empty(x,y);
world[x][y]=4;
}
num=(int)(size/5.0);
if(numMAX_FOOD) num=MAX_FOOD;
for(i=0;inum;i++)
{
ok=0;
while(ok==0)
{
x=random(wx);y=random(wy);
if((world[x][y]!=4)
(world[x][y-1]==4 || world[x][y+1]==4 ||
world[x-1][y]==4 || world[x+1][y]==4))
{ world[x][y]=4;
ok=1;
}
}
}
for(y=0;ywy;y++)
for(x=0;xwx;x++)
if(world[x][y]==0)
{
num=0;
for(i=-1;i=1;i++)
for(j=-1;j=1;j++)
if(get_world(x+j,y+i)==4)
num++;
if(num=6) world[x][y]=4;
}
/* 设定生物 */
num=(int)(size*R_LIFE);
for(i=0;inum;i++)
{ find_empty(x,y);
world[x][y]=random(2)+1;
}
/* 设定食物 */
num=(int)(size*R_FOOD);
for(i=0;inum;i++)
{
find_empty(x,y);
world[x][y]=3;
}
}
void load_world_file() /* 读取虚拟环境数据文件设定 */
{
FILE *fopen(),*fpt;
char st[100],c;
int i,j;
if((fpt=fopen("\ga\world","r"))==NULL) exit(-1);
else
{
fscanf(fpt,"%d",wx);
fscanf(fpt,"%d",wy);
for(i=0;iwy;i++)
for(j=0;jwx;j++)
fscanf(fpt,"%d",world[j] [ i]);
fclose(fpt);
python有没有简单的遗传算法库
首先遗传算法是一种优化算法，通过模拟基因的优胜劣汰，进行计算（具体的算法思路什么的就不赘述了）。大致过程分为初始化编码、个体评价、选择，交叉，变异。
以目标式子 y = 10 * sin(5x) + 7 * cos(4x)为例，计算其最大值
首先是初始化，包括具体要计算的式子、种群数量、染色体长度、交配概率、变异概率等。并且要对基因序列进行初始化
[python] view plain copy
pop_size = 500 # 种群数量
max_value = 10 # 基因中允许出现的最大值
chrom_length = 10 # 染色体长度
pc = 0.6 # 交配概率
pm = 0.01 # 变异概率
results = [[]] # 存储每一代的最优解，N个二元组
fit_value = [] # 个体适应度
fit_mean = [] # 平均适应度
pop = geneEncoding(pop_size, chrom_length)
其中genEncodeing是自定义的一个简单随机生成序列的函数，具体实现如下
[python] view plain copy
def geneEncoding(pop_size, chrom_length):
pop = [[]]
for i in range(pop_size):
temp = []
for j in range(chrom_length):
temp.append(random.randint(0, 1))
pop.append(temp)
return pop[1:]
编码完成之后就是要进行个体评价，个体评价主要是计算各个编码出来的list的值以及对应带入目标式子的值。其实编码出来的就是一堆2进制list。这些2进制list每个都代表了一个数。其值的计算方式为转换为10进制，然后除以2的序列长度次方减一，也就是全一list的十进制减一。根据这个规则就能计算出所有list的值和带入要计算式子中的值，代码如下-遗传算法代码
[python] view plain copy
# 0.0 coding:utf-8 0.0
# 解码并计算值
import math
def decodechrom(pop, chrom_length):
temp = []
for i in range(len(pop)):
t = 0
for j in range(chrom_length):
t += pop[i][j] * (math.pow(2, j))
temp.append(t)
return temp
def calobjValue(pop, chrom_length, max_value):
temp1 = []
obj_value = []
temp1 = decodechrom(pop, chrom_length)
for i in range(len(temp1)):
x = temp1[i] * max_value / (math.pow(2, chrom_length) - 1)
obj_value.append(10 * math.sin(5 * x) + 7 * math.cos(4 * x))
return obj_value
有了具体的值和对应的基因序列，然后进行一次淘汰，目的是淘汰掉一些不可能的坏值。这里由于是计算最大值，于是就淘汰负值就好了
[python] view plain copy
# 0.0 coding:utf-8 0.0
# 淘汰（去除负值）
def calfitValue(obj_value):
fit_value = []
c_min = 0
for i in range(len(obj_value)):
if(obj_value[i] + c_min 0):
temp = c_min + obj_value[i]
else:
temp = 0.0
fit_value.append(temp)
return fit_value
然后就是进行选择，这是整个遗传算法最核心的部分。选择实际上模拟生物遗传进化的优胜劣汰，让优秀的个体尽可能存活，让差的个体尽可能的淘汰。个体的好坏是取决于个体适应度。个体适应度越高，越容易被留下，个体适应度越低越容易被淘汰。具体的代码如下-遗传算法代码
[python] view plain copy
# 0.0 coding:utf-8 0.0
# 选择
import random
def sum(fit_value):
total = 0
for i in range(len(fit_value)):
total += fit_value[i]
return total
def cumsum(fit_value):
for i in range(len(fit_value)-2, -1, -1):
t = 0
j = 0
while(j = i):
t += fit_value[j]
j += 1
fit_value[i] = t
fit_value[len(fit_value)-1] = 1
def selection(pop, fit_value):
newfit_value = []
# 适应度总和
total_fit = sum(fit_value)
for i in range(len(fit_value)):
newfit_value.append(fit_value[i] / total_fit)
# 计算累计概率
cumsum(newfit_value)
ms = []
pop_len = len(pop)
for i in range(pop_len):
ms.append(random.random())
ms.sort()
fitin = 0
newin = 0
newpop = pop
# 转轮盘选择法
while newin pop_len:
if(ms[newin] newfit_value[fitin]):
newpop[newin] = pop[fitin]
newin = newin + 1
else:
fitin = fitin + 1
pop = newpop
以上代码主要进行了3个操作，首先是计算个体适应度总和，然后在计算各自的累积适应度。这两步都好理解，主要是第三步，转轮盘选择法。这一步首先是生成基因总数个0-1的小数，然后分别和各个基因的累积个体适应度进行比较。如果累积个体适应度大于随机数则进行保留，否则就淘汰。这一块的核心思想在于：一个基因的个体适应度越高，他所占据的累计适应度空隙就越大，也就是说他越容易被保留下来。-遗传算法代码
选择完后就是进行交配和变异，这个两个步骤很好理解。就是对基因序列进行改变，只不过改变的方式不一样
交配：
[python] view plain copy
# 0.0 coding:utf-8 0.0
# 交配
import random
def crossover(pop, pc):
pop_len = len(pop)
for i in range(pop_len - 1):
if(random.random() pc):
cpoint = random.randint(0,len(pop[0]))
temp1 = []
temp2 = []
temp1.extend(pop[i][0:cpoint])
temp1.extend(pop[i+1][cpoint:len(pop[i])])
temp2.extend(pop[i+1][0:cpoint])
temp2.extend(pop[i][cpoint:len(pop[i])])
pop[i] = temp1
pop[i+1] = temp2
变异：
[python] view plain copy
# 0.0 coding:utf-8 0.0
# 基因突变
import random
def mutation(pop, pm):
px = len(pop)
py = len(pop[0])
for i in range(px):
if(random.random() pm):
mpoint = random.randint(0, py-1)
if(pop[i][mpoint] == 1):
pop[i][mpoint] = 0
else:
pop[i][mpoint] = 1
整个遗传算法的实现完成了，总的调用入口代码如下
[python] view plain copy
# 0.0 coding:utf-8 0.0
import matplotlib.pyplot as plt
import math
from calobjValue import calobjValue
from calfitValue import calfitValue
from selection import selection
from crossover import crossover
from mutation import mutation
from best import best
from geneEncoding import geneEncoding
print 'y = 10 * math.sin(5 * x) + 7 * math.cos(4 * x)'
# 计算2进制序列代表的数值
def b2d(b, max_value, chrom_length):
t = 0
for j in range(len(b)):
t += b[j] * (math.pow(2, j))
t = t * max_value / (math.pow(2, chrom_length) - 1)
return t
pop_size = 500 # 种群数量
max_value = 10 # 基因中允许出现的最大值
chrom_length = 10 # 染色体长度
pc = 0.6 # 交配概率
pm = 0.01 # 变异概率
results = [[]] # 存储每一代的最优解，N个二元组
fit_value = [] # 个体适应度
fit_mean = [] # 平均适应度
# pop = [[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] for i in range(pop_size)]
pop = geneEncoding(pop_size, chrom_length)
for i in range(pop_size):
obj_value = calobjValue(pop, chrom_length, max_value) # 个体评价
fit_value = calfitValue(obj_value) # 淘汰
best_individual, best_fit = best(pop, fit_value) # 第一个存储最优的解, 第二个存储最优基因
results.append([best_fit, b2d(best_individual, max_value, chrom_length)])
selection(pop, fit_value) # 新种群复制
crossover(pop, pc) # 交配
mutation(pop, pm) # 变异
results = results[1:]
results.sort()
X = []
Y = []
for i in range(500):
X.append(i)
t = results[i][0]
Y.append(t)
plt.plot(X, Y)
plt.show()
最后调用了一下matplotlib包，把500代最优解的变化趋势表现出来。
完整代码可以在github 查看
欢迎访问我的个人博客
阅读全文
遗传算法的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]; %数据范围
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 bestfitnessnewbestfitness
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]);
