遺傳演算法python編譯
遺傳演算法（GA）是最早由美國Holland教授提出的一種基於自然界的「適者生存，優勝劣汰」基本法則的智能搜索演算法。
遺傳演算法也是借鑒該基本法則，通過基於種群的思想，將問題的解通過編碼的方式轉化為種群中的個體，並讓這些個體不斷地通過選擇、交叉和變異運算元模擬生物的進化過程，然後利用「優勝劣汰」法則選擇種群中適應性較強的個體構成子種群，然後讓子種群重復類似的進化過程，直到找到問題的最優解或者到達一定的進化（運算）時間。
『貳』 請問編程小白，想自學遺傳演算法編程，用於證券市場交易策略效果模擬與
建議學c#，語法簡練優雅，類庫功能豐富。
c#的框架類庫目前已超過15000個類型。很多功能都被封裝好了，不用你自己去一一實現，相當於站在巨人的肩膀上。
C#開發windows平台的應用程序非常成熟，開發效率很高。
『叄』 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)
defgeneEncoding(pop_size,chrom_length):
pop=[[]]
foriinrange(pop_size):
temp=[]
forjinrange(chrom_length):
temp.append(random.randint(0,1))
pop.append(temp)
returnpop[1:]
#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
#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
#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的小數，然後分別和各個基因的累積個體適應度進行比較。如果累積個體適應度大於隨機數則進行保留，否則就淘汰。這一塊的核心思想在於：一個基因的個體適應度越高，他所佔據的累計適應度空隙就越大，也就是說他越容易被保留下來。
#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
- 變異：
#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
- 整個遺傳演算法的實現完成了，總的調用入口代碼如下
#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代最優解的變化趨勢表現出來。
其中genEncodeing是自定義的一個簡單隨機生成序列的函數，具體實現如下
[python]view plain
編碼完成之後就是要進行個體評價，個體評價主要是計算各個編碼出來的list的值以及對應帶入目標式子的值。其實編碼出來的就是一堆2進制list。這些2進制list每個都代表了一個數。其值的計算方式為轉換為10進制，然後除以2的序列長度次方減一，也就是全一list的十進制減一。根據這個規則就能計算出所有list的值和帶入要計算式子中的值，代碼如下
[python]view plain
有了具體的值和對應的基因序列，然後進行一次淘汰，目的是淘汰掉一些不可能的壞值。這里由於是計算最大值，於是就淘汰負值就好了
[python]view plain
然後就是進行選擇，這是整個遺傳演算法最核心的部分。選擇實際上模擬生物遺傳進化的優勝劣汰，讓優秀的個體盡可能存活，讓差的個體盡可能的淘汰。個體的好壞是取決於個體適應度。個體適應度越高，越容易被留下，個體適應度越低越容易被淘汰。具體的代碼如下
[python]view plain
選擇完後就是進行交配和變異，這個兩個步驟很好理解。就是對基因序列進行改變，只不過改變的方式不一樣
交配：
[python]view plain
[python]view plain
[python]view plain
完整代碼可以在github查看
歡迎訪問我的個人博客
閱讀全文
『肆』 使用流行的遺傳演算法python庫是哪個
剛從github上面安裝了兩個遺傳演算法的庫，tpot和gplearn。才剛接觸遺傳演算法，不敢多講
『伍』 請問，遺傳演算法中的交叉編譯概率在編寫子函數時為啥要在rand(1)小於概...
遺傳演算法中的交叉變異概率在編子函數時，應該是rand(1)產生的隨機數小於交叉率pc,或交叉率pm才能進行交叉變異操作。
因為遺傳演算法中，交叉變異操作是以一定的交叉率pc和一定的變異率pm執行的。所以首先選擇參與交叉或變異操作的個體進入到交配池，選擇過程是隨機選擇的，即滿足rand(1)
<pc或rand(1)
<pm才被選擇
『陸』 python有沒有簡單的遺傳演算法庫
最後還是用DEAP搞定了....雖然中間過程還是看不太懂，但是只要會添加函數就可以用了，這就是工程師的好處吧
『柒』 求遺傳演算法（GA）C語言代碼
.----來個例子，大家好理解..--
基於遺傳演算法的人工生命模擬
#include<stdio.h>
#include<stdlib.h>
#include<graphics.h>
#include<math.h>
#include<time.h>
#include<string.h>
#include "graph.c"
/* 宏定義 */
#define TL1 20 /* 植物性食物限制時間 */
#define TL2 5 /* 動物性食物限制時間 */
#define NEWFOODS 3 /* 植物性食物每代生成數目 */
#define MUTATION 0.05 /* 變異概率 */
#define G_LENGTH 32 /* 個體染色體長度 */
#define MAX_POP 100 /* 個體總數的最大值 */
#define MAX_FOOD 100 /* 食物總數的最大值 */
#define MAX_WX 60 /* 虛擬環境的長度最大值 */
#define MAX_WY 32 /* 虛擬環境的寬度最大值 */
#define SX1 330 /* 虛擬環境圖左上角點x坐標 */
#define SY1 40 /* 虛擬環境圖左上角點y坐標 */
#define GX 360 /* 個體數進化圖形窗口的左上角點X坐標 */
#define GY 257 /* 個體數進化圖形窗口的左上角點Y坐標 */
#define GXR 250 /* 個體數進化圖形窗口的長度 */
#define GYR 100 /* 個體數進化圖形窗口的寬度 */
#define GSTEP 2 /* 個體數進化圖形窗口的X方向步長 */
#define R_LIFE 0.05 /* 初期產生生物數的環境比率 */
#define R_FOOD 0.02 /* 初期產生食物數的環境比率 */
#define SL_MIN 10 /* 個體壽命最小值 */
/* 全局變數 */
unsigned char gene[MAX_POP][G_LENGTH]; /* 遺傳基因 */
unsigned char iflg[MAX_POP]; /* 個體死活狀態標志變數 */
『捌』 關於遺傳演算法的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實現的遺傳演算法優化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
『拾』 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