Différences entre les versions de « Environmental modeling and software paper supplementary material »
Ligne 198 : | Ligne 198 : | ||
size of prog buffer : 200000000 | size of prog buffer : 200000000 | ||
+ | \end | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | ||
+ | |||
+ | /*_________________________________________________________ | ||
+ | GA implementation | ||
+ | __________________________________________________________*/ | ||
+ | |||
+ | \User declarations : | ||
+ | #define PI 3.141592654 | ||
+ | #define NB_SIN 1 | ||
+ | #define NB_SAMPLES 18 | ||
+ | |||
+ | |||
+ | |||
+ | #define MIN_A -2.0 | ||
+ | #define MAX_A 5.0 | ||
+ | #define MIN_B -2.0 | ||
+ | #define MAX_B 2.0 | ||
+ | #define MIN_C 0.1 | ||
+ | #define MAX_C 5.0 | ||
+ | #define MIN_D 0.1 | ||
+ | #define MAX_D 2.0 | ||
+ | |||
+ | int nSample[NB_SAMPLES][2]; // what is read from the file | ||
+ | float sample[NB_SAMPLES][2]; // straightened samples | ||
+ | float usedSample[NB_SAMPLES][2]; // samples that are used | ||
+ | int xSample[NB_SAMPLES]; | ||
+ | |||
+ | |||
+ | __device__ float gpuSample[NB_SAMPLES][2]; | ||
+ | \end | ||
+ | |||
+ | \User functions: | ||
+ | __device__ __host__ inline float fScoreOnGPU(float genome[NB_SIN*4], int nNbSamples, int nNbSin){ | ||
+ | |||
+ | float y,fScore=0.0; | ||
+ | #ifndef __CUDA_ARCH__ | ||
+ | for (int i=0;i<nNbSamples;i++){ | ||
+ | y=0; | ||
+ | for(int j=0;j<nNbSin;j++) | ||
+ | y+=genome[4*j+0]+usedSample[i][0]*genome[4*j+1]+genome[4*j+2]*sin(usedSample[i][0]*usedSample[i][0]*genome[4*j+3]); | ||
+ | fScore+=pow((usedSample[i][1]-y),2); // square of the difference | ||
+ | } | ||
+ | #else | ||
+ | for (int i=0;i<nNbSamples;i++){ | ||
+ | y=0; | ||
+ | for(int j=0;j<nNbSin;j++) | ||
+ | y+=genome[4*j+0]+gpuSample[i][0]*genome[4*j+1]+genome[4*j+2]*sin(gpuSample[i][0]*gpuSample[i][0]*genome[4*j+3]); | ||
+ | fScore+=pow((gpuSample[i][1]-y),2); // square of the difference | ||
+ | } | ||
+ | |||
+ | #endif | ||
+ | fScore/=(float)nNbSamples; // divided by the number of samples | ||
+ | fScore=powf(fScore,.5); // of which I take the cubic root for a more "powerful" MSE | ||
+ | return fScore*100; // for a better looking curve | ||
+ | |||
+ | } | ||
+ | |||
+ | \end | ||
+ | |||
+ | \User CUDA: | ||
+ | cudaMemcpyToSymbol(gpuSample, usedSample, NB_SAMPLES*2*sizeof(int)); | ||
+ | \end | ||
+ | |||
+ | \Before everything else function: | ||
+ | |||
+ | sample[0][0]=0.0833; | ||
+ | sample[1][0]=0.1667; | ||
+ | sample[2][0]=0.25; | ||
+ | sample[3][0]=0.3333; | ||
+ | sample[4][0]=0.4167; | ||
+ | sample[5][0]=0.5; | ||
+ | sample[6][0]=0.5833; | ||
+ | sample[7][0]=0.6667; | ||
+ | sample[8][0]=0.75; | ||
+ | sample[9][0]=0.8333; | ||
+ | sample[10][0]=0.9167; | ||
+ | sample[11][0]=1; | ||
+ | sample[12][0]=1.0833; | ||
+ | sample[13][0]=1.1667; | ||
+ | sample[14][0]=1.25; | ||
+ | sample[15][0]=1.3333; | ||
+ | sample[16][0]=1.4167; | ||
+ | sample[17][0]=1.5; | ||
+ | |||
+ | |||
+ | sample[0][1]=-0.12; | ||
+ | sample[1][1]=0; | ||
+ | sample[2][1]=0.22; | ||
+ | sample[3][1]=0.48; | ||
+ | sample[4][1]=0.64; | ||
+ | sample[5][1]=0.82; | ||
+ | sample[6][1]=0.88; | ||
+ | sample[7][1]=0.94; | ||
+ | sample[8][1]=1.16; | ||
+ | sample[9][1]=1.4; | ||
+ | sample[10][1]=1.68; | ||
+ | sample[11][1]=1.86; | ||
+ | sample[12][1]=1.8; | ||
+ | sample[13][1]=1.56; | ||
+ | sample[14][1]=1.22; | ||
+ | sample[15][1]=0.92; | ||
+ | sample[16][1]=0.6; | ||
+ | sample[17][1]=0.34; | ||
+ | |||
+ | |||
+ | |||
+ | for (int i=0;i<NB_SAMPLES;i++){ | ||
+ | // int nIndex=random(X_MIN,X_MAX); // for random sampling | ||
+ | int nIndex=i; // for exact sampling starting at X_MIN | ||
+ | usedSample[i][0]=sample[nIndex][0]; | ||
+ | usedSample[i][1]=sample[nIndex][1]; | ||
+ | } | ||
+ | |||
+ | |||
+ | // cudaMalloc((void**)&gpuSample,NB_SAMPLES*2*sizeof(int)); | ||
+ | \end | ||
+ | |||
+ | \After everything else function: | ||
+ | float gen[NB_SIN*6]; | ||
+ | printf("\n\nAfter Everything Else: NB_SIN = %d, nNB_SIN = %d\n",NB_SIN,NB_SIN); | ||
+ | for (int i=0;i<NB_SIN*6;i++) gen[i]=bBest->Sin[i]; | ||
+ | |||
+ | |||
+ | printf("Obtained functions : \ny="); | ||
+ | int i=0; | ||
+ | for (i=0;i<NB_SIN-1;i++) | ||
+ | printf("%f+%f*x+%f*sin(%f*x*x)+",bBest->Sin[i*4+0],bBest->Sin[i*4+1],bBest->Sin[i*4+2],bBest->Sin[i*4+3]); | ||
+ | printf("%f+%f*x+%f*sin(%f*x*x)\n\n",bBest->Sin[i*4+0],bBest->Sin[i*4+1],bBest->Sin[i*4+2],bBest->Sin[i*4+3]); | ||
+ | |||
+ | printf("Fitness=%f\n",bBest->fitness); | ||
+ | |||
+ | printf("%d sines on %d NUS\n",NB_SIN,NB_SAMPLES); | ||
+ | printf("Amplitude Angular_velocity Phase\n"); | ||
+ | for (int i=0;i<NB_SIN;i++) printf("%.9f\t%.9f\t%.9f\t%.9f\n",gen[i*4+0],gen[i*4+1],gen[i*4+2],gen[i*4+3]); | ||
+ | |||
+ | \end | ||
+ | |||
+ | \At the beginning of each generation function: | ||
+ | \end | ||
+ | |||
+ | \At the end of each generation function: | ||
+ | //cout << "At the end of each generation function called" << endl; | ||
+ | \end | ||
+ | |||
+ | \At each generation before reduce function: | ||
+ | //cout << "At each generation before replacement function called" << endl; | ||
+ | \end | ||
+ | |||
+ | \User classes : | ||
+ | GenomeClass { | ||
+ | float Sin[NB_SIN*4]; | ||
+ | |||
+ | |||
+ | } | ||
+ | \end | ||
+ | |||
+ | \GenomeClass::display: | ||
+ | \end | ||
+ | |||
+ | \GenomeClass::initialiser : // "initializer" is also accepted | ||
+ | for(int i=0; i<NB_SIN; i++){ | ||
+ | Genome.Sin[i*4+0]=-0.5298154; | ||
+ | // Genome.Sin[i*4+0]=random(MIN_A, MAX_A); | ||
+ | // Genome.Sin[i*4+1]= 0.7270191; | ||
+ | Genome.Sin[i*4+1]=random(MIN_B, MAX_B); | ||
+ | // Genome.Sin[i*4+2]=1.0; | ||
+ | Genome.Sin[i*4+2]=random(MIN_C, MAX_C); | ||
+ | //Genome.Sin[i*4+3]=1.71968; | ||
+ | Genome.Sin[i*4+3]=random(MIN_D, MAX_D); | ||
+ | } | ||
+ | \end | ||
+ | |||
+ | \GenomeClass::crossover : | ||
+ | int nLocus=random(0,NB_SIN); | ||
+ | for (int i=nLocus;i<NB_SIN;i++){ | ||
+ | child.Sin[i*4+0]=parent2.Sin[i*4+0]; | ||
+ | child.Sin[i*4+1]=parent2.Sin[i*4+1]; | ||
+ | child.Sin[i*4+2]=parent2.Sin[i*4+2]; | ||
+ | child.Sin[i*4+3]=parent2.Sin[i*4+3]; | ||
+ | } | ||
+ | \end | ||
+ | |||
+ | \GenomeClass::mutator: // Must return the number of mutations | ||
+ | float ampTemp, freqTemp, phaseTemp, DTemp; | ||
+ | for (int i=0;i<NB_SIN;i++) | ||
+ | if (tossCoin(2/((float)NB_SIN))){ | ||
+ | if (tossCoin(.6)) Genome.Sin[i*4+0]+=0.01-random(0.0,0.02); | ||
+ | if (tossCoin(.6)) Genome.Sin[i*4+1]+=0.01-random(0.0,0.02); | ||
+ | if (tossCoin(.6)) Genome.Sin[i*4+2]+=0.01-random(0.0,0.02); | ||
+ | if (tossCoin(.6)) Genome.Sin[i*4+3]+=0.001-random(0.0,0.002); | ||
+ | |||
+ | } | ||
+ | // Here, we "sort" the sines by frequency. This is the first loop only of a | ||
+ | // bubble sort. The subsequent loops will be done through the multiple generations | ||
+ | /* | ||
+ | for (int i=0;i<NB_SIN-1;i++){ | ||
+ | if (Genome.Sin[i*4+1]>Genome.Sin[(i+1)*4+1]){ | ||
+ | ampTemp=Genome.Sin[i*4+0];freqTemp=Genome.Sin[i*4+1];phaseTemp=Genome.Sin[i*4+2];DTemp=Genome.Sin[i*4+3]; | ||
+ | Genome.Sin[i*4+0]=Genome.Sin[(i+1)*4+0]; Genome.Sin[i*4+1]=Genome.Sin[(i+1)*4+1]; Genome.Sin[i*4+2]=Genome.Sin[(i+1)*4+2];Genome.Sin[i*4+3]=Genome.Sin[(i+1)*4+3]; | ||
+ | Genome.Sin[(i+1)*4+0]=ampTemp; Genome.Sin[(i+1)*4+1]=freqTemp; Genome.Sin[(i+1)*4+2]=phaseTemp; Genome.Sin[(i+1)*4+3]=DTemp; | ||
+ | } | ||
+ | } | ||
+ | */ | ||
+ | //return ;//1.1; | ||
+ | \end | ||
+ | |||
+ | \GenomeClass::evaluator: // Returns the score | ||
+ | return (double) fScoreOnGPU(Genome.Sin,NB_SAMPLES,NB_SIN); | ||
+ | \end | ||
+ | |||
+ | \User Makefile options: | ||
+ | \end | ||
+ | |||
+ | \Default run parameters : // Please let the parameters appear in this order | ||
+ | Number of generations : 1000 // NB_GEN | ||
+ | Time limit: 0 // In seconds, 0 to deactivate | ||
+ | Population size : 50000 | ||
+ | Offspring size : 100% | ||
+ | Mutation probability : 0.2 // MUT_PROB | ||
+ | Crossover probability : 1 // XOVER_PROB | ||
+ | Evaluator goal : minimise // Maximise | ||
+ | Selection operator: Tournament 10 | ||
+ | Surviving parents: 100% //percentage or absolute | ||
+ | Surviving offspring: 100% | ||
+ | Reduce parents operator: Tournament 2 | ||
+ | Reduce offspring operator: Tournament 2 | ||
+ | Final reduce operator: Tournament 2 | ||
+ | |||
+ | Elitism: Weak //Weak or Strong | ||
+ | Elite: 1 | ||
+ | Print stats: true //Default: 1 | ||
+ | Generate csv stats file:false | ||
+ | Generate gnuplot script:false | ||
+ | Generate R script:false | ||
+ | Plot stats:false //Default: 0 | ||
+ | |||
+ | Remote island model: false | ||
+ | IP file: ip.txt //File containing all the remote island's IP | ||
+ | Server port : 2929 | ||
+ | Migration probability: 0.1 // 0.15 or 0.5 | ||
+ | |||
+ | Save population: true | ||
+ | Start from file: false | ||
\end | \end |
Version du 3 février 2024 à 16:05
/*_________________________________________________________
This is a standard GP implementation on EASEA, aimed for regression.
For running on CPU, compile with: $ make easeaclean ; easena -gp regression.ez ; make
Then run with: $ ./regression --seed 2 // for a nice result :-)
You can test the parallel version on several cores with: $ ./regression --seed 2 --nbCPUThreads 20
For running on GPU, compile with: $ make easeaclean ; easena -cuda_gp regression.ez ; make
__________________________________________________________*/
\User declarations :
- include<stdio.h>
- include<string.h>
// these 3 defines are mandatory here. Adjust as you like.
- define NO_FITNESS_CASES 18
- define VAR_LEN 1 // number of input variables
- define GROW_FULL_RATIO 0.5 // cf. Koza's book on Genetic Programming
- define NUMTHREAD 1024 // nb of threads in parallel on GPU cards.
// 1024 is the maximum on Fermi architectures. It is 512 on older cards
- define MAX_STACK 15
- define PI (3.141592653589793)
float x[NO_FITNESS_CASES] = {0.0833, 0.1667, 0.25, 0.3333, 0.4167, 0.5, 0.5833, 0.6667, 0.75, 0.8333, 0.9167, 1, 1.0833, 1.1667, 1.25, 1.3333, 1.4167, 1.5};
float y[NO_FITNESS_CASES] = { -0.457142857, -0.428571429, -0.285714286, -0.042857143, 0.142857143, 0.328571429, 0.457142857, 0.571428571, 0.742857143, 0.914285714, 1.128571429, 1.271428571, 1.171428571, 0.985714286, 0.714285714, 0.442857143, 0.2, 0.057142857};
\end
\User functions:
int initData(float*** inputs, float** outputs) {
int i=0; (*inputs) = new float*[NO_FITNESS_CASES]; (*outputs) = new float[NO_FITNESS_CASES]; for( i=0 ; i<NO_FITNESS_CASES ; i++ ){ (*inputs)[i]=new float[VAR_LEN]; (*inputs)[i][0] = x[i]; (*outputs)[i] = y[i]; }
return NO_FITNESS_CASES;
}
void free_data(){
for( int i=0 ; i<NO_FITNESS_CASES ;i++ ) delete[] inputs[i] ; delete[] outputs; delete[] inputs;
}
\end
\Before everything else function:
initData(&inputs,&outputs); // inputs, outputs requis par EASEA
\end
\After everything else function:
std::cout << "y=" << toString(((IndividualImpl*)EA->population->Best)->root) << std::endl; free_data();
\end
\At the beginning of each generation function: \end
\At the end of each generation function: \end
\At each generation before reduce function: \end
\User classes :
GenomeClass {
GPNode* root; // GPNode is a reserved name that must be used for GP
} \end
\GenomeClass::display: \end
\GenomeClass::initialiser :
Genome.root = ramped_hh(); // Initializer, cf. Koza GP
\end
\GenomeClass::crossover :
simpleCrossOver(parent1,parent2,child); // cf. Koza GP child.valid = false; // to force the evaluation of the child
\end
\GenomeClass::mutator :
simple_mutator(&Genome); // cf. Koza GP
\end
\begin operator description : // <symbole>, "<affichage dans l'arbre>", <arité de l'opérateur>, {RESULT=<resultat>}
OP_X, "x", 0, {RESULT=INPUT[0];};
OP_ERC, "ERC", 0, {RESULT=ERC;}; // ERC = valeur aléatoire entre 0 et 1
OP_ADD, "+", 2, {RESULT=OP1+OP2;};
OP_SUB, "-", 2, {RESULT=OP1-OP2;};
OP_MUL, "*", 2, {RESULT=OP1*OP2;};
OP_SIN, "sin", 1, {RESULT=sin(OP1);};
// you can add other operators if you wish \end
\GenomeClass::evaluator header: \end
\GenomeClass::evaluator for each fc : // How to compute error for one point float expected_value = OUTPUT; error = pow((expected_value-EVOLVED_VALUE),2); error/=(float)NO_FITNESS_CASES; error=sqrtf(error); \end
\GenomeClass::evaluator accumulator : // here, error is the sum of errors for each point
return error; \end
\User Makefile options:
CXXFLAGS+=-I/usr/local/cuda/common/inc/ -I/usr/local/cuda/include/
LDFLAGS+=
\end
\Default run parameters :
Number of generations : 500 // NB_GEN Time limit: 0 // In seconds, 0 to deactivate Population size : 50000 // POP_SIZE Offspring size : 50000 // can be a percentage such as 40% Mutation probability : 0.1 // Probability to call the mutation function Crossover probability : 1 // Probability to call the crossover function Evaluator goal : minimise // or Maximise Selection operator: Tournament 10 // to select parents Surviving parents: 100% // to select breeders Surviving offspring: 100% // to select among offspring for next generation Reduce parents operator: Tournament 2 // how to select the breeders Reduce offspring operator: Tournament 2 // how to select the offspring that will compete to access the next generation Final reduce operator: Tournament 2 // to select the individuals composing the next generation
Elitism: Strong // Strong = from parents pop, Weak = from parents + children Elite: 1 Print stats: true Generate csv stats file:false Generate gnuplot script:false Generate R script:false Plot stats:true
Remote island model: false IP file: ip.txt //File containing all the remote island's IP Server port : 2929 Migration probability: 0.33
Save population: false Start from file: false
// nouveaux paramètres max init tree depth : 4 min init tree depth : 2 max tree depth : 6
size of prog buffer : 200000000
\end
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*_________________________________________________________ GA implementation __________________________________________________________*/
\User declarations :
- define PI 3.141592654
- define NB_SIN 1
- define NB_SAMPLES 18
- define MIN_A -2.0
- define MAX_A 5.0
- define MIN_B -2.0
- define MAX_B 2.0
- define MIN_C 0.1
- define MAX_C 5.0
- define MIN_D 0.1
- define MAX_D 2.0
int nSample[NB_SAMPLES][2]; // what is read from the file float sample[NB_SAMPLES][2]; // straightened samples float usedSample[NB_SAMPLES][2]; // samples that are used
int xSample[NB_SAMPLES];
__device__ float gpuSample[NB_SAMPLES][2];
\end
\User functions: __device__ __host__ inline float fScoreOnGPU(float genome[NB_SIN*4], int nNbSamples, int nNbSin){
float y,fScore=0.0;
- ifndef __CUDA_ARCH__
for (int i=0;i<nNbSamples;i++){ y=0; for(int j=0;j<nNbSin;j++) y+=genome[4*j+0]+usedSample[i][0]*genome[4*j+1]+genome[4*j+2]*sin(usedSample[i][0]*usedSample[i][0]*genome[4*j+3]); fScore+=pow((usedSample[i][1]-y),2); // square of the difference }
- else
for (int i=0;i<nNbSamples;i++){
y=0; for(int j=0;j<nNbSin;j++) y+=genome[4*j+0]+gpuSample[i][0]*genome[4*j+1]+genome[4*j+2]*sin(gpuSample[i][0]*gpuSample[i][0]*genome[4*j+3]); fScore+=pow((gpuSample[i][1]-y),2); // square of the difference }
- endif
fScore/=(float)nNbSamples; // divided by the number of samples fScore=powf(fScore,.5); // of which I take the cubic root for a more "powerful" MSE return fScore*100; // for a better looking curve
}
\end
\User CUDA: cudaMemcpyToSymbol(gpuSample, usedSample, NB_SAMPLES*2*sizeof(int)); \end
\Before everything else function:
sample[0][0]=0.0833; sample[1][0]=0.1667; sample[2][0]=0.25; sample[3][0]=0.3333; sample[4][0]=0.4167; sample[5][0]=0.5; sample[6][0]=0.5833; sample[7][0]=0.6667; sample[8][0]=0.75; sample[9][0]=0.8333; sample[10][0]=0.9167; sample[11][0]=1; sample[12][0]=1.0833; sample[13][0]=1.1667; sample[14][0]=1.25; sample[15][0]=1.3333; sample[16][0]=1.4167; sample[17][0]=1.5;
sample[0][1]=-0.12;
sample[1][1]=0;
sample[2][1]=0.22;
sample[3][1]=0.48;
sample[4][1]=0.64;
sample[5][1]=0.82;
sample[6][1]=0.88;
sample[7][1]=0.94;
sample[8][1]=1.16;
sample[9][1]=1.4;
sample[10][1]=1.68;
sample[11][1]=1.86;
sample[12][1]=1.8;
sample[13][1]=1.56;
sample[14][1]=1.22;
sample[15][1]=0.92;
sample[16][1]=0.6;
sample[17][1]=0.34;
for (int i=0;i<NB_SAMPLES;i++){ // int nIndex=random(X_MIN,X_MAX); // for random sampling int nIndex=i; // for exact sampling starting at X_MIN usedSample[i][0]=sample[nIndex][0]; usedSample[i][1]=sample[nIndex][1]; }
// cudaMalloc((void**)&gpuSample,NB_SAMPLES*2*sizeof(int));
\end
\After everything else function: float gen[NB_SIN*6]; printf("\n\nAfter Everything Else: NB_SIN = %d, nNB_SIN = %d\n",NB_SIN,NB_SIN); for (int i=0;i<NB_SIN*6;i++) gen[i]=bBest->Sin[i];
printf("Obtained functions : \ny=");
int i=0;
for (i=0;i<NB_SIN-1;i++)
printf("%f+%f*x+%f*sin(%f*x*x)+",bBest->Sin[i*4+0],bBest->Sin[i*4+1],bBest->Sin[i*4+2],bBest->Sin[i*4+3]);
printf("%f+%f*x+%f*sin(%f*x*x)\n\n",bBest->Sin[i*4+0],bBest->Sin[i*4+1],bBest->Sin[i*4+2],bBest->Sin[i*4+3]);
printf("Fitness=%f\n",bBest->fitness);
printf("%d sines on %d NUS\n",NB_SIN,NB_SAMPLES); printf("Amplitude Angular_velocity Phase\n"); for (int i=0;i<NB_SIN;i++) printf("%.9f\t%.9f\t%.9f\t%.9f\n",gen[i*4+0],gen[i*4+1],gen[i*4+2],gen[i*4+3]);
\end
\At the beginning of each generation function: \end
\At the end of each generation function:
//cout << "At the end of each generation function called" << endl;
\end
\At each generation before reduce function:
//cout << "At each generation before replacement function called" << endl;
\end
\User classes : GenomeClass {
float Sin[NB_SIN*4];
} \end
\GenomeClass::display: \end
\GenomeClass::initialiser : // "initializer" is also accepted for(int i=0; i<NB_SIN; i++){
Genome.Sin[i*4+0]=-0.5298154;
// Genome.Sin[i*4+0]=random(MIN_A, MAX_A);
// Genome.Sin[i*4+1]= 0.7270191;
Genome.Sin[i*4+1]=random(MIN_B, MAX_B); // Genome.Sin[i*4+2]=1.0;
Genome.Sin[i*4+2]=random(MIN_C, MAX_C);
//Genome.Sin[i*4+3]=1.71968; Genome.Sin[i*4+3]=random(MIN_D, MAX_D); } \end
\GenomeClass::crossover : int nLocus=random(0,NB_SIN); for (int i=nLocus;i<NB_SIN;i++){
child.Sin[i*4+0]=parent2.Sin[i*4+0]; child.Sin[i*4+1]=parent2.Sin[i*4+1]; child.Sin[i*4+2]=parent2.Sin[i*4+2]; child.Sin[i*4+3]=parent2.Sin[i*4+3];
} \end
\GenomeClass::mutator: // Must return the number of mutations float ampTemp, freqTemp, phaseTemp, DTemp; for (int i=0;i<NB_SIN;i++)
if (tossCoin(2/((float)NB_SIN))){ if (tossCoin(.6)) Genome.Sin[i*4+0]+=0.01-random(0.0,0.02); if (tossCoin(.6)) Genome.Sin[i*4+1]+=0.01-random(0.0,0.02); if (tossCoin(.6)) Genome.Sin[i*4+2]+=0.01-random(0.0,0.02); if (tossCoin(.6)) Genome.Sin[i*4+3]+=0.001-random(0.0,0.002); }
// Here, we "sort" the sines by frequency. This is the first loop only of a // bubble sort. The subsequent loops will be done through the multiple generations /* for (int i=0;i<NB_SIN-1;i++){
if (Genome.Sin[i*4+1]>Genome.Sin[(i+1)*4+1]){ ampTemp=Genome.Sin[i*4+0];freqTemp=Genome.Sin[i*4+1];phaseTemp=Genome.Sin[i*4+2];DTemp=Genome.Sin[i*4+3]; Genome.Sin[i*4+0]=Genome.Sin[(i+1)*4+0]; Genome.Sin[i*4+1]=Genome.Sin[(i+1)*4+1]; Genome.Sin[i*4+2]=Genome.Sin[(i+1)*4+2];Genome.Sin[i*4+3]=Genome.Sin[(i+1)*4+3]; Genome.Sin[(i+1)*4+0]=ampTemp; Genome.Sin[(i+1)*4+1]=freqTemp; Genome.Sin[(i+1)*4+2]=phaseTemp; Genome.Sin[(i+1)*4+3]=DTemp; }
}
- /
//return ;//1.1; \end
\GenomeClass::evaluator: // Returns the score
return (double) fScoreOnGPU(Genome.Sin,NB_SAMPLES,NB_SIN);
\end
\User Makefile options: \end
\Default run parameters : // Please let the parameters appear in this order
Number of generations : 1000 // NB_GEN Time limit: 0 // In seconds, 0 to deactivate Population size : 50000 Offspring size : 100% Mutation probability : 0.2 // MUT_PROB Crossover probability : 1 // XOVER_PROB Evaluator goal : minimise // Maximise Selection operator: Tournament 10 Surviving parents: 100% //percentage or absolute Surviving offspring: 100% Reduce parents operator: Tournament 2 Reduce offspring operator: Tournament 2 Final reduce operator: Tournament 2
Elitism: Weak //Weak or Strong Elite: 1 Print stats: true //Default: 1 Generate csv stats file:false Generate gnuplot script:false Generate R script:false Plot stats:false //Default: 0
Remote island model: false IP file: ip.txt //File containing all the remote island's IP Server port : 2929 Migration probability: 0.1 // 0.15 or 0.5
Save population: true Start from file: false
\end