memetic_weierstrass.ez 4.92 KB
Newer Older
kruger's avatar
kruger committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/*_________________________________________________________

Test functions
log normal adaptive mutation
Selection operator: Tournament
__________________________________________________________*/

\User declarations :
#define SIZE 100
#define X_MIN -1.
#define X_MAX 1.
#define ITER 120      
#define Abs(x) ((x) < 0 ? -(x) : (x))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define MIN(x,y) ((x)<(y)?(x):(y))
#define SIGMA  1.                     /*  mutation parameter */
#define PI 3.141592654

 
float pMutPerGene=0.1;


\end

\User functions:
//fitness function
#include <math.h>

__device__ __host__ inline float Weierstrass(float x[SIZE], int n)  // Weierstrass multimidmensionnel h = 0.25
{
   float res = 0.;
   float val[SIZE];
   float b=2.;
   float h = 0.25;

   for (int i = 0;i<n; i++) {
	val[i] = 0.;
    	for (int k=0;k<ITER;k++)
		val[i] += pow(b,-(float)k*h) * sin(pow(b,(float)k)*x[i]);
	res += Abs(val[i]);
	}
   return (res);
} 

float gauss()
/* Generates a normally distributed random value with variance 1 and 0 mean.
    Algorithm based on "gasdev" from Numerical recipes' pg. 203. */
{
  int iset = 0;
  float gset = 0.0;
  float v1 = 0.0, v2 = 0.0, r = 0.0;
  float factor = 0.0;

  if (iset) {
        iset = 0;
        return gset;
      	}
  else {    
        do {
            v1 = (float)random(0.,1.) * 2.0 - 1.0;
            v2 = (float)random(0.,1.) * 2.0 - 1.0;
            r = v1 * v1 + v2 * v2;
	                }
        while (r > 1.0);
        factor = sqrt (-2.0 * log (r) / r);
        gset = v1 * factor;
        iset = 1;
        return (v2 * factor);
    	}
}
\end



\Before everything else function:
  //cout<<"Before everything else function called "<<endl;
\end

\After everything else function:
  //cout << "After everything else function called" << endl;
\end

\At the beginning of each generation function:
  //cout << "At the beginning of each generation function called" << endl;
\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 x[SIZE];
  float sigma[SIZE]; // auto-adaptative mutation parameter
}
\end

\GenomeClass::display:
/* 	 for( size_t i=0 ; i<SIZE ; i++){ */
/* 	      //     cout << Genome.x[i] << ":" << Genome.sigma[i] << "|"; */
/* 	      printf("%.02f:%.02f|",Genome.x[i],Genome.sigma[i]); */
/* 	 }	       */
\end

\GenomeClass::initialiser : // "initializer" is also accepted
  for(int i=0; i<SIZE; i++ ) {
     	Genome.x[i] = (float)random(X_MIN,X_MAX);
	Genome.sigma[i]=(float)random(0.,0.5);
	}
\end

\GenomeClass::crossover :
  for (int i=0; i<SIZE; i++)
  {
    float alpha = (float)random(0.,1.); // barycentric crossover
     child.x[i] = alpha*parent1.x[i] + (1.-alpha)*parent2.x[i];
  }
\end

\GenomeClass::mutator : // Must return the number of mutations
  int NbMut=0;
  float pond = 1./sqrt((float)SIZE);

    for (int i=0; i<SIZE; i++)
    if (tossCoin(pMutPerGene)){
    	NbMut++;
       	Genome.sigma[i] = Genome.sigma[i] * exp(SIGMA*pond*(float)gauss());
       	Genome.sigma[i] = MIN(0.5,Genome.sigma[0]);              
       	Genome.sigma[i] = MAX(0.,Genome.sigma[0]);
       	Genome.x[i] += Genome.sigma[i]*(float)gauss();
       	Genome.x[i] = MIN(X_MAX,Genome.x[i]);              // pour eviter les depassements
       	Genome.x[i] = MAX(X_MIN,Genome.x[i]);
    	}
return NbMut;
\end

\GenomeClass::evaluator : // Returns the score
  float Score= 0.0;
  Score= Weierstrass(Genome.x, SIZE);         
  return Score;
\end

\GenomeClass::optimiser : // Optimises the Genome
149
  /*for(int i=0; i<SIZE; i++){
kruger's avatar
kruger committed
150
151
	if(random(0.,1.)<0.2)
		Genome.x[i]+=0.1;	
152
153
154
  }*/
  float pas = .01;
  Genome.x[currentIteration%SIZE]+=pas;
kruger's avatar
kruger committed
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
\end

\User Makefile options: 
CPPFLAGS+=
\end

\Default run parameters :        // Please let the parameters appear in this order
  Number of generations : 100     	// NB_GEN
  Time limit: 0 			// In seconds, 0 to deactivate
  Population size : 10			//POP_SIZE
  Offspring size : 10 // 40% 
  Mutation probability : 1       // MUT_PROB
  Crossover probability : 1      // XOVER_PROB
  Evaluator goal : minimise      // Maximise
  Selection operator: Tournament 2.0
  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: Strong			//Weak or Strong
  Elite: 1

  Number of optimisation iterations : 100 //Number of optimisation iteration
  Baldwinism : true //True or False (Lamarckism : keep optimised Genome

  Print stats:1				//Default: 1
  Generate csv stats file:0			
  Generate gnuplot script:0
  Generate R script:0
  Plot stats:0				//Default: 0
\end