population.cpp

- XCS for Dynamic Environments + Continuous versions of XCS + Test problem: real multiplexer +

/*	XCSR_DE1.0
*	--------------------------------------------------------
*	Learning classifier system based on accuracy in dynamic environments
*
*	by  Huong Hai (Helen) Dam
*	[e-mail]
*	UNSW @ ADFA, Canberra Australia
*	Artificial Life and Adaptive Robotics Laboratory
*	http://www.itee.adfa.edu.au/~alar
*
*	Last modified: 24-11-2005
*
*/
#include "population.h"
#include <math.h>

Population::Population(int seed)
{	
	random = new Random(); 
	random->setSeed(seed);
	num_new_rules = 0;
	num_delete_rules = 0;
}
Population::~Population()
{
	int size = c_classifiers.size();
	for(int i = 0; i < size; i++)
		delete c_classifiers[i];
	c_classifiers.clear();
}

int Population::getPopSize()
{
	int my_size=0;
	for(int i = 0; i < c_classifiers.size(); i++)
		my_size += c_classifiers[i]->getNum();
	
	return my_size;
}

void Population::addClassifier(Classifier *c){
	c->validateClassifier();
	c_classifiers.push_back(c);
	num_new_rules ++;
}

Classifier* Population::getClassifierC(int i){
	
	return c_classifiers[i];
}

int Population::getClassifierP(Classifier *c){
	int pos = -1;
	
	int size = c_classifiers.size();
	for(int i = 0; i  < size; i++)
	{
		if(c_classifiers[i]->matchClassifier(c))
		{
			pos = i;
			break;
		}
	}
	return pos;
}

void Population::deleteClassifier(int i)
{
	int schema = c_classifiers[i]->getSchema();
	delete c_classifiers[i];
	c_classifiers.erase (c_classifiers.begin() + i);
	num_delete_rules ++;
}
void Population::emptyPopulation()
{
	int size = c_classifiers.size();
	for(int i = size-1; i >= 0; i--)
		deleteClassifier(i);
}
void Population::deletePartialPopulation(double proportion)
{
	int size = c_classifiers.size();
	for(int i = size -1; i >= 0; i--)
	{
		if(random->nextDouble()<proportion)
			deleteClassifier(i);
	}
}
void Population::reinitParam()
{
	int size = c_classifiers.size();
	for(int i = size -1; i >= 0; i --)
		c_classifiers[i]->resetParam();
}
void Population::deleteFromPopulation()
{
	int i;
	int check = FALSE;
	
	double meanf = 0.0;
	int total = 0;
	
	int num_classifier = getNumMacro();
	for(i = 0; i < num_classifier; i++)
	{
		Classifier *tempc = getClassifierC(i);
		meanf += tempc->getFitness();
		total += tempc->getNum();
	}
	if(total != 0)
	{
		meanf = meanf/(double)total;
	}
	else
	{
		meanf = 0.0;
	}
	double voteSum = 0.0;
	//Get delete proportion , which depend on the average fitness
	for(i = 0; i < num_classifier; i++)
	{
		voteSum += (double)getClassifierC(i)->getNum() * deleteVote(getClassifierC(i), meanf);
	}
	double choicePoint = (double)random->nextDouble() * voteSum;
	voteSum = 0.0;
	for (i = 0; i < num_classifier; i++)
	{
		voteSum += getClassifierC(i)->getNum() * deleteVote(getClassifierC(i), meanf);
		if(voteSum > choicePoint)
		{
			if(getClassifierC(i)->getNum() > 1){
				getClassifierC(i)->decreaseNum();
			}
			else{
				deleteClassifier(i);
			}
			break;
		}
		
	}
}
//Using the deletion vote which realizes niching as well as removal of 
//the lowest fitness classifiers
double Population::deleteVote(Classifier *cl, double avgFitInPop)
{
	//double vote = cl->getAS() * cl->getNum();
	double vote = 1.0;
	if((cl->getExp() >= THETADEL) && (cl->getFitness()/cl->getNum() < DELTA *avgFitInPop))	
		vote = vote * avgFitInPop/(cl->getFitness()/(double)cl->getNum());
	return vote;
}

int Population::getNumNewRules()
{
	int num = num_new_rules;
	num_new_rules = 0;
	return num;
}
int Population::getNumDeleteRules()
{
	int num = num_delete_rules;
	num_delete_rules = 0;
	return num;
}

void Population::snapshotReport(ofstream &resultfile)
{
	int nclassifiers = c_classifiers.size();
	//resultfile<<"No.  Fitness      Prediction      Prediction Error     Condition   Action  Number"<<endl;
	
	for(int i = 0; i <  nclassifiers ; i++)
	{
		Classifier *temp = getClassifierC(i);
		for(int j=0; j < COND_OFFSET; j++)
		{
			resultfile<<temp->getIntervalMin(j)<<"\t";
			resultfile<<temp->getIntervalMax(j)<<"|";
		}
		resultfile<<temp->getAction()<<"\t";
		resultfile<<temp->getPrediction()<<"\t";
		resultfile<<temp->getPredictionError()<<"\t";
		resultfile<<temp->getFitness()<<"\t";
		resultfile<<temp->getNum()<<"\t";
		resultfile<<temp->getExp();
		resultfile<<endl;
	}
	
}
//Return order and length of the schema in the population
int** Population::getBBData()
{
	int **bb_inf = new int *[COND_OFFSET+1];
	int psize = getNumMacro();
	int order, length;
	int i,j;
	for(i = 0; i < COND_OFFSET+1; i++)
		bb_inf[i]= new int[COND_OFFSET];
	for(i = 0; i < COND_OFFSET+1; i++)
	{
		for(j = 0; j < COND_OFFSET; j++)
		{
			bb_inf[i][j] = 0;
		}
	}
	for(int i = 0; i  < psize; i++)
	{
		order = getClassifierC(i)->getSchemaOrder();
		length = getClassifierC(i)->getSchemaLength();
		bb_inf[order][length] ++;
	}
	return bb_inf;
}
#ifdef MP
//The first two array elements are the macro number and numericity of classifiers, which the condition is a schema id and having a correct action. The last two array elements are number and numericity of classifiers with incorrect action.
double* Population::getNumSchemas(double threshold, int id)
{
	int popsize = getNumMacro();
	double *num_schema = new double[4];
	int i;
	for(i = 0; i < 4; i++)
	{
		num_schema[i] = 0.;
	}
	for(i = 0; i < popsize; i++)
	{
		if(getClassifierC(i)->isASchema(threshold, id))
		{
			getClassifierC(i)->setSchema(id);
			if((id%2 == 0 && getClassifierC(i)->getAction() == 0)||//Schema 0,2,4,6 has 0 as a corrected class
				(id%2 == 1 && getClassifierC(i)->getAction() == 1))//Schema 1,3,5,7 has 1 as a corrected class
			{
				num_schema[0]+=getClassifierC(i)->getFitness()*
					getClassifierC(i)->getPrediction();
				num_schema[1]+=getClassifierC(i)->getNum();
			}
			else
			{
				num_schema[2]+=getClassifierC(i)->getFitness()*
					getClassifierC(i)->getPrediction();
				num_schema[3]+= getClassifierC(i)->getNum();
			}
		}
	}
	return num_schema;
}
double* Population::getNumClassifiersInSchema(double threshold, int id)
{
	int popsize = getNumMacro();
	double *num_classifiers = new double[4];
	int i;
	for(int i = 0; i < 4; i++)
	{
		num_classifiers[i] = 0.;
	}
	for(i = 0; i < popsize; i++)
	{
		if(getClassifierC(i)->belongToSchema(threshold, id))
		{
			if((id%2 == 0 && getClassifierC(i)->getAction() == 0)||//Schema 0,2,4,6 has 0 as a corrected class
				(id%2 == 1 && getClassifierC(i)->getAction() == 1))//Schema 1,3,5,7 has 1 as a corrected class
			{
				num_classifiers[0]+=getClassifierC(i)->getFitness()* 
					getClassifierC(i)->getPrediction();
				num_classifiers[1]+=getClassifierC(i)->getNum();
			}
			else
			{
				num_classifiers[2]+=getClassifierC(i)->getFitness()*
					getClassifierC(i)->getPrediction();
				num_classifiers[3]+= getClassifierC(i)->getNum();
			}
		}
	}
	
	return num_classifiers;
}
#endif
int* Population::getNumMacroInRegion()
{
	int *num = new int[5] ;
	for (int j = 0; j < 5; j++)
		num[j] = 0;
	int popsize = getNumMacro();
	for(int i = 0; i < popsize; i++)
	{
		
		for(int j = 0; j < COND_OFFSET; j++)
		{
			double max = c_classifiers[i]->getIntervalMax(j);
			double min = c_classifiers[i]->getIntervalMin(j);
			if(min  > LOWER_BOUND && max < UPPER_BOUND)
				num[1]++;
			else if(min <= LOWER_BOUND && max >= UPPER_BOUND)
				num[4]++;
			else	if(min > LOWER_BOUND && max >= UPPER_BOUND)
			{
				num[3]++;
			}
			else if(min <= LOWER_BOUND && max < UPPER_BOUND)
			{
				num[2]++;
			}
			else
				cout<<"Strange interval:"<<min<<", "<<max<<endl;
			
		}
		
	}
	return num;
}