3 Linkage identication. In each linkage. Intra GA Intra GA Intra GA. BB candidates. Inter GA;

Size: px

Start display at page:

Download "3 Linkage identication. In each linkage. Intra GA Intra GA Intra GA. BB candidates. Inter GA;"

Melissa Allison
5 years ago
Views:

1 Designing a Genetic Algorithm Using the Linkage Identication by Nonlinearity Check Masaharu Munetomo and David E. Goldberg IlliGAL Report No December 1998 Illinois Genetic Algorithms Laboratory University of Illinois at Urbana-Champaign 117 Transportation Building 104 S. Mathews Avenue Urbana, IL Oce: (217) Fax: (217)

2 Designing a Genetic Algorithm Using Linkage Identication by Nonlinearity Check Masaharu Munetomo and David E. Goldberg fmunetomo, degg@illigal.ge.uiuc.edu Illinois Genetic Algorithm Laboratory, Department of General Engineering, University of Illinois at Urbana-Champaign Abstract In this paper, we design a genetic algorithm based on the Linkage Identication by Nonlinearity Check (LINC) procedure proposed in a previous report (Munetomo & Goldberg, 1998). The resulting LINC-GA performs genetic algorithms inside the linkage groups obtained by the LINC procedure to nd candidates of building blocks and then mixes them to obtain optimal or suboptimal solutions. The procedure is demonstrated on two nonlinear functions: one that is easy for the GA and one that is not. 1 Introduction It is essential to ensure tight linkage for GAs to work eectively. If two loci in a building block (BB) are not tightly linked, they are easily disrupted by crossover operators. It is sometimes dicult to ensure tight linkage in advance because we need to have enough information on the problem for it to be solved. Instead of encoding strings to have tight linkage, recent development of genetic algorithms such as the gene expression messy-ga (GEMGA) (Kargupta, 1996b) and linkage learning GA (LLGA) (Harik, 1997) enables us to learn linkage information along the way of optimization by genetic operators. The GEMGA is based on the SEARCH (Search Envisioned As Relation and Class Hierarchizing) framework (Kargupta, 1995), which considers hierarchy structure of solution space that consists of classes which correspond to schemata for GAs and relations as their meta-class. The relation space is explicitly evaluated using the weights associated with each member (bitposition) (Kargupta, 1996b). If the tness value is improved by a perturbation at a bitposition, the amount of change by the perturbation is stored as its weight value. Otherwise, the weight becomes zero. The revised GEMGA (Kargupta, 1996a) also detects dependency among bitpositions and stores the result to linkage sets. This dependency check is performed only for the bitpositions which have positive weights (Kargupta, Goldberg, & Wang, 1997). Masaharu Munetomo is a visiting scholar from Information and Data Analysis, Graduate School of Engineering, Hokkaido University, Sapporo 060{8628 JAPAN. 1

3 On the other hand, the LLGA does not employ explicit representation of a linkage set. It employs circular representation of strings and a two point crossover-like genetic operator which tends to preserve tight linkage. Proper linkage groups implicitly increase their share in a population by the genetic operator under selection pressure. It works eectively on exponentially-scaled boundedly-deceptive problems (Harik, 1997). On uniformly scaled problems, however, it suers from identifying linkage and does not outperform simple GAs. This is because it performs identication of linkage and exploitation of building blocks at the same time. Therefore, there exists a negative feedback eect among equally-scaled BBs, which prevents tight linkage from growing in a population. In this paper, we take another approach which directly identies linkage just after the initialization and then performs a GA inside the linkage to nd candidates for building blocks to be mixed to have an optimal solution. Direct identication became possible by the Linkage Identication by Nonlinear Check (LINC) procedure proposed in a previous report (Munetomo & Goldberg, 1998). The procedure detects arbitrary nonlinearity among strings in a population and includes a pair of loci in a linkage set if nonlinear interaction is found between them. In the LINC-GA we propose, the optimization process after the linkage identication is divided into a local GA inside the linkage (called intra-ga) and a global GA among the linkage (called inter-ga). If the linkage identication is correct and we have enough population size, combining the best schemata (as BBs) is enough to obtain an optimal solution. In addition, the algorithm is expected to be less sensitive to an undersized population by performing intra-gas inside the linkage. If the problem inside the linkage is dicult enough, as in a deceptive problem, we still need to have O(2 k ) strings, where k is the length of the linkage, but if the problem is easy for GA, we do not need to have such a large population size because it is easy for the intra GA to nd an optimal solution inside the linkage which is to be a BB. 2 The LINC-GA Figure 1 illustrates the LINC-GA. It performs the LINC procedure to obtain linkage information and then divide the problem into quasi-linearly separable subproblems based on the linkage groups. In each subproblem, a local GA called intra GA is performed to obtain BB candidates inside the linkage. The inter GA mixes the candidates to generate optimal or quasi-optimal solutions. Figure 2 is the procedure of the LINC-GA. First, after initializing a population, the LINC procedure is applied on the population to identify linkage groups. Second, based on the linkage information obtained, strings in a population are divided into schemata in each of the linkage groups in which the intra GA is performed to nd candidates of BBs. Fitness values of the schemata are evaluated by employing a competitive template (Deb, 1991) that has the best tness value in a population. After nishing the intra GA, a limited number of schemata are selected as BB candidates. Finally, the inter GA mixes with the BB candidates. In the remainder of this paper, we present detailed descriptions of each procedure in the algorithm. First, we revisit the LINC procedure, and second, we explain the detail of the intra and the inter GA. 2

4 Linkage Identification In each linkage Intra GA Intra GA Intra GA BB candidates Inter GA Figure 1: Overview of the LINC-GA algorithm LINC-GA Initialize population; LINC; Intra GA; Select candidates of building blocks; Inter GA; Linkage identication Figure 2: The LINC-GA The linkage identication by nonlinearity check (LINC) procedure (Munetomo & Goldberg, 1998) identies linkage from a population of strings. The basic idea is simple: nonlinearity should exist inside a linkage in at least one string; otherwise, they need not be tightly linked because linearity is apparently easy for the GAs. Therefore, we can identify linkage by sampling strings and checking whether perturbations in each pair of loci cause nonlinear eects or not. Linear interactions may exist (and are often found) inside a linkage group in some context, so it is necessary to check nonlinearity in O(2 k ) strings (k is the maximum length of BBs) to have an accurate linkage set. The LINC simply checks in each pair of loci whether f 1 + f 2 = f 12 or not, where f 1 is the amount of change caused in tness value by a perturbation in one locus, f 2 is the change caused by a perturbation in another locus, and f 12 is the change caused by simultaneous perturbations in both loci. Strict equality criterion of nonlinearity, however, is apparently vulnerable to noise in tness evaluations. To relax the above criterion, we introduce a positive value as a threshold in checking nonlinearity. If jf 12?(f 1 +f 2 )j >, we consider the loci to have nonlinear interaction, and we store them to the linkage set. The Linkage Identication by Nonlinearity Check (LINC) procedure is shown in gure. The procedure checks strings in a population whether there exists a nonlinear interaction

5 between each pair of loci or not. If any nonlinear interaction is found between the pair, they are added to the linkage set. The computational cost of the algorithm is O(l 2 ) for each string and O(nl 2 ) = O(2 k l 2 ) for a population, where l is the string length. procedure Linkage Identification by Nonlinearity Check (LINC) for(i = 0; i < length; i++) initialize linkage_set[i]; for(k = 0; k < #_of_strings; k++) { for(i = 0; i < length; i++) { s' = Perturb(s, i); df1 = f(s') - f(s); for(j = i; j < length; j++) { if(i!= j) { s' = Perturb(s, j); df2 = f(s') - f(s); s'' = Perturb(s', i) df12 = f(s'') - f(s); if( df12 - (df1 + df2) > e) { /* nonlinearity detected between i and j */ adding j to the linkage_set[i]; adding i to the linkage_set[j]; n_linkage = 0; /* # of independent linkage sets */ for(i = 0; i < length; i++) { if(linkage_set[i]!= {) { linkage[n_linkage++] = linkage_set[i]; for(entry in linkage_set[i]) { linkage_set[entry] = {; Figure : The Linkage Identication by Nonlinearity Check (LINC) procedure In the algorithm, Perturb(s, i) performs a perturbation of string s in its locus i. For binary strings (s[i] = f0,1g), it performs s[i] 1 - s[i]. linkage set[i] stores a list of loci which are tightly linked to the position i. Since the LINC condition is symmetry for pairs of loci, if a locus i is in the linkage set[j], locus j must be in the linkage set[i]. The linkage[i] stores the loci which belong to the same linkage sets. We use this linkage[i] in the following procedure. In this paper, we employ the LINC procedure without an allowable nonlinearity condition, which was in the original version of the LINC procedure (Munetomo & Goldberg, 4

6 1998). The allowable nonlinearity is a GA-easy nonlinearity which satises monotonicity conditions in all contexts in a population. This is because we employ uniform crossover in the intra GA as detailed in the next section. By employing uniform crossover inside the linkage, subproblems with GA-easy allowable nonlinearity are apparently easily optimized by any GA. 4 Intra GA From linkage information obtained by the LINC procedure, we can nd candidates of BBs by performing a GA in each linkage. If a subproblem inside a linkage is dicult for GAs (such as a deceptive function), we need to have O(2 k ) strings where k is the length of the linkage, which means that we can only rely on an enumerative search provided by a population of strings. But if the subproblem inside the linkage is not GA-dicult, a GA can solve the subproblem with a smaller population size to nd a BB. The intra GA performs uniform crossover and simple mutation inside the linkage. After the GA, duplications of schemata are removed to have a set of unique schemata in each linkage group. This is because a GA may create identical strings which are both unnecessary and unfavorable in selecting candidates of BBs. Only O(log k) computational cost is necessary for this duplication check. procedure Intra GA for(i = 0; i < n_linkage; i++) { for(j = 0; j < n_strings; j++) { schema[i][j] = cut(s[j], linkage[i]); for(gen = 0; gen < gen_intra_max; gen++) { (p, q) = create_pairs; for each pair (p, q) { uniform_crossover(schema[i][p], schema[i][q]); inserting the offsprings in the population; for(k = 0; k < n_strings; k++) { simple_mutation(schema[i][k]); inserting the offspring in the population; Figure 4: Intra GA Figure 4 is the detail of the intra GA. First, a population is initialized by splitting schemata from strings based on the linkage set. The function cut(str, link) creates a schema by selecting a substring from a string (str) based to the linkage (link) and lling the remainder of the string by DON'T CARE symbols. The intra GA performs uniform 5

7 crossover and simple mutation inside the linkage group. After the genetic operators, the osprings are inserted in the population by performing a ranking selection. Their tness values are evaluated by lling in the DON'T CARE symbols using a competitive template (Deb, 1991), which is the best string in the original population. It should be safe to use templates in evaluating schema tness because each subproblem is linearly or quasi-linearly separable in its contribution to overall tness value. After the intra GA, a limited number of schemata are selected as BB candidates in each linkage. Figure 5 shows the detail of this selection procedure. procedure Select candidates of building blocks for(i = 0; i < n_linkage; i++) { k = 0; while(fitness(schema[i][k]) >= fitness(schema[0][k]) - e*length) { building_blocks[i][k] = schema[i][k]; k++; Figure 5: Select candidates of building blocks A schema with the best tness value is selected if = 0. This is because when there is no error in linkage identication, each subproblem in each linkage group becomes linearlyseparable, and combining the best schemata of the subproblems is enough to obtain the optimal solution. Otherwise, considering the error in linkage identication, we need to select a set of schemata that satisfy f > f? l (f is the tness for the best schema and l is the length of the string) as BB candidates. This condition is a conservative one because we assume the total error in evaluating the tness value of the schemata to be the sum of in all loci in the string, which should be the worst case. 5 Inter GA The inter GA mixes the BB candidates to nd an optimal solution. When there is no error in checking nonlinearity by the LINC with a large enough population size, combining the best schemata is enough to obtain an optimal solution. This is because the problem is linearly separable to the sum of independent subproblems. In actual applications, however, we do not usually set the value of at zero, because it becomes too sensitive to noise. When we set > 0, the LINC procedure may cause errors in selecting BB candidates. Therefore, it becomes necessary to mix and test for a set of BB candidates in each linkage obtained by the intra GA. Figure 6 shows the inter GA. First, a candidate for an optimal string is generated by combining the best schemata obtained in the intra GA. Second, the rest of the population is initialized by randomly picking up BB candidates in each linkage and combining them 6

8 to make a string. In each generation of the GA, a crossover operator based on linkage information is performed, which exchanges substrings that belong to the same linkage set. The LINC crossover ensures tight linkage among loci in the linkage set. After the crossover, the ospring is inserted in the population based on its tness value, which corresponds to a ranking selection. procedure Inter GA for(i = 0; i < n_linkage; i++) { for(entry in linkage[i]) { BB_string[0][entry] = building_blocks[0][entry]; /* best string */ for(i = 1; i < #_of_bb_strings; i++) { for(j = 0; j < h; j++) { k = random from 0 to # of building_blocks; for(entry in linkage[j]) { BB_string[i][entry] = building_blocks[k][entry]; for(gen = 0; gen < gen_inter_max; gen++) { (p, q) = random from 0 to n_linkage; for each pair (p, q) { for(i = 0; i < n_linkage; i++) { if(random[0,1) < p_cross_inter) { exchange substrings of BB_string[p] and BB_string[q] in bit positions of linkage[i]; inserting the offsprings to the population; Figure 6: Inter GA If the LINC procedure correctly identies the linkage information of the problem, we do not need to perform the inter GA repeatedly. In the best case, only one generation is needed to obtain an optimal string. This is because we can eectively divide the problem into quasi-linearly separable subproblems and the intra GA generates a small number of BB candidates to be mixed. The success of this algorithm depends upon the value of. If the value is set to be smaller, the LINC procedure may generate overspecied linkage sets because of its strict condition of nonlinear check. On the other hand, if we set a larger value, the LINC 7

9 procedure can easily separate the problem into smaller subproblems; however, it might be incorrect. We can restore the incorrectness of identifying linkage by mixing a set of BB candidates in the inter GA. 6 Empirical Results We perform experiments on two test functions. One is easy for GAs, and the other is dicult. The GA-easy function is the sum of 5-bit quadratic functions as in the following: f(s) = l=5 X i=1 x 2 i : (1) x i = s 5i + 2s 5i s 5i s 5i s 5i+4: (2) For this function, even a small population enables the algorithm to have optimal solutions. This is because the quadratic subfunctions are easy to solve by the intra GA with uniform crossover, which enables us to obtain appropriate BB candidates. We employ a population of 10 strings, perform intra GA for 10 generations, and perform inter GA for a single generation. The reason why we employ only a single generation in the inter GA is that the function has no error in its evaluations, and combining the best schemata should be enough to have an optimal solution. For crossover and mutation probabilities, we employ 0.5 for uniform crossover and 0.1 for simple mutations in the intra GA and 0.2 for linkagebased crossover in the inter GA. We set the value at zero in this experiment because the function does not produce any error in its evaluation. Figure 7 shows the number of function evaluations in dierent string lengths. The dotted line shows the number of overall tness evaluations. This gure indicates that the computational cost concerning tness evaluations is a little lower than O(l 2 ). This is because the order of the LINC procedure is O(l 2 ), which dominates the order of overall computational cost. We perform another experiment on a GA-dicult function, the sum of 5-bit deceptive functions dened by the following: f(s) = l=5 X i=1 f i (u i ): () f i (u i ) = ( 4? ui if 0 u i 4 5 if u i = 5 (4) where u i is the unitation (the number of one's) in the i-th 5-bit substring. To solve order-k trap functions, a population size of O(2 k ) is necessary for GAs because the problem is dicult for the algorithms that can be only relied upon an enumerative search by a population. In this experiment, we employ 70 strings in a population, which enables the algorithm to have more than 90% of BBs in its nal solutions. Other conditions are the same as those for the previous experiment. 8

10 O(l 2 ) Eval O(l) String length Figure 7: The number of function evaluations (Quadratic functions) Figure 8 shows the number of function evaluations in dierent lengths of strings. The dotted line is the number of tness evaluations in the experiment. This result shows that its computational cost is slightly lower than O(l 2 ), which also means that the LINC procedure occupies the majority of function evaluations. Once the linkage is identied by the LINC, it becomes easy to nd an optimal string by mixing BB candidates in each linkage. 7 Conclusion In this paper, we designed a genetic algorithm which performs linkage identication by the LINC and then performs Intra and Inter GAs based on the obtained linkage. The resulting LINC-GA is able to nd optimal solutions with a little less than O(l 2 ) tness evaluations empirically. This is because once correct linkage groups are identied, then we only need to nd BBs in each linkage and mix them to obtain optimal or near optimal solutions. A possible problem of the LINC-GA is its centralized manner of identifying linkage groups. Checking all the strings in a population leads to obtaining accurate linkage groups; however, its centralized nonlinear check might cause unnecessary computational cost in some problems with easier identiable linkage. We may reduce computational cost by performing the LINC procedure in each string to yield local linkage information to be distributed among neighbor strings. This distributed LINC procedure may also be suited for problems which have linkage locally in some contexts. We may also extend the LINC procedure to have a Meta-Level LINC procedure, which is applied to the selected schemata, and also the Meta-Level LINC-GA which climbs a ladder of hierarchy structure of BBs. 9

11 e e+06 O(l 2 ) 2e+06 Eval 1.5e+06 1e O(l) String length References Figure 8: The number of function evaluations (Trap functions) Deb, K. (1991). Binary and oating-point function optimization using messy genetic algorithms (IlliGAL Report No and doctoral dissertation, Unversity of Alabama, Tuscaloosa). Urbana: University of Illinois at Urbana-Champaign. Harik, G. R. (1997). Learning gene linkage to eciently solve problems of bounded diculty using genetic algorithms. Unpublished doctoral dissertation, University of Michigan, Ann Arbor. Also IlliGAL Report No Kargupta, H. (1995, October). SEARCH, polynomial complexity, and the fast messy genetic algorithm (Technical Report 95008). Urbana, IL: University of Illinois at Urbana- Champaign. Kargupta, H. (1996a). The gene expression messy genetic algorithm. Proceedings of 1996 IEEE International Conference on Evolutionary Computation, 814{819. Kargupta, H. (1996b). SEARCH, evolution, and the gene expression messy genetic algorithm (Unclassied Report LA-UR 96-60). Los Alamos, NM: Los Alamos National Laboratory. Kargupta, H., Goldberg, D. E., & Wang, L. (1997). Extending the class of order-k delineable problems for the gene expression messy genetic algorithm. In Koza, J. R., Deb, K., Dorigo, M., Fogel, D. B., Garzon, M., Iba, H., & Riolo, R. (Eds.), Genetic Programming 1997, Proceedings of the Second Annual Conference (pp. 64{69). San Francisco, CA: Morgan Kaufmann. Munetomo, M., & Goldberg, D. E. (1998). Identifying linkage by nonlinearity check (IlliGAL Report No ). Urbana, IL: University of Illinois at Urbana-Champaign. 10

gorithm and simple two-parent recombination operators soon showed to be insuciently powerful even for problems that are composed of simpler partial su

gorithm and simple two-parent recombination operators soon showed to be insuciently powerful even for problems that are composed of simpler partial su BOA: The Bayesian Optimization Algorithm Martin Pelikan, David E. Goldberg, and Erick Cantu-Paz Illinois Genetic Algorithms Laboratory Department of General Engineering University of Illinois at Urbana-Champaign