2. 程式人生 > >遺傳演算法上機系列之用遺傳演算法求函式最值問題（附自己寫的程式碼）

遺傳演算法上機系列之用遺傳演算法求函式最值問題（附自己寫的程式碼）

阿新 • • 發佈：2018-12-19

本文基於下面的最值問題進行求解： maxf(x1,x2)=21.5+x1sin(4πx1)+x2sin(20πx2)\ max f(x_1,x_2)=21.5+x_1sin(4\pi x_1)+x_2sin(20\pi x_2) −3.0≤x1≤12.1\ -3.0\le x_1\le 12.1 4.1≤x2≤5.8\ 4.1\le x_2\le 5.8 精度要求ϵ=10−4\epsilon=10^{-4}

遺傳演算法的基本步驟

step1：按某種編碼方式產生初始種群
p(0)\ p(0),設種群代數t=0\ t=0；

常用編碼方式：

二進位制編碼、實數編碼、整數編碼、排列編碼、有限狀態機編碼、樹編碼……（本例中我們採用二進位制編碼，需要對應解碼）

二進位制編碼

x∈[a,b]\ x \in[a,b]，精度要求不小於10−α\ 10^{-\alpha}. 編碼公式：2m−1−1<(b−a)∗10α≤2m−1\ 2^{m-1}-1<(b-a)*10^\alpha\le2^{m-1},根據取值範圍即可求出共需要多少位二進位制數才能滿足精度要求 解碼公式：y=a+(b−a)∗x

2m−1\ y=a+(b-a)*\frac{x}{2^m-1}（其中x\ x為無符號二進位制換算成十進位制之後的值）

本例中，按照精度要求及取值範圍，x1\ x_1需要18位二進位制編碼，x2\ x_2需要15位二進位制編碼。 以下為初始化部分程式碼：

//初始化種群
void init()
{
	double p=0.5;
	//srand(time(0));
	for(int i=0;i<NUMBER;i++)
	{
		string s;
		for(int j=0;j<33;j++)
		{
			double r = rand();
		    if(r>RAND_MAX/2)
				s.append("1");
			else
				s.append("0");
		}
		pop.push_back(s);
	}
}

step2：計算種群p(t)\ p(t)中每個個體的適應度值；

即按照解碼公式進行解碼之後帶入函式中計算f(x1,x2)\ f(x_1,x_2)的值，即為本例的適應度值。相關程式碼如下（individual為自定義結構體，包含當前計算個體對應的x1,x2,f\ x_1,x_2,f三個值：

//計算適應度值
individual Fitness(string s)
{
	individual T;
	double x1a = -3.0;
	double x1b = 12.1;
	double x2a = 4.1;
	double x2b = 5.8;
	string s1 = s.substr(0,18);
	string s2 = s.substr(18,15);
	int t1 = Transform(s1);
	int t2 = Transform(s2);
	T.x1 = x1a+(x1b-x1a)*t1/(pow(2.0,18)-1);
	T.x2 = x2a+(x2b-x2a)*t2/(pow(2.0,15)-1);
	T.fit = 21.5+T.x1*sin(4*PI*T.x1) +T.x2*sin(20*PI*T.x2);
	return T;
}

step3：按某種規則從p(t)\ p(t)中選擇一個子群體p′(t)\ p&#x27;(t)作為產生後代的父母，用交叉運算元作用於p′(t)\ p&#x27;(t)產生交叉後代集合O′(t)\ O&#x27;(t),再用變異運算元作用於O′(t)\ O&#x27;(t)產生變異後代集合O(t)\ O(t),計算O(t)\ O(t)中每個後代的適應度；

某種規則：本例使用輪盤賭選擇（根據每個個體適應度所佔總適應度的比例，以及產生隨機數的大小，選擇出一部分個體進入交叉池，這樣適應度大的的個體會有更大的可能性被選為父母進行交叉，優良基因得以保留下去） 下面是輪盤賭選擇部分程式碼：

//輪盤賭選擇
vector<string> choose(vector<string> population,int x)
{
	//srand(time(0));
	double fitness_sum=0;
	vector<double> q;
	vector<individual> indi_vec;
	vector<string> result;
	double p=0;
	vector<double> random;
	for (int i = 0; i < x; i++)
	{
		double r = rand();
		random.push_back(r / (double)RAND_MAX);
	}
	for(int i=0;i<population.size();i++)
	{
		individual Indi=Fitness(population[i]);
		indi_vec.push_back(Indi);
		fitness_sum=fitness_sum+Indi.fit;	
	}
	for(int i=0;i<population.size();i++)
	{
		individual Indi=indi_vec[i];
		p=p+Indi.fit/fitness_sum;
		if(i==population.size()-1)
			q.push_back(1.0);
		else
			q.push_back(p);
	}
	for(int i=0;i<random.size();i++)
	{
		for(int j=0;j<q.size();j++)
		{
			if (random[i]>q[j] && random[i] <= q[j + 1])
			{
				result.push_back(population[j + 1]);
				break;
			}		
		}
	}
	return result;
}

交叉運算元：單點交叉、兩點交叉、多點交叉、均勻交叉、部分匹配交叉、順序交叉、迴圈交叉、二維交叉…… 本例使用兩點交叉做為交叉運算元，在一對個體上選擇兩個相同的點位，切斷之後進行交換即產生兩個後代，下面是交叉部分程式碼：

//兩點交叉
vector<string> crossover(vector<string>population)
{
	//srand(time(0));
	vector<string> result;
	for(int i=0;i+1<population.size();i=i+2)
	{
		string s1=population[i];
		string s2=population[i+1];
		double r = rand();
		if (r<pc*RAND_MAX)
		{
			int i1 = (int)(rand()/RAND_MAX)*33;
			int i2 = (int)(rand() / RAND_MAX) * 33;
			if(i1<i2)
			{
				string sub1=s1.substr(i1,i2-i1);
				string sub2=s2.substr(i1,i2-i1);
				s1.replace(i1,i2-i1,sub2);
				s2.replace(i1,i2-i1,sub1);
				result.push_back(s1);
				result.push_back(s2);
			}
			else{
				if (i1 > i2)
				{
					string sub1 = s1.substr(i2, i1 - i2);
					string sub2 = s2.substr(i2, i1 - i2);
					s1.replace(i2, i1 - i2, sub2);
					s2.replace(i2, i1 - i2, sub1);
					result.push_back(s1);
					result.push_back(s2);
				}
				else
				{
					result.push_back(s1);
					result.push_back(s2);
				}
			}
		}
		else
		{
			result.push_back(s1);
			result.push_back(s2);
		}
	}
	return result;
}

變異運算元：單點變異、對換變異、移位變異、插入便宜、均勻變異、正態變異、非一致變異…… 本例使用單點變異作為變異運算元，即產生隨機數，將對應位上的二進位制編碼取反即可，下面為變異部分程式碼：

//單點變異
string mutation(string s)
{
	//srand(time(0));
	for(int i=0;i<33;i++)
	{
		double r = rand();
		if (r<pm*RAND_MAX)
		{
			if(s[i]=='0')
				s[i]='1';
			else
				s[i]='0';
		}
	}
	return s;
}

step4：用選擇運算元從集合p(t)UO(t)\ p(t)UO(t)中選出下一代種群p(t+1)\ p(t+1),令t=t+1\ t=t+1;

此步驟同樣用輪盤賭選擇作為選擇運算元選出進入下一代中的個體

step5：如演算法滿足終止條件，則輸出p(t+1)\ p(t+1)中具有最大適應度值的個體作為最優解，中止演算法。否則，進入步驟2.

終止條件：要麼迭代代數達到限制範圍，要麼很多代後的最好個體沒有繼續改進即可停止。

以下為全部程式碼（一般在執行到300+代時即可達到最優解）：

#include "stdafx.h"
#include <string>
#include <time.h>
#include <windows.h>
#include <math.h>
#include <iostream>
#include <vector>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

#define NUMBER 20
#define PI 3.14159265358979323

vector<string> pop;
double pc = 0.5;
double pm = 0.1;
string max_s;

//個體結構體
struct individual
{
	double x1=0;
	double x2=0;
	double fit=0;
};

//初始化種群
void init()
{
	double p=0.5;
	//srand(time(0));
	for(int i=0;i<NUMBER;i++)
	{
		string s;
		for(int j=0;j<33;j++)
		{
			double r = rand();
		    if(r>RAND_MAX/2)
				s.append("1");
			else
				s.append("0");
		}
		pop.push_back(s);
	}
}

//二進位制字串轉換成整形
int Transform(string s)
{
    int n =0;
    for(int i = 0; i<s.size(); i++)
    {
        n = n*2 + s[i]-'0';
    }
    return n;
}

//解碼並計算適應度
individual Fitness(string s)
{
	individual T;
	double x1a = -3.0;
	double x1b = 12.1;
	double x2a = 4.1;
	double x2b = 5.8;
	string s1 = s.substr(0,18);
	string s2 = s.substr(18,15);
	int t1 = Transform(s1);
	int t2 = Transform(s2);
	T.x1 = x1a+(x1b-x1a)*t1/(pow(2.0,18)-1);
	T.x2 = x2a+(x2b-x2a)*t2/(pow(2.0,15)-1);
	T.fit = 21.5+T.x1*sin(4*PI*T.x1) +T.x2*sin(20*PI*T.x2);
	return T;
}

//輪盤賭選擇
vector<string> choose(vector<string> population,int x)
{
	//srand(time(0));
	double fitness_sum=0;
	vector<double> q;
	vector<individual> indi_vec;
	vector<string> result;
	double p=0;
	vector<double> random;
	for (int i = 0; i < x; i++)
	{
		double r = rand();
		random.push_back(r / (double)RAND_MAX);
	}
	for(int i=0;i<population.size();i++)
	{
		individual Indi=Fitness(population[i]);
		indi_vec.push_back(Indi);
		fitness_sum=fitness_sum+Indi.fit;	
	}
	for(int i=0;i<population.size();i++)
	{
		individual Indi=indi_vec[i];
		p=p+Indi.fit/fitness_sum;
		if(i==population.size()-1)
			q.push_back(1.0);
		else
			q.push_back(p);
	}
	for(int i=0;i<random.size();i++)
	{
		for(int j=0;j<q.size();j++)
		{
			if (random[i]>q[j] && random[i] <= q[j + 1])
			{
				result.push_back(population[j + 1]);
				break;
			}		
		}
	}
	return result;
}

//兩點交叉
vector<string> crossover(vector<string>population)
{
	//srand(time(0));
	vector<string> result;
	for(int i=0;i+1<population.size();i=i+2)
	{
		string s1=population[i];
		string s2=population[i+1];
		double r = rand();
		if (r<pc*RAND_MAX)
		{
			int i1 = (int)(rand()/RAND_MAX)*33;
			int i2 = (int)(rand() / RAND_MAX) * 33;
			if(i1<i2)
			{
				string sub1=s1.substr(i1,i2-i1);
				string sub2=s2.substr(i1,i2-i1);
				s1.replace(i1,i2-i1,sub2);
				s2.replace(i1,i2-i1,sub1);
				result.push_back(s1);
				result.push_back(s2);
			}
			else{
				if (i1 > i2)
				{
					string sub1 = s1.substr(i2, i1 - i2);
					string sub2 = s2.substr(i2, i1 - i2);
					s1.replace(i2, i1 - i2, sub2);
					s2.replace(i2, i1 - i2, sub1);
					result.push_back(s1);
					result.push_back(s2);
				}
				else
				{
					result.push_back(s1);
					result.push_back(s2);
				}
			}
		}
		else
		{
			result.push_back(s1);
			result.push_back(s2);
		}
	}
	return result;
}

//單點變異
string mutation(string s)
{
	//srand(time(0));
	for(int i=0;i<33;i++)
	{
		double r = rand();
		if (r<pm*RAND_MAX)
		{
			if(s[i]=='0')
				s[i]='1';
			else
				s[i]='0';
		}
	}
	return s;
}

//返回本輪適應度值最大的個體
individual print_(vector<string> generation)
{
	individual max;
	for (int i = 0; i < generation.size(); i++)
	{
		individual Ind = Fitness(generation[i]);
		if (Ind.fit>max.fit)
		{
			max = Ind;
			max_s = generation[i];
		}
	}
	return max;
}

int main(int argc, _TCHAR* argv[])
{
	srand(time(0));
	individual Max;
	init();
	int j = 0;
	double MAX = 0;
	while (j < 5000)
	{
		vector<string> pop1, pop2, pop3, pop_new;		
		pop1 = choose(pop,NUMBER);
		pop2 = crossover(pop1);
		double max1 = 0;
		double max2 = 0;
		string s1;
		string s2;
		for (int i = 0; i < pop2.size(); i++)
		{
			string s = mutation(pop2[i]);
			pop3.push_back(s);
			double d = Fitness(pop2[i]).fit;
			if ( d> max1)
			{
				s1 = pop2[i];
				max1 = d;
			}
		}
		for (int i = 0; i < pop3.size(); i++)
		{
			double d = Fitness(pop3[i]).fit;
			if (d > max2)
			{
				s2 = pop3[i];
				max2 = d;
			}
		}
		pop_new = choose(pop, NUMBER-2);
		pop_new.push_back(s1);
		pop_new.push_back(s2);
		pop = pop_new;
		individual max = print_(pop);
		if (max.fit > Max.fit)
		{
			cout << j + 1 << ":" << max.x1 << ";" << max.x2 << ";" << max.fit << endl;
			Max = max;
			pop.push_back(max_s);
		}
		else
			cout << j + 1 << ":" << Max.x1 << ";" << Max.x2 << ";" << Max.fit << endl;
		j++;
	}
	system("pause");
	return 0;
}

相關推薦

遺傳演算法上機系列之用遺傳演算法求函式最值問題（附自己寫的程式碼）

本文基於下面的最值問題進行求解： maxf(x1,x2)=21.5+x1sin(4πx1)+x2sin(20πx2)\ max f(x_1,x_2)=21.5+x_1sin(4\pi x_1)+x_2sin(20\pi x_2)maxf(x1​,x2​)=21.

還在用PCA降維？快學學大牛最愛的t-SNE演算法吧（附Python/R程式碼）

大資料文摘作品編譯：寒小陽、蔣寶尚、Sheila、賴小娟、錢天培假設你有一個包含數百個特徵（變數

機器學習系列(12)_XGBoost參數調優完全指南（附Python代碼）

row cti tar libraries 叠代 數據科學家 值範圍 邏輯回歸 doc https://blog.csdn.net/han_xiaoyang/article/details/52665396 轉： 原文地址：Complete Guide to Paramet

【備戰春招/秋招系列】美團面經總結基礎篇 （附詳解答案）

該文已加入開源文件：JavaGuide（一份涵蓋大部分Java程式設計師所需要掌握的核心知識）。地址:github.com/Snailclimb/…. 【強烈推薦！非廣告！】阿里雲雙11褥羊毛活動：m.aliyun.com/act/team111… 差不多一折，不過僅限阿里雲新人購買，不是新人的朋

資料結構系列——字尾樹（附Java實現程式碼）

字尾樹，說的通俗點就是將一個字串所有的字尾按照字首樹（Trie樹，可參考此篇文章）的形式組織成一棵樹。 什麼是字尾樹 舉例：“banana\0”，其中 “\0” 作為文字結束符號，該字串所有的字尾如下： banana\0 anana\0 na

用QT實現Wake On Lan功能（附全部程式原始碼）

Wake On Lan也就是遠端喚醒（遠端開機），即通過一臺PC向另一臺已經關機但仍連線電源PC傳送網路資料包，使其開機的功能，前提是兩臺PC同處一個區域網內，且被喚醒方的網絡卡支援網路喚醒功能（現在網絡卡基本上都支援啦）。 原理：PC關閉後，網絡卡仍能獲取電源，一直監聽“m

arcgis api 4.x for js 結合 react 入門開發系列react全家桶實現加載天地圖（附源碼下載）

style foo 多說 target pat tile es6 wrap 頁面 基於兩篇react+arcgis的文章介紹，相信大家也能體會兩者的開發區別了。在“初探篇”中作者也講述了自己的選擇，故廢話不多說，本篇帶大家體驗在@arcgis/web

遺傳程式設計（GA，genetic programming）演算法初探，以及用遺傳程式設計自動生成符合題解的正則表示式的實踐

1. 遺傳程式設計簡介 0x1：什麼是遺傳程式設計演算法，和傳統機器學習演算法有什麼區別 傳統上，我們接觸的機器學習演算法，都是被設計為解決某一個某一類問題的確定性演算法。對於這些機器學習演算法來說，唯一的靈活性體現在引數搜尋空間上，向演算法輸入樣本，演算法藉助不同的優化手段，對引數進行調整，以此來得到一

演算法題系列之六 - 兩整數之和

不使用運算子 + 和 - ，計算兩整數 ​​​​​​​a 、b ​​​​​​​之和。 示例 1: 輸入: a = 1, b = 2 輸出: 3 示例 2: 輸入: a = -2, b = 3 輸出: 1 方法

演算法題系列之五 - 對稱二叉樹

給定一個二叉樹，檢查它是否是映象對稱的。 例如，二叉樹 [1,2,2,3,4,4,3] 是對稱的。 1 / \ 2 2 / \ / \ 3 4 4 3 但是下面這個 [1,2,2,null,3,null,3] 則不是映

演算法題系列之四 - 柱狀圖儲水

題目： 給定一個數組，每個位置的值代表一個高度，那麼整個陣列可以看做是一個直方圖， 如果把這個直方圖當作容器的話，求這個容器能裝多少水 例如：3，1，2，4 代表第一個位置高度為3，第二個位置高度為1，以此類推，這個直方圖能裝3格水。如圖紅色地方：   思路：

演算法題系列之三 - 單鏈表反轉

問題： 實現單鏈表反轉 答案： 連結串列準備 class Node { private int Data;// 資料域 private Node Next;// 指標域 public Node(int Data) { // super(); this.Data = Da

演算法題系列之二 - 反波蘭式

問題： 用反波蘭式表示算術表示式的值。 有效運算子是+,-,*,/。每個運算元可以是一個整數或另一個表示式。 一些例子：   ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9 ["4", "13", "5", "/"

matlab手寫遺傳演算法解決一元函式最值問題（例項）

問題：找出y=x4-4x3+3x+5 （xÎ[0,6]）在[0,6]之間的最小值。 思路：用33位0，1變數來編碼x,3位編碼整數，30位編碼小數。理論上30位編碼小數可以將最小值對應的x精確到小數點後九位. 下面是我解決這個問題所有的函式，複製就可以運行了，不明白可以私

遺傳演算法解決TSP旅行商問題（附：Python實現）

前言 我先囉嗦一下：不是很喜歡寫計算智慧的演算法，因為一個演算法就要寫好久。前前後後將近有兩天的時間。 好啦，現在進入正題。 巡迴旅行商問題(TSP)是一個組合優化方面的問題，已經成為測試組合優化新演算法的標準問題。應用遺傳演算法解決 TSP 問題，首先對訪問

大資料與算法系列之數值查詢演算法

查詢是指在大量的資料中尋找特定的元素，它是數值計算中常用的運算邏輯，一般情況下，可以按照順序依次查詢，但是在資料量較大的情況下，順序查詢的效能往往會讓人望而卻步，折半查詢和二叉樹查詢可以針對的數值序列做到快速查詢，雜湊查詢則是針對無序的數值序列查詢，它們都具有較好的效能。二分

無人機系列之飛控演算法

一.無人機的分類 按飛行平臺構型分類：無人機可分為固定翼無人機，旋翼無人機，無人飛艇，傘翼無人機，撲翼無人機等. 圖1 無人機平臺構型 多軸飛行器multirotor是一種具有三個以上旋翼軸的特殊

Python實現遺傳演算法（二進位制編碼）求函式最優值

目標函式 maxf(x1,x2)=21.5+x1sin(4πx1)+x2sin(20πx2) max f({x_1},{x_2}) = 21.5 + {x_1}\sin (4\pi {x_1}) + {x_2}\sin (20\pi {x_2})

機器學習系列之K-近鄰演算法（監督學習-分類問題）

''' @description ： 演算法優點： a簡單、易於理解、易於實現、無需估計引數、無需訓練 演算法缺點： a懶惰演算法，對測試樣本分類時計算量大，記憶體開銷大 b必須制定k值，k值得選擇

“0公式系列”之粒子濾波演算法----逃離迷宮

放在開頭，“0公式系列”：無公式，無理論，單靠動畫，或圖片，加上個人理解，來解釋演算法中的思想。 你醒來在一個迷宮內，不知道自己在這個大迷宮的哪一個位置，你要出去，但是你也不能亂走吧，正當你迷茫的時候，你發現自己手裡有一張紙質的迷宮地圖，該地圖不僅包含了迷宮的形狀，還包括了