EE459 I ntroduction to Artificial I ntelligence Genetic Algorithms Practical Issues: Representations

Simple Binary In the standard GA, a binary encoding is used to represent each variable being optimised  (x,y) requires two binary variables If we are working over a range that requires an exact number of binary bits, this is easy for example, maximising the function  (x) = x 2, with x being an integer over the range 0 to 31 0 to 31 requires 5 binary bits (because 2 5 = 32) = = 1 … = 31

More Complex Cases If required, we can add an offset as well e.g. x  [1 32] or x  [ ] still require only 5 bits x  [1 32]  x  [0 31] + 1 x  [ ]  x  [0 31] = = 146 … = 176 But what if the range is not an exact power of 2? e.g. in the biscuit example: x, y  [1,9] nine numbers to represent, so four bits are required

Clipping If the number to be represented varies from M to N, for example from 1 to 9 the first N-M (8) bit patterns represent M to N-1 (1 to 8) the rest represent N (9) 0000 = = = = 9 … … 0111 = = 9 Clipping has one bit pattern for each number apart from the last, which can cause problems the last number is more likely to occur than others

Scaling Scaling (partially) solves this problem for x in the range M to N, using L bits use x = INT(b * ((N-M) / (2 L - 1))) + M where b is the normal binary equivalent of the encoding e.g. for x  [1 9]; x = INT(b * (8/15)) = = = = = = = = = = = = = = = = 9

Fitness Penalty The last alternative is to just let the variable vary over the full range of the binary representation, but to set the fitness function to zero for all values outside the allowable range, e.g. Note: this does not work in all cases assumes ‘roulette’ selection with fitness > 0

Approximate Floating-Point If the exact precision of the figures is not too important, then just divide a binary range of the appropriate size into intervals for example, to maximise  (x) = x 2 to 3 decimal places, with x over the range to decimal places requires 1000 numbers nearest power of 2 is 1024 ( = 2 10 ) 10 bits required for decimal point + 5 bits required for range 15 bits gives a number between 0 and x = x b / 1024 gives x to approx. 3 d.p.s

Exact Floating-Point If an ‘exact’ floating-point precision is required, then probably a method similar to binary scaling is the best option For example to represent (exactly) the numbers 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 use the same coding scheme as shown for the scaling example previously, including using an ‘INT’ function to remove fractions, and then divide by ten Think carefully about the representation used remember that floating-points are not exact!

Gray Code With a standard binary representation, it is difficult for a GA to add (subtract) 1 from certain numbers e.g (63) to (64) requires seven changes to the bit pattern this can cause the binary GA to get ‘stuck’ One solution is to use a new coding scheme in which each successive number is represented by a bit pattern which is only one bit different from the previous number such coding schemes are call gray codes

Gray Code Example Binary 0000 = = = = = = = = = = = = = = = = 15 Gray 0000 = = = = = = = = = = = = = = = = 15 Gray code: flip the rightmost bit that generates a pattern that is different from all the previous ones

Generating Gray Code To generate a gray code from a binary code assume the binary code is N bits long bits are numbered 1 to N, where 1 is the leftmost bit gray(1)= binary(1); for i = 2:N gray(i)= binary(i-1) XOR binary(i); end binary(1)= gray(1); for i = 2:N binary(i)= binary(i-1) XOR gray(i); end A = [ ]; gray= (A * binary) MOD 2; binary= (INV(A) * gray) MOD 2; looping methodmatrix method (e.g. 8 bits)