ga.cpp

用C#写的一个神经网络结合遗传算法优化的程序

#include "stdafx.h"
#include "GA.h"
CGA::CGA(int popsize, double mutationrate, double crossoverrate, int numweights):m_iPopSize(popsize),
                                                                                 m_dMutationRate(mutationrate),
	                                                                             m_dCrossoverRate(crossoverrate),
	                                                                             m_iChromoLength(numweights),
																				 m_dTotalFitness(0),
																				 m_dBestFitness(0),
																				 m_dAverageFitness(0),
																				 m_dWorstFitness(99999999),
																				 m_iFittestGenome(0),
																				 m_iGeneration(0)
{//构造函数应该用“初始化列表”还是“赋值”？
	for(int i=0; i<m_iPopSize; i++)
	{
		m_vecPop.push_back(SGenome());//适应度为0
		for(int j=0; j<m_iChromoLength; j++)
		{
			m_vecPop[i].vecWeights.push_back(RandomClamped());//随机权值序列

		}
	}	
}
void CGA::Mutate(vector<double> &chromo)
{
	for(int i=0; i<(int)chromo.size(); i++)
	{
		if(RandFloat()<m_dMutationRate)
		{
			chromo[i]+=(RandomClamped()*0.3);
		}
	}
}
SGenome CGA::GetChromoRoulette()//
{
	double Slice=(double)(RandFloat()*m_dTotalFitness);
	SGenome TheChosenOne;
	double FitnessSoFar=0;
	for(int i=0; i<m_iPopSize; i++)
	{
		FitnessSoFar+=m_vecPop[i].dFitness;
		if(FitnessSoFar>=Slice)
		{
			TheChosenOne=m_vecPop[i];
			break;
		}
	}
	return TheChosenOne;
}
void CGA::Crossover(const std::vector<double> &mum, const std::vector<double> &dad, std::vector<double> &baby1, std::vector<double> &baby2)
{
	if(RandFloat()>m_dCrossoverRate||mum==dad)//
	{
		baby1=mum;
		baby2=dad;
		return;
	}
	int cp = RandInt(0, m_iChromoLength - 1);
	for(int i=0; i<cp; i++)
	{
		baby1.push_back(mum[i]);
		baby2.push_back(dad[i]);
	}
	for(int i=cp; i<(int)mum.size(); i++)
	{
		baby1.push_back(dad[i]);
		baby2.push_back(mum[i]);
	}
	return;
}
vector<SGenome> CGA::Epoch(std::vector<SGenome> &old_pop)
{
	m_vecPop=old_pop;
	Reset();
	sort(m_vecPop.begin(), m_vecPop.end());

	CalculateBestWorstAvTot();
	vector<SGenome> vecNewPop;
	if(!(1*4%2))
	{
		GrabNBest(4,1,vecNewPop);
	}
	while((int)vecNewPop.size()<m_iPopSize)
	{
		SGenome mum=GetChromoRoulette();
		SGenome dad=GetChromoRoulette();
		vector<double> baby1, baby2;
		Crossover(mum.vecWeights, dad.vecWeights, baby1, baby2);
		Mutate(baby1);
		Mutate(baby2);
		vecNewPop.push_back(SGenome(baby1,0));
		vecNewPop.push_back(SGenome(baby2,0));
	}
	m_vecPop=vecNewPop;
	return m_vecPop;
}
void CGA::GrabNBest(int NBest, const int NumCopies, std::vector<SGenome> &vecPop)
{
	while(NBest--)
	{
		for(int i=0; i<NumCopies; i++)
		{
			vecPop.push_back(m_vecPop[m_iPopSize-NBest-1]);
		}
	}
}
void CGA::CalculateBestWorstAvTot()
{
	m_dTotalFitness=0;
	double HighestSoFar=0;
	double LowestSoFar=9999999;
	for(int i=0; i<m_iPopSize; i++)
	{
		if(m_vecPop[i].dFitness>HighestSoFar)
		{
			HighestSoFar=m_vecPop[i].dFitness;
			m_iFittestGenome=i;
			m_dBestFitness=HighestSoFar;
		}
		if(m_vecPop[i].dFitness<LowestSoFar)
		{
			LowestSoFar=m_vecPop[i].dFitness;
			m_dWorstFitness=LowestSoFar;
		}
		m_dTotalFitness += m_vecPop[i].dFitness;
	}
	m_dAverageFitness = m_dTotalFitness/m_iPopSize;
}
void CGA::Reset()
{
	m_dTotalFitness=0;
	m_dBestFitness=0;
	m_dWorstFitness=9999999;
	m_dAverageFitness=0;
}