遺傳演算法python實驗報告

⑴ python 遺傳演算法問題

遺傳演算法（GA）是最早由美國Holland教授提出的一種基於自然界的「適者生存，優勝劣汰」基本法則的智能搜索演算法。
遺傳演算法也是借鑒該基本法則，通過基於種群的思想，將問題的解通過編碼的方式轉化為種群中的個體，並讓這些個體不斷地通過選擇、交叉和變異運算元模擬生物的進化過程，然後利用「優勝劣汰」法則選擇種群中適應性較強的個體構成子種群，然後讓子種群重復類似的進化過程，直到找到問題的最優解或者到達一定的進化（運算）時間。

⑵ 關於遺傳演算法的Python，請問如何修改達到想要的目的

defrun(self):
foriinrange(self.generation_max):
self.generation=i
self.evolve()
printi
foriinrange(self.indivials):
(x,y)=self.decode(interval,chrom1)
self.decode(interval,chrom2))
print（x,y)

⑶ 老師要求用python做遺傳演算法，原理明白，可是不會代碼，哪位老哥幫講講，價錢可以商量

還是蠻簡單的，而且 python 中有現成的遺傳演算法工具箱可用。
實現的關鍵則是如何進行編碼，這個碼就是函數的參數，參數的個數就是染色體中基因的個數， 選擇交叉變異，無非就是改變基因的值而不改變染色體的長度，然後產生新的染色體，將新的染色體重的值以參數的形式帶入到函數中求得新的函數值

⑷ Python 遺傳演算法的數學應用

來自nnetinfo目前可以做的一般有:分類.函數擬合壓縮.圖象識別等等,其實說到底,所有的都能歸於第2點--函數擬合.一般如果輸入與輸出是有強烈關系的,網路都能找得到這個關系.例如病人的特徵作為輸入,判斷這個是否為病人,一般都是可以的.業務背景知識強,才能把神經網路運用到實際中.另外,還需要把實現問題轉換為數學問題的能力.例如數字識別就是一個經典的應用.但直接把圖片放進去訓練是得不到識別效果的,因為維度太多了,而且信息冗餘量很大.於是有人把圖片的特徵先自已提取出來:例如對角線與圖片上的數字有幾個交點等等,再把這些特徵作為輸入,數字類別向量作為輸出,放到網路中訓練.最後你再寫一個數字,提取這個數字的特徵,再把這特徵放進網路中的時候,它就能識別到你是哪個數字了.另外,又有人用卷積神經網路去做數字識別.還有人用深度網路去做,即先把原來圖片的信息用RBM網路進行壓縮,然後再訓練,效果就好了.等等,其實很多問題都可以做,但前提是你要想到好的方式去運用神經網路.

⑸ python有沒有簡單的遺傳演算法庫

首先遺傳演算法是一種優化演算法，通過模擬基因的優勝劣汰，進行計算（具體的演算法思路什麼的就不贅述了）。大致過程分為初始化編碼、個體評價、選擇，交叉，變異。

以目標式子 y = 10 * sin(5x) + 7 * cos(4x)為例，計算其最大值

首先是初始化，包括具體要計算的式子、種群數量、染色體長度、交配概率、變異概率等。並且要對基因序列進行初始化

[python]view plain

• 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

• defgeneEncoding(pop_size,chrom_length):

• pop=[[]]

• foriinrange(pop_size):

• temp=[]

• forjinrange(chrom_length):

• temp.append(random.randint(0,1))

• pop.append(temp)

• returnpop[1:]

編碼完成之後就是要進行個體評價，個體評價主要是計算各個編碼出來的list的值以及對應帶入目標式子的值。其實編碼出來的就是一堆2進制list。這些2進制list每個都代表了一個數。其值的計算方式為轉換為10進制，然後除以2的序列長度次方減一，也就是全一list的十進制減一。根據這個規則就能計算出所有list的值和帶入要計算式子中的值，代碼如下

[python]view plain

• #0.0coding:utf-80.0

• #解碼並計算值

• importmath

• defdecodechrom(pop,chrom_length):

• temp=[]

• foriinrange(len(pop)):

• t=0

• forjinrange(chrom_length):

• t+=pop[i][j]*(math.pow(2,j))

• temp.append(t)

• returntemp

• defcalobjValue(pop,chrom_length,max_value):

• temp1=[]

• obj_value=[]

• temp1=decodechrom(pop,chrom_length)

• foriinrange(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))

• returnobj_value

有了具體的值和對應的基因序列，然後進行一次淘汰，目的是淘汰掉一些不可能的壞值。這里由於是計算最大值，於是就淘汰負值就好了

[python]view plain

• #0.0coding:utf-80.0

• #淘汰（去除負值）

• defcalfitValue(obj_value):

• fit_value=[]

• c_min=0

• foriinrange(len(obj_value)):

• if(obj_value[i]+c_min>0):

• temp=c_min+obj_value[i]

• else:

• temp=0.0

• fit_value.append(temp)

• returnfit_value




然後就是進行選擇，這是整個遺傳演算法最核心的部分。選擇實際上模擬生物遺傳進化的優勝劣汰，讓優秀的個體盡可能存活，讓差的個體盡可能的淘汰。個體的好壞是取決於個體適應度。個體適應度越高，越容易被留下，個體適應度越低越容易被淘汰。具體的代碼如下

[python]view plain

• #0.0coding:utf-80.0

• #選擇

• importrandom

• defsum(fit_value):

• total=0

• foriinrange(len(fit_value)):

• total+=fit_value[i]

• returntotal

• defcumsum(fit_value):

• foriinrange(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

• defselection(pop,fit_value):

• newfit_value=[]

• #適應度總和

• total_fit=sum(fit_value)

• foriinrange(len(fit_value)):

• newfit_value.append(fit_value[i]/total_fit)

• #計算累計概率

• cumsum(newfit_value)

• ms=[]

• pop_len=len(pop)

• foriinrange(pop_len):

• ms.append(random.random())

• ms.sort()

• fitin=0

• newin=0

• newpop=pop

• #轉輪盤選擇法

• whilenewin<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

• #0.0coding:utf-80.0

• #交配

• importrandom

• defcrossover(pop,pc):

• pop_len=len(pop)

• foriinrange(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

• #0.0coding:utf-80.0

• #基因突變

• importrandom

• defmutation(pop,pm):

• px=len(pop)

• py=len(pop[0])

• foriinrange(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

• #0.0coding:utf-80.0

• importmatplotlib.pyplotasplt

• importmath

• fromselectionimportselection

• fromcrossoverimportcrossover

• frommutationimportmutation

• frombestimportbest

• print'y=10*math.sin(5*x)+7*math.cos(4*x)'

• #計算2進制序列代表的數值

• defb2d(b,max_value,chrom_length):

• t=0

• forjinrange(len(b)):

• t+=b[j]*(math.pow(2,j))

• t=t*max_value/(math.pow(2,chrom_length)-1)

• returnt

• 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]foriinrange(pop_size)]

• pop=geneEncoding(pop_size,chrom_length)

• foriinrange(pop_size):

• obj_value=calobjValue(pop,chrom_length,max_value)#個體評價

• fit_value=calfitValue(obj_value)#淘汰

• best_indivial,best_fit=best(pop,fit_value)#第一個存儲最優的解,第二個存儲最優基因

• results.append([best_fit,b2d(best_indivial,max_value,chrom_length)])

• selection(pop,fit_value)#新種群復制

• crossover(pop,pc)#交配

• mutation(pop,pm)#變異

• results=results[1:]

• results.sort()

• X=[]

• Y=[]

• foriinrange(500):

• X.append(i)

• t=results[i][0]

• Y.append(t)

• plt.plot(X,Y)

• plt.show()

• 最後調用了一下matplotlib包，把500代最優解的變化趨勢表現出來。



完整代碼可以在github查看

歡迎訪問我的個人博客

閱讀全文

⑹ python遺傳演算法目標函數怎麼編

一、遺傳演算法介紹
遺傳演算法是通過模擬大自然中生物進化的歷程，來解決問題的。大自然中一個種群經歷過若干代的自然選擇後，剩下的種群必定是適應環境的。把一個問題所有的解看做一個種群，經歷過若干次的自然選擇以後，剩下的解中是有問題的最優解的。當然，只能說有最優解的概率很大。這里，我們用遺傳演算法求一個函數的最大值。
f(x) = 10 * sin( 5x ) + 7 * cos( 4x ), 0 <= x <= 10
1、將自變數x進行編碼
取基因片段的長度為10, 則10位二進制位可以表示的范圍是0到1023。基因與自變數轉變的公式是x = b2d(indivial) * 10 / 1023。構造初始的種群pop。每個個體的基因初始值是[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
2、計算目標函數值
根據自變數與基因的轉化關系式，求出每個個體的基因對應的自變數，然後將自變數代入函數f（x），求出每個個體的目標函數值。
3、適應度函數
適應度函數是用來評估個體適應環境的能力，是進行自然選擇的依據。本題的適應度函數直接將目標函數值中的負值變成0. 因為我們求的是最大值，所以要使目標函數值是負數的個體不適應環境，使其繁殖後代的能力為0.適應度函數的作用將在自然選擇中體現。
4、自然選擇
自然選擇的思想不再贅述，操作使用輪盤賭演算法。其具體步驟：
假設種群中共5個個體，適應度函數計算出來的個體適應性列表是fitvalue = [1 ,3, 0, 2, 4] ，totalvalue = 10 ， 如果將fitvalue畫到圓盤上，值的大小表示在圓盤上的面積。在轉動輪盤的過程中，單個模塊的面積越大則被選中的概率越大。選擇的方法是將fitvalue轉化為[1 ， 4 ，4 , 6 ，10], fitvalue / totalvalue = [0.1 , 0.4 , 0.4 , 0.6 , 1.0] . 然後產生5個0-1之間的隨機數，將隨機數從小到大排序，假如是[0.05 , 0.2 , 0.7 , 0.8 ,0.9]，則將0號個體、1號個體、4號個體、4號個體、4號個體拷貝到新種群中。自然選擇的結果使種群更符合條件了。
5、繁殖
假設個體a、b的基因是
a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]

b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]

這兩個個體發生基因交換的概率pc = 0.6.如果要發生基因交換，則產生一個隨機數point表示基因交換的位置，假設point = 4,則：

a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]

b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
交換後為：

a = [1, 0, 0, 0, 1, 0, 1, 1, 1, 1]

b = [0, 0, 0, 1, 0, 1, 1, 1, 0, 0]
6、突變
遍歷每一個個體，基因的每一位發生突變（0變為1,1變為0）的概率為0.001.突變可以增加解空間
二、代碼
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def b2d(b): #將二進制轉化為十進制 x∈[0,10] t = 0 for j in range(len(b)): t += b[j] * (math.pow(2, j)) t = t * 10 / 1023 return tpopsize = 50 #種群的大小#用遺傳演算法求函數最大值：#f(x)=10*sin(5x)+7*cos(4x) x∈[0,10]chromlength = 10 #基因片段的長度pc = 0.6 #兩個個體交叉的概率pm = 0.001; #基因突變的概率results = [[]]bestindivial = []bestfit = 0fitvalue = []tempop = [[]]pop = [[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] for i in range(popsize)]for i in range(100): #繁殖100代 objvalue = calobjvalue(pop) #計算目標函數值 fitvalue = calfitvalue(objvalue); #計算個體的適應值 [bestindivial, bestfit] = best(pop, fitvalue) #選出最好的個體和最好的函數值 results.append([bestfit,b2d(bestindivial)]) #每次繁殖，將最好的結果記錄下來 selection(pop, fitvalue) #自然選擇，淘汰掉一部分適應性低的個體 crossover(pop, pc) #交叉繁殖 mutation(pop, pc) #基因突變 results.sort() print(results[-1]) #列印函數最大值和對應的

來自CODE的代碼片
GA.py

1
2
3
4
5
6
7
8
9
def best(pop, fitvalue): #找出適應函數值中最大值，和對應的個體 px = len(pop) bestindivial = [] bestfit = fitvalue[0] for i in range(1,px): if(fitvalue[i] > bestfit): bestfit = fitvalue[i] bestindivial = pop[i] return [bestindivial, bestfit]

來自CODE的代碼片
best.py

1
2
3
4
5
6
7
8
9
10
11
def calfitvalue(objvalue):#轉化為適應值，目標函數值越大越好，負值淘汰。 fitvalue = [] temp = 0.0 Cmin = 0; for i in range(len(objvalue)): if(objvalue[i] + Cmin > 0): temp = Cmin + objvalue[i] else: temp = 0.0 fitvalue.append(temp) return fitvalue

來自CODE的代碼片
calfitvalue.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import mathdef decodechrom(pop): #將種群的二進制基因轉化為十進制（0,1023） temp = []; for i in range(len(pop)): t = 0; for j in range(10): t += pop[i][j] * (math.pow(2, j)) temp.append(t) return tempdef calobjvalue(pop): #計算目標函數值 temp1 = []; objvalue = []; temp1 = decodechrom(pop) for i in range(len(temp1)): x = temp1[i] * 10 / 1023 #（0,1023）轉化為 （0,10） objvalue.append(10 * math.sin(5 * x) + 7 * math.cos(4 * x)) return objvalue #目標函數值objvalue[m] 與個體基因 pop[m] 對應

來自CODE的代碼片
calobjvalue.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import randomdef crossover(pop, pc): #個體間交叉，實現基因交換 poplen = len(pop) for i in range(poplen - 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

來自CODE的代碼片
crossover.py

1
2
3
4
5
6
7
8
9
10
11
12
13
import randomdef 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

來自CODE的代碼片
mutation.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import randomdef sum(fitvalue): total = 0 for i in range(len(fitvalue)): total += fitvalue[i] return totaldef cumsum(fitvalue): for i in range(len(fitvalue)): t = 0; j = 0; while(j <= i): t += fitvalue[j] j = j + 1 fitvalue[i] = t;def selection(pop, fitvalue): #自然選擇（輪盤賭演算法） newfitvalue = [] totalfit = sum(fitvalue) for i in range(len(fitvalue)): newfitvalue.append(fitvalue[i] / totalfit) cumsum(newfitvalue) ms = []; poplen = len(pop) for i in range(poplen): ms.append(random.random()) #random float list ms ms.sort() fitin = 0 newin = 0 newpop = pop while newin < poplen: if(ms[newin] < newfitvalue[fitin]): newpop[newin] = pop[fitin] newin = newin + 1 else: fitin = fitin + 1 pop = newpop

⑺ 遺傳演算法中幾種不同選擇運算元及Python語言實現

在Python這種動態類型語言中貌似看起來有些雞肋，但是為了能夠更加規范使用者，利用Python的元類在實例化類對象的時候對介面的實現以及介面的參數類型加以限制。

⑻ 有沒有用python實現的遺傳演算法優化BP神經網路的代碼

下面是函數實現的代碼部分：
clc
clear all
close all
%% 載入神經網路的訓練樣本 測試樣本每列一個樣本 輸入P 輸出T，T是標簽
%樣本數據就是前面問題描述中列出的數據
%epochs是計算時根據輸出誤差返回調整神經元權值和閥值的次數
load data
% 初始隱層神經元個數
hiddennum=31;
% 輸入向量的最大值和最小值
threshold=[0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1];
inputnum=size(P,1); % 輸入層神經元個數
outputnum=size(T,1); % 輸出層神經元個數
w1num=inputnum*hiddennum; % 輸入層到隱層的權值個數
w2num=outputnum*hiddennum;% 隱層到輸出層的權值個數
N=w1num+hiddennum+w2num+outputnum; %待優化的變數的個數
%% 定義遺傳演算法參數
NIND=40; %個體數目
MAXGEN=50; %最大遺傳代數
PRECI=10; %變數的二進制位數
GGAP=0.95; %代溝
px=0.7; %交叉概率
pm=0.01; %變異概率
trace=zeros(N+1,MAXGEN); %尋優結果的初始值
FieldD=[repmat(PRECI,1,N);repmat([-0.5;0.5],1,N);repmat([1;0;1;1],1,N)]; %區域描述器
Chrom=crtbp(NIND,PRECI*N); %初始種群
%% 優化
gen=0; %代計數器
X=bs2rv(Chrom,FieldD); %計算初始種群的十進制轉換
ObjV=Objfun(X,P,T,hiddennum,P_test,T_test); %計算目標函數值
while gen

⑼ 遺傳演算法tsp 城市100個 種群個數應該是多少

個體基因數為100，建議種群數為100*（3~5）
遺傳代數為100*（8~10）

⑽ Python演算法中如何添加平均適應度圖

今天整理之前寫的代碼，發現在做數模期間寫的用python實現的遺傳演算法，感覺還是挺有意思的，就拿出來分享一下。
首先遺傳演算法是一種優化演算法，通過模擬基因的優勝劣汰，進行計算（具體的演算法思路什麼的就不贅述了）。大致過程分為初始化編碼、個體評價、選擇，交叉，變異。
遺傳演算法介紹
遺傳演算法是通過模擬大自然中生物進化的歷程，來解決問題的。大自然中一個種群經歷過若干代的自然選擇後，剩下的種群必定是適應環境的。把一個問題所有的解看做一個種群，經歷過若干次的自然選擇以後，剩下的解中是有問題的最優解的。當然，只能說有最優解的概率很大。這里，我們用遺傳演算法求一個函數的最大值。
f(x) = 10 * sin( 5x ) 7 * cos( 4x ), 0 <= x <= 10
1、將自變數x進行編碼
取基因片段的長度為10, 則10位二進制位可以表示的范圍是0到1023。基因與自變數轉變的公式是x = b2d(indivial) * 10 / 1023。構造初始的種群pop。每個個體的基因初始值是[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
2、計算目標函數值
根據自變數與基因的轉化關系式，求出每個個體的基因對應的自變數，然後將自變數代入函數f（x），求出每個個體的目標函數值。
3、適應度函數
適應度函數是用來評估個體適應環境的能力，是進行自然選擇的依據。本題的適應度函數直接將目標函數值中的負值變成0. 因為我們求的是最大值，所以要使目標函數值是負數的個體不適應環境，使其繁殖後代的能力為0.適應度函數的作用將在自然選擇中體現。
4、自然選擇
自然選擇的思想不再贅述，操作使用輪盤賭演算法。其具體步驟：
假設種群中共5個個體，適應度函數計算出來的個體適應性列表是fitvalue = [1 ,3, 0, 2, 4] ，totalvalue = 10 ， 如果將fitvalue畫到圓盤上，值的大小表示在圓盤上的面積。在轉動輪盤的過程中，單個模塊的面積越大則被選中的概率越大。選擇的方法是將fitvalue轉化為[1 ， 4 ，4 , 6 ，10], fitvalue / totalvalue = [0.1 , 0.4 , 0.4 , 0.6 , 1.0] . 然後產生5個0-1之間的隨機數，將隨機數從小到大排序，假如是[0.05 , 0.2 , 0.7 , 0.8 ,0.9]，則將0號個體、1號個體、4號個體、4號個體、4號個體拷貝到新種群中。自然選擇的結果使種群更符合條件了。
5、繁殖
假設個體a、b的基因是
a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]
b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
這兩個個體發生基因交換的概率pc = 0.6.如果要發生基因交換，則產生一個隨機數point表示基因交換的位置，假設point = 4,則：
a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]
b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
交換後為：
a = [1, 0, 0, 0, 1, 0, 1, 1, 1, 1]
b = [0, 0, 0, 1, 0, 1, 1, 1, 0, 0]
6、突變
遍歷每一個個體，基因的每一位發生突變（0變為1,1變為0）的概率為0.001.突變可以增加解空間
以目標式子 y = 10 * sin(5x) 7 * cos(4x)為例，計算其最大值
首先是初始化，包括具體要計算的式子、種群數量、染色體長度、交配概率、變異概率等。並且要對基因序列進行初始化
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是自定義的一個簡單隨機生成序列的函數，具體實現如下
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的值和帶入要計算式子中的值，代碼如下
# 0.0 coding:utf-8 0.0