gp.cc

标准的GP源代码,由Andy Singleton维护

     <<endl;
}//end display_best_stats();


void dout(int i)
{
char buf[80]; sprintf(buf,"%5d",i); cout << buf;
}

void display_list(Pop* pop, int output[], int duplicates[], int outputsize, 
		  int popwidth,	BOOL details)
{
#define max_display_list 10

cout<<"Best ("<<outputsize<<") in population "<<endl;

for (int i=0; i<outputsize; i++){
	if (popwidth == 0) dout(output[i]);
	else 
		{dout(output[i] % popwidth);
		 dout(output[i] / popwidth);}
	dout(duplicates[i]);
	pop->pop[output[i]]->nfitness->write();
	cout<<endl;
}//end loop write fitness only

for (i=0; i<outputsize && i<max_display_list; i++){
	if (popwidth == 0) dout(output[i]);
	else 
		{dout(output[i] % popwidth);
		 dout(output[i] / popwidth);}
	dout(duplicates[i]);
	pop->pop[output[i]]->nfitness->write();
#ifdef TRACE
	if ( details ) pop->pop[output[i]]->write(PRETTY_NONE,cout);
#endif
	cout<<endl;
}//end loop
}//end display_list


void display_elite(Pop* pop, int popsize, int popwidth)
{
int i;
const int limit = popsize;
//Chrome*  chromes[limit];
Chrome** chromes = new Chrome* [limit];
int num_elite;
scoretype best [num_ellite_pareto];
int       count[num_ellite_pareto];

find_elite(chromes, limit, num_elite, best, count);

cout<<"Ellite ("<<num_elite<<") in population "<<endl;

cout<<"bst ";
for (i=0; i<num_ellite_pareto; i++){
//	char buf[80]; sprintf(buf,"%4d",best[i]);
//	cout << buf << ",";
	cout << best[i] << ",";
}
cout<<endl;
cout<<"No. ";
for (i=0; i<num_ellite_pareto; i++){
	char buf[80]; sprintf(buf,"%4d",count[i]);
	cout << buf << ",";
}
cout<<endl;

//Now reduce size of list of best in pop by weeding out those dominated
//by others in the list.

int dummy;
int outputsize = num_elite;
//int duplicates[outputsize];
//int slot      [outputsize];
int* duplicates = new int [outputsize];
int* slot       = new int [outputsize];
{
//int output    [outputsize];
int* output     = new int [outputsize];

select_hits(
chromes, num_elite, 0, &dummy, TRUE, output, duplicates, &outputsize);

//Now convert output to slot numbers in pop.

for (i=0; i<outputsize; i++){
	BOOL found = FALSE;
	for(int s=0; !found; s++) {
		assert(s<popsize);
		if(pop->pop[s] == chromes[output[i]]) {
			found = TRUE;
			slot[i] = s;
		}
	}
}
delete[] output;
}//end scope output

display_list(pop, slot, duplicates, outputsize, popwidth, TRUE);

delete[] slot;
delete[] duplicates;
delete[] chromes;
}//end display_elite();

void display_all_best(Pop* pop, int popsize, int popwidth, BOOL details)
{
int dummy;
int outputsize = popsize;
//int output[outputsize];
//int duplicates[outputsize];
int* output     = new int [outputsize];
int* duplicates = new int [outputsize];

select_hits(
pop->pop, popsize, 0, &dummy, TRUE, output, duplicates, &outputsize);

display_list(pop, output, duplicates, outputsize, popwidth, details);

delete[] duplicates;
delete[] output;
}//end display_all_best();
#endif //PARETO

//void write_fitness_summary()
//{
//
//};//end write_fitness_summary


//**************************************************************************
int do_gens (Pop* pop, int number, int tree, int& phase) //return if complete or not
{    
     pop->ClearCStats();
     cout << "Running, gpquick_seed " << gpquick_seed
          << " at " <<pop->gencount+1 << ". ";
     if ( tree >= 0 )
	  {  cout << "Crossover in ";
             ThisProblem->WriteTreeName(tree);
          }
     else
	     cout << "Random crossover tree\n";
//   cout << "gpquick_seed "<<gpquick_seed<<endl;//debug

     if(pop->params->params[pTournOff] != 0         && 
	pop->params->params[pTournSize] > 1 &&
	(pop->gencount+1)>=pop->params->params[pTournOff]) {
       cout<<"Setting pTournSize to 1\n";
       pop->params->params[pTournSize] = 1;
     };

     Chrome* last_chrome = pop->go_until(0,number,max_fitness,tree);

//     if((((pop->gencount+1)/ThisParams->params[pPopSize]) <= 1)   ||
//	(((pop->gencount+1)/ThisParams->params[pPopSize])%5 == 0))   {
     // Display the best so far
     cout << "\n\nAfter " << pop->gencount+1 << " ";
#ifdef PARETO
     if(ThisParams->params[pTrace] & pTracePareto )
	     display_all_best(pop, ThisParams->params[pPopSize],
			      ThisParams->params[pPopWidth], TRUE);
     display_best_stats(pop, ThisParams->params[pPopSize]);
#else
     cout << " generates, BestFitness = ";
     cout << pop->BestFitness->fvalue << " ";

#ifdef TRACE
     cout << pop->BestMember;
     pop->pop[pop->BestMember]->write_trace();
     pop->pop[pop->BestMember]->write(PRETTY_NONE,cout);
     cout << endl;
#endif
#endif //PARETO
     pop->DisplayStats();
     if ( ThisParams->params[pTrace] & pTraceDStats ) pop->DisplayDStats();
     if ( ThisParams->params[pTrace] & pTracePStats ) pop->DisplayPStats();
     else                                             pop->DisplayLPStats();
     if ( ThisParams->params[pTrace] & pTraceDupStats)pop->DisplayDupStats();


//     display_run(pop->best()); //show what it does
//     test_all_adf1(pop, 1);
//     }
#ifdef PARETO
     cout<<"select_hits callss ";select_hits_write_stats(); cout<<endl;
#endif
     cout<<"crossovers ";pop->DisplayCStats();

     phase = end_gens(); //problem specific

#ifdef GRID_LIB
     display_schedule_counts(cout);
#endif

     return (last_chrome->nfitness->fvalue >=max_fitness);

}//end do_gens()
///////////////////////////////  MAIN

int main(int argc, char * argv[])
{
	time_t start, end;

	ThisProblem=new gp();
	output_header(cout);

	assert ( NUM_TREES >= NUM_OPERATIONS );

	time (&start);
	memcpy(&last_save_time,&start,sizeof(start));

	ifstream gpParams ("gp.ini");
	if ( gpParams )
	     { ThisParams->Load(gpParams);
	       gpParams.close();
             }
	else {
		cerr << "Could not open gp.ini\n";
		exit(0);
	     }

	ifstream gpTests ("gp.test");
	if ( gpTests )
	     { ThisTest = new test(ThisProblem, gpTests);
	       gpTests.close();
//	       ThisTest->write(ThisProblem,cout);//debug
             }
	else {
		cerr << "Could not open gp.test"<<endl;
		exit(0);
	     }

	for(int i=0; i<argc;i++) {
		ThisParams->Load(argv[i]); }

	int initial_gencount = load_dumpfile(argc, argv); //if possible
		
	ThisTest->test_seed = ThisParams->params[pTestSeed];
	if ( ThisParams->params[pPopSeed] > 0 )
		gpquick_seed = ThisParams->params[pPopSeed];  //dirty I know
	else
	      { rndomize(); //use random seed
		ThisParams->params[pPopSeed] = gpquick_seed; //record seed used
	      }

	max_fitness = setmaxfit(ThisParams);

	ifstream gpLoad ("gp.load");
	if ( gpLoad )
	     { cout << "Loading chromes from gp.load\n";
	       if(ThisParams->params[pSeeds]==0) {
	       ThisParams->params[pPopSize]=1;
	       ThisParams->params[pGenerateLimit]=1;
             }}
	else if(ThisParams->params[pSeeds]!=0)
		cout << "Failed to open gp.load\n";

	int pop_size = ThisParams->params[pPopSize];
	int gen_max  = ThisParams->params[pGenerateLimit];

	if( initial_gencount<0 ) {
	cout << "Creating new population of " << pop_size<< " individuals\n";
	if(gpLoad && ThisParams->params[pSeeds]!=0)
		ThisPop = new Pop(ThisProblem,ThisParams,pop_size,&gpLoad);
	else
	ThisPop = new Pop(ThisProblem,ThisParams,pop_size);
	cout << "new Pop -- completed\n";
        }
	else
		ThisPop->gencount = initial_gencount - (pop_size-1);

	write_problem_params();
	ThisParams->Save();

	int done;
	if ( gpLoad && ThisParams->params[pSeeds]==0 )
	     { cout << "Overwritting with file gp.load\n";
	       //prevent trying to maintain list of best members of population
	       ThisParams->params[pElitist] = 0;

	       current_phase = ThisTest->num_phases-1; //display all tests

	       int rval = ThisPop->pop[0]->Load(gpLoad, TRUE);
	       if (rval != 0)
		       cout<<"Load error - "<<rval<<endl;
	       else
		   {   ThisTest->test_seed = ThisParams->params[pTestSeed];
		       ThisPop->pop[0]->SetupEval();
		       ThisProblem->fitness(ThisPop->pop[0]);
		       ThisPop->pop[0]->write_trace();
		       ThisPop->pop[0]->write(PRETTY_NONE,cout);
#ifdef ADF_CACHE
		       cache_stats_init();
#endif
		       display_run (ThisPop->pop[0]);
#ifdef ADF
//		       test_all_adf1(ThisPop, 0);
#endif
	           }
	       gpLoad.close();
	       done = TRUE;
        }
else
{
	int phase;
	cout << "Setting each fitness value\n";
	done = do_gens (ThisPop, pop_size-1, -1, phase); //no xover on init pop

	cout << "Initial fitness values calculated,\n";
	if ( initial_gencount >= 0 ) {
//		ThisPop->gencount = initial_gencount;

		//It is important that gpquick_seed is restored to correct
		//value. This step is only required because generate()
		//unneccessarily calls rnd()
		gpquick_seed = ThisParams->params[pPopSeed];
	}

	cout << "Creating a total of " << gen_max << " individuals\n";

	const int generates_per_report = pop_size *
	  ((ThisParams->params[pTrace] & 
	    (pTraceDStats|pTracePStats|pTraceDupStats))? 
	   1 : ((gen_max+(50*pop_size)-1)/(50*pop_size)));
	if( ((ThisPop->gencount+1) % generates_per_report!=0) &&
	    ((ThisPop->gencount+1) < gen_max) && !done && !kbhit() )  
	{
		done = do_gens (ThisPop, generates_per_report-pop_size, -1,
				phase);
#ifdef PARETO
		if(ThisParams->params[pElitist] == 0)
			display_all_best(ThisPop,ThisParams->params[pPopSize], 
					 ThisParams->params[pPopWidth], TRUE);
		else
			display_elite(   ThisPop,ThisParams->params[pPopSize], 
				         ThisParams->params[pPopWidth]);
#endif
	}//endif catchup to even boundary on generates
	                         // kbhit IS NOT PORTABLE (Borland specific)
	while ( (ThisPop->gencount+1) < gen_max && !done && !kbhit() )  
	{
		done = do_gens (ThisPop, generates_per_report, -1, phase);
		save_state(phase);
#ifdef PARETO
		if(ThisParams->params[pElitist] == 0)
			display_all_best(ThisPop,ThisParams->params[pPopSize], 
					 ThisParams->params[pPopWidth], TRUE);
		else
			display_elite(   ThisPop,ThisParams->params[pPopSize], 
				         ThisParams->params[pPopWidth]);
#endif
	}
	save_state(9);


//	// Display the best
	cout << "\n\nFINAL RESULTS. After " << ThisPop->gencount+1 << " ";
#ifdef PARETO
	if(ThisParams->params[pElitist] == 0)
		display_all_best(ThisPop, ThisParams->params[pPopSize], 
				 ThisParams->params[pPopWidth], TRUE);
	else
		display_elite(   ThisPop, ThisParams->params[pPopSize], 
				 ThisParams->params[pPopWidth]);
#else
	cout << " generates, BestFitness = ";
	cout << ThisPop->BestFitness->fvalue<<endl;
#endif //PARETO

	// Display the final population
	if ( ThisParams->params[pTrace] & pTraceStatic )
	  {  cout << "\n\nFINAL Population";
	     ThisPop->Write();
          }

//	display_run(ThisPop->best()); //show what it does

}//if not loading from file

	ThisProblem->write_stats();
	ThisTest->write_stats();

	time (&end);
	cout << "\nGP took " << end - start << " secs. Finished at ";
	cout << ctime(&end);
//	cout << clock() << " ticks cpu";
	cout << endl;

        //prevent trying to maintain list of best members of population
        ThisParams->params[pElitist] = 0;

	delete ThisPop;
	delete ThisProblem;
	delete ThisParams;	
        return done? 1 : 0;
}