Download presentation

Presentation is loading. Please wait.

Published byLauren Martins Modified over 2 years ago

1
SA, GA and GSA in Fuzzy Systems Supervisor: Prof. Ho Cheng-Seen Presented by: Irfan Subakti 司馬伊凡 (M ) EE601-2 NTUST, February 9 th 2004 Supervisor: Prof. Ho Cheng-Seen Presented by: Irfan Subakti 司馬伊凡 (M ) EE601-2 NTUST, February 9 th 2004

2
Fields of Artificial Intelligent (AI)

3
Simulated Annealing (SA) SA is stochastic iterative improvement methods for solving combinatorial optimization problems. SA is stochastic iterative improvement methods for solving combinatorial optimization problems. SA generates a single sequence of solutions and searches for an optimum solution along this search path. SA generates a single sequence of solutions and searches for an optimum solution along this search path. SA starts with a given initial solution x 0. SA starts with a given initial solution x 0. At each step, SA generates a candidate solution x’ by changing a small fraction of a current solution x. At each step, SA generates a candidate solution x’ by changing a small fraction of a current solution x. SA accepts the candidate solution as a new solution with a probability min {1, e - f/T }, where f = f(x’) – f(x) is cost reduction from the current solution x to the candidate solution x’, and T is a control parameter called temperature. SA accepts the candidate solution as a new solution with a probability min {1, e - f/T }, where f = f(x’) – f(x) is cost reduction from the current solution x to the candidate solution x’, and T is a control parameter called temperature. A key point of SA is that SA accepts up-hill moves with the probability e - f/T. A key point of SA is that SA accepts up-hill moves with the probability e - f/T. This allows SA to escape from local minima. This allows SA to escape from local minima. But SA cannot cover a large region of the solution space within a limited computation time because SA is based on small moves. But SA cannot cover a large region of the solution space within a limited computation time because SA is based on small moves. SA is stochastic iterative improvement methods for solving combinatorial optimization problems. SA is stochastic iterative improvement methods for solving combinatorial optimization problems. SA generates a single sequence of solutions and searches for an optimum solution along this search path. SA generates a single sequence of solutions and searches for an optimum solution along this search path. SA starts with a given initial solution x 0. SA starts with a given initial solution x 0. At each step, SA generates a candidate solution x’ by changing a small fraction of a current solution x. At each step, SA generates a candidate solution x’ by changing a small fraction of a current solution x. SA accepts the candidate solution as a new solution with a probability min {1, e - f/T }, where f = f(x’) – f(x) is cost reduction from the current solution x to the candidate solution x’, and T is a control parameter called temperature. SA accepts the candidate solution as a new solution with a probability min {1, e - f/T }, where f = f(x’) – f(x) is cost reduction from the current solution x to the candidate solution x’, and T is a control parameter called temperature. A key point of SA is that SA accepts up-hill moves with the probability e - f/T. A key point of SA is that SA accepts up-hill moves with the probability e - f/T. This allows SA to escape from local minima. This allows SA to escape from local minima. But SA cannot cover a large region of the solution space within a limited computation time because SA is based on small moves. But SA cannot cover a large region of the solution space within a limited computation time because SA is based on small moves.

4
Simulated Annealing (SA) (continue) Pseudo-code of Simulated Annealing (SA) (Koakutsu et al. [20]) Pseudo-code of Simulated Annealing (SA) (Koakutsu et al. [20]) SA_algorithm(N a, T 0, ) { x x 0 ; /* initial solution */ T T 0 ; /* initial temperature */ while (system is not frozen) { for (loop = 1; loop N a ; loop++) { x’ Mutate(x); f f(x’) – f(x); r random number between 0 and 1 if ( f < 0 or r < exp(- f/T)) x x’; } T T * /* lower temperature */ } return x } Pseudo-code of Simulated Annealing (SA) (Koakutsu et al. [20]) Pseudo-code of Simulated Annealing (SA) (Koakutsu et al. [20]) SA_algorithm(N a, T 0, ) { x x 0 ; /* initial solution */ T T 0 ; /* initial temperature */ while (system is not frozen) { for (loop = 1; loop N a ; loop++) { x’ Mutate(x); f f(x’) – f(x); r random number between 0 and 1 if ( f < 0 or r < exp(- f/T)) x x’; } T T * /* lower temperature */ } return x }

5
Genetic Algorithms (GA) GA is another approach for solving combinatorial optimization problems. GA is another approach for solving combinatorial optimization problems. GA applies an evolutionary mechanism to optimization problems. GA applies an evolutionary mechanism to optimization problems. It starts with a population of initial solutions. It starts with a population of initial solutions. Each solution has a fitness value which is a measure of the quality of solutions. Each solution has a fitness value which is a measure of the quality of solutions. At each step, called a generation, GA produces a set of candidate solutions, called child solutions (offspring), using two types of genetic operators: mutation and crossover. At each step, called a generation, GA produces a set of candidate solutions, called child solutions (offspring), using two types of genetic operators: mutation and crossover. It selects good solutions as survivors to the next generation according to the fitness value. It selects good solutions as survivors to the next generation according to the fitness value. The mutation operator takes a single parent and modifies it randomly in a localized manner, so that it makes a small jump in the solution space. The mutation operator takes a single parent and modifies it randomly in a localized manner, so that it makes a small jump in the solution space. On the other hand, the crossover operator takes 2 solutions as parents and creates their child solutions by combining the partial solutions of the parents. On the other hand, the crossover operator takes 2 solutions as parents and creates their child solutions by combining the partial solutions of the parents. Crossover tends to create child solutions which differs from both parent solutions. Crossover tends to create child solutions which differs from both parent solutions. It results in a large jump in the solution space. It results in a large jump in the solution space. GA is another approach for solving combinatorial optimization problems. GA is another approach for solving combinatorial optimization problems. GA applies an evolutionary mechanism to optimization problems. GA applies an evolutionary mechanism to optimization problems. It starts with a population of initial solutions. It starts with a population of initial solutions. Each solution has a fitness value which is a measure of the quality of solutions. Each solution has a fitness value which is a measure of the quality of solutions. At each step, called a generation, GA produces a set of candidate solutions, called child solutions (offspring), using two types of genetic operators: mutation and crossover. At each step, called a generation, GA produces a set of candidate solutions, called child solutions (offspring), using two types of genetic operators: mutation and crossover. It selects good solutions as survivors to the next generation according to the fitness value. It selects good solutions as survivors to the next generation according to the fitness value. The mutation operator takes a single parent and modifies it randomly in a localized manner, so that it makes a small jump in the solution space. The mutation operator takes a single parent and modifies it randomly in a localized manner, so that it makes a small jump in the solution space. On the other hand, the crossover operator takes 2 solutions as parents and creates their child solutions by combining the partial solutions of the parents. On the other hand, the crossover operator takes 2 solutions as parents and creates their child solutions by combining the partial solutions of the parents. Crossover tends to create child solutions which differs from both parent solutions. Crossover tends to create child solutions which differs from both parent solutions. It results in a large jump in the solution space. It results in a large jump in the solution space.

6
Genetic Algorithms (GA) (continue) There are 2 key differences between GA and SA. There are 2 key differences between GA and SA. 1. GA maintains a population of solutions and uses them to search the solution space. 2. GA uses the crossover operator which causes a large jump in the solution space. Features 2 allows GA to globally search a large region of the solution space. But GA has no explicit ways to produce a sequence of small moves in the solution space. Features 2 allows GA to globally search a large region of the solution space. But GA has no explicit ways to produce a sequence of small moves in the solution space. Mutation creates a single small move one at a time instead of a sequence of small moves. Mutation creates a single small move one at a time instead of a sequence of small moves. As the result GA cannot search local region on the solution space exhaustively. As the result GA cannot search local region on the solution space exhaustively. There are 2 key differences between GA and SA. There are 2 key differences between GA and SA. 1. GA maintains a population of solutions and uses them to search the solution space. 2. GA uses the crossover operator which causes a large jump in the solution space. Features 2 allows GA to globally search a large region of the solution space. But GA has no explicit ways to produce a sequence of small moves in the solution space. Features 2 allows GA to globally search a large region of the solution space. But GA has no explicit ways to produce a sequence of small moves in the solution space. Mutation creates a single small move one at a time instead of a sequence of small moves. Mutation creates a single small move one at a time instead of a sequence of small moves. As the result GA cannot search local region on the solution space exhaustively. As the result GA cannot search local region on the solution space exhaustively.

7
Genetic Algorithms (GA) (continue)

8
Pseudo-code of Genetic Algorithms (GA) (Koakutsu et al. [20]) Pseudo-code of Genetic Algorithms (GA) (Koakutsu et al. [20]) GA_algorithm(L, R c, R m ) { X {x 1,..., x L }; /* initial population */ while (stop criterion is not met) { X’ ; X’ ; while (number of children created < L R c ) { while (number of children created < L R c ) { select two solution, x i,x j from X x’ Crossover(x i, x j ); X’ X’ + {x’}; } select L solutions from X X’ as a new population select L solutions from X X’ as a new population while (number of solutions mutated < L R m ) { while (number of solutions mutated < L R m ) { select one solution x k from X x k Mutate(x k ); }} return the best solution in X } Pseudo-code of Genetic Algorithms (GA) (Koakutsu et al. [20]) Pseudo-code of Genetic Algorithms (GA) (Koakutsu et al. [20]) GA_algorithm(L, R c, R m ) { X {x 1,..., x L }; /* initial population */ while (stop criterion is not met) { X’ ; X’ ; while (number of children created < L R c ) { while (number of children created < L R c ) { select two solution, x i,x j from X x’ Crossover(x i, x j ); X’ X’ + {x’}; } select L solutions from X X’ as a new population select L solutions from X X’ as a new population while (number of solutions mutated < L R m ) { while (number of solutions mutated < L R m ) { select one solution x k from X x k Mutate(x k ); }} return the best solution in X }

9
Genetic Simulated Annealing (GSA) In order to improve the performance of GA and SA, several hybrid algorithms have been proposed. In order to improve the performance of GA and SA, several hybrid algorithms have been proposed. Mutation used in GA tends to destroy some good features of solutions at the final stages of optimization process. Mutation used in GA tends to destroy some good features of solutions at the final stages of optimization process.SA-based While Sigrag and Weisser [10] proposed a thermodynamic genetic operator, which incorporates an annealing schedule to control the probability of applying the mutation, Adler [11] used a SA-based acceptance function to control the probability of accepting a new solution produced by the mutation. While Sigrag and Weisser [10] proposed a thermodynamic genetic operator, which incorporates an annealing schedule to control the probability of applying the mutation, Adler [11] used a SA-based acceptance function to control the probability of accepting a new solution produced by the mutation.GA-based More recent works on GA-oriented hybrids are the Simulated Annealing Genetic Algorithm (SAGA) method proposed by Brown et al. [12] and Annealing Genetic (AG) method proposed by Lin et al. [13]. More recent works on GA-oriented hybrids are the Simulated Annealing Genetic Algorithm (SAGA) method proposed by Brown et al. [12] and Annealing Genetic (AG) method proposed by Lin et al. [13]. Both methods divide each “generation” into 2 phases: GA phase and SA phase. Both methods divide each “generation” into 2 phases: GA phase and SA phase. GA generates a set of new solutions using the crossover operator and then SA further refines each solution in the population. GA generates a set of new solutions using the crossover operator and then SA further refines each solution in the population. While SAGA uses the same annealing schedule for each SA phase, AG tries to optimize different schedules for different SA phases. While SAGA uses the same annealing schedule for each SA phase, AG tries to optimize different schedules for different SA phases. In order to improve the performance of GA and SA, several hybrid algorithms have been proposed. In order to improve the performance of GA and SA, several hybrid algorithms have been proposed. Mutation used in GA tends to destroy some good features of solutions at the final stages of optimization process. Mutation used in GA tends to destroy some good features of solutions at the final stages of optimization process.SA-based While Sigrag and Weisser [10] proposed a thermodynamic genetic operator, which incorporates an annealing schedule to control the probability of applying the mutation, Adler [11] used a SA-based acceptance function to control the probability of accepting a new solution produced by the mutation. While Sigrag and Weisser [10] proposed a thermodynamic genetic operator, which incorporates an annealing schedule to control the probability of applying the mutation, Adler [11] used a SA-based acceptance function to control the probability of accepting a new solution produced by the mutation.GA-based More recent works on GA-oriented hybrids are the Simulated Annealing Genetic Algorithm (SAGA) method proposed by Brown et al. [12] and Annealing Genetic (AG) method proposed by Lin et al. [13]. More recent works on GA-oriented hybrids are the Simulated Annealing Genetic Algorithm (SAGA) method proposed by Brown et al. [12] and Annealing Genetic (AG) method proposed by Lin et al. [13]. Both methods divide each “generation” into 2 phases: GA phase and SA phase. Both methods divide each “generation” into 2 phases: GA phase and SA phase. GA generates a set of new solutions using the crossover operator and then SA further refines each solution in the population. GA generates a set of new solutions using the crossover operator and then SA further refines each solution in the population. While SAGA uses the same annealing schedule for each SA phase, AG tries to optimize different schedules for different SA phases. While SAGA uses the same annealing schedule for each SA phase, AG tries to optimize different schedules for different SA phases.

10
GSA (continue) The above GA-oriented hybrids methods try to incorporate the local stochastic hill climbing features of SA into GA. The above GA-oriented hybrids methods try to incorporate the local stochastic hill climbing features of SA into GA. Since they incorporate full SA into each generation and the number of generations is usually very large, GA-oriented hybrid methods are very time-consuming. Since they incorporate full SA into each generation and the number of generations is usually very large, GA-oriented hybrid methods are very time-consuming. SA-oriented hybrid approaches, attempts to adopt the global crossover operations of GA into SA. SA-oriented hybrid approaches, attempts to adopt the global crossover operations of GA into SA. Parallel Genetic Simulated Annealing (PGSA) [14, 15], is a parallel version of SA incorporating GA features. Parallel Genetic Simulated Annealing (PGSA) [14, 15], is a parallel version of SA incorporating GA features. During parallel SA-based search, crossover is used to generate new solutions in order to enlarge the search region of SA. During parallel SA-based search, crossover is used to generate new solutions in order to enlarge the search region of SA. GSA proposed by Koakutsu et al. [20]. GSA proposed by Koakutsu et al. [20]. While PGSA generates the seeds of SA local search in parallel, that is the order of applying each SA local search is independent, GSA generates the seeds of SA sequentially, that is the seeds of a SA local search depends of the best-so-far solutions of all previous SA local searches. While PGSA generates the seeds of SA local search in parallel, that is the order of applying each SA local search is independent, GSA generates the seeds of SA sequentially, that is the seeds of a SA local search depends of the best-so-far solutions of all previous SA local searches. This sequentially approach seems to generate better child solutions. This sequentially approach seems to generate better child solutions. In addition, compared to PGSA, GSA uses fewer crossover operations since it only uses crossover operations when the SA local search reaches a flat surface and it is time to jump in the solution space. In addition, compared to PGSA, GSA uses fewer crossover operations since it only uses crossover operations when the SA local search reaches a flat surface and it is time to jump in the solution space. The above GA-oriented hybrids methods try to incorporate the local stochastic hill climbing features of SA into GA. The above GA-oriented hybrids methods try to incorporate the local stochastic hill climbing features of SA into GA. Since they incorporate full SA into each generation and the number of generations is usually very large, GA-oriented hybrid methods are very time-consuming. Since they incorporate full SA into each generation and the number of generations is usually very large, GA-oriented hybrid methods are very time-consuming. SA-oriented hybrid approaches, attempts to adopt the global crossover operations of GA into SA. SA-oriented hybrid approaches, attempts to adopt the global crossover operations of GA into SA. Parallel Genetic Simulated Annealing (PGSA) [14, 15], is a parallel version of SA incorporating GA features. Parallel Genetic Simulated Annealing (PGSA) [14, 15], is a parallel version of SA incorporating GA features. During parallel SA-based search, crossover is used to generate new solutions in order to enlarge the search region of SA. During parallel SA-based search, crossover is used to generate new solutions in order to enlarge the search region of SA. GSA proposed by Koakutsu et al. [20]. GSA proposed by Koakutsu et al. [20]. While PGSA generates the seeds of SA local search in parallel, that is the order of applying each SA local search is independent, GSA generates the seeds of SA sequentially, that is the seeds of a SA local search depends of the best-so-far solutions of all previous SA local searches. While PGSA generates the seeds of SA local search in parallel, that is the order of applying each SA local search is independent, GSA generates the seeds of SA sequentially, that is the seeds of a SA local search depends of the best-so-far solutions of all previous SA local searches. This sequentially approach seems to generate better child solutions. This sequentially approach seems to generate better child solutions. In addition, compared to PGSA, GSA uses fewer crossover operations since it only uses crossover operations when the SA local search reaches a flat surface and it is time to jump in the solution space. In addition, compared to PGSA, GSA uses fewer crossover operations since it only uses crossover operations when the SA local search reaches a flat surface and it is time to jump in the solution space.

11
GSA (continue) GSA starts with a population X = {x 1, …, X Np } and repeatedly applies 3 operations: SA-based local search, GA-based crossover operation, and population update. GSA starts with a population X = {x 1, …, X Np } and repeatedly applies 3 operations: SA-based local search, GA-based crossover operation, and population update. SA-based local search produces a candidate solution x’ by changing a small fraction of the state of x. SA-based local search produces a candidate solution x’ by changing a small fraction of the state of x. The candidate solution is accepted as the new solution with probability min{1, e - f/T }. The candidate solution is accepted as the new solution with probability min{1, e - f/T }. GSA preserves the local best-so-far solution x* L during the SA- based local search. GSA preserves the local best-so-far solution x* L during the SA- based local search. When the search reaches a flat surface or the system is frozen, GSA produces a large jump in the solution space by using GA- based crossover. When the search reaches a flat surface or the system is frozen, GSA produces a large jump in the solution space by using GA- based crossover. GSA picks up a pair of parent solutions x j and x k at random from the population X such that f(x j ) f(x k ), applies crossover operator, and then replace the worst solution x i by the new solution produced by the crossover operator. GSA picks up a pair of parent solutions x j and x k at random from the population X such that f(x j ) f(x k ), applies crossover operator, and then replace the worst solution x i by the new solution produced by the crossover operator. At the end of each SA-based local search, GSA updates the population by replacing the current solution x i by the local best- so-far solution x* L. At the end of each SA-based local search, GSA updates the population by replacing the current solution x i by the local best- so-far solution x* L. GSA terminates when the CPU time reaches given limit, and reports the global best-so-far solution x* G. GSA terminates when the CPU time reaches given limit, and reports the global best-so-far solution x* G. GSA starts with a population X = {x 1, …, X Np } and repeatedly applies 3 operations: SA-based local search, GA-based crossover operation, and population update. GSA starts with a population X = {x 1, …, X Np } and repeatedly applies 3 operations: SA-based local search, GA-based crossover operation, and population update. SA-based local search produces a candidate solution x’ by changing a small fraction of the state of x. SA-based local search produces a candidate solution x’ by changing a small fraction of the state of x. The candidate solution is accepted as the new solution with probability min{1, e - f/T }. The candidate solution is accepted as the new solution with probability min{1, e - f/T }. GSA preserves the local best-so-far solution x* L during the SA- based local search. GSA preserves the local best-so-far solution x* L during the SA- based local search. When the search reaches a flat surface or the system is frozen, GSA produces a large jump in the solution space by using GA- based crossover. When the search reaches a flat surface or the system is frozen, GSA produces a large jump in the solution space by using GA- based crossover. GSA picks up a pair of parent solutions x j and x k at random from the population X such that f(x j ) f(x k ), applies crossover operator, and then replace the worst solution x i by the new solution produced by the crossover operator. GSA picks up a pair of parent solutions x j and x k at random from the population X such that f(x j ) f(x k ), applies crossover operator, and then replace the worst solution x i by the new solution produced by the crossover operator. At the end of each SA-based local search, GSA updates the population by replacing the current solution x i by the local best- so-far solution x* L. At the end of each SA-based local search, GSA updates the population by replacing the current solution x i by the local best- so-far solution x* L. GSA terminates when the CPU time reaches given limit, and reports the global best-so-far solution x* G. GSA terminates when the CPU time reaches given limit, and reports the global best-so-far solution x* G.

12
GSA (continue) Pseudo-code of GSA (Koakutsu et al. [20]) Pseudo-code of GSA (Koakutsu et al. [20]) GSA_algorithm(N p, N a, T 0, ) { X {x 1,..., X Np }; /* initialize population */ X {x 1,..., X Np }; /* initialize population */ x* L the best solution among X; /* initialize local best-so-far */ x* L the best solution among X; /* initialize local best-so-far */ x* G x* L /* initialize global best-so-far */ x* G x* L /* initialize global best-so-far */ while (not reach CPU time limit) { while (not reach CPU time limit) { T T 0 ; /* initialize temperature */ T T 0 ; /* initialize temperature */ /* jump */ /* jump */ select the worst solution x i from X; select the worst solution x i from X; select two solutions x j, x k from X such that f(x j ) f(x k ); select two solutions x j, x k from X such that f(x j ) f(x k ); x i Crossover(x j, x k ); x i Crossover(x j, x k ); /* SA-based local search */ /* SA-based local search */ while (not frozen or not meet stopping criterion) { while (not frozen or not meet stopping criterion) { for (loop = 1; loop N a ; loop++) { for (loop = 1; loop N a ; loop++) { x’ Mutate(x i ); x’ Mutate(x i ); f f(x’) – f(x i ); f f(x’) – f(x i ); r random number between 0 and 1 r random number between 0 and 1 if ( f < 0 or r < exp(- f/T)) if ( f < 0 or r < exp(- f/T)) x i x’; x i x’; if (f(x i ) < f(x* L )) if (f(x i ) < f(x* L )) x* L x i ; /* update local best-so-far */ x* L x i ; /* update local best-so-far */} T T * /* lower temperature */ } if (f(x* L ) < f(x* G )) if (f(x* L ) < f(x* G )) x* G x* L ; /* update global best-so-far */ x* G x* L ; /* update global best-so-far */ /* update population */ /* update population */ x i x* L ; x i x* L ; f(x* L ) + ; /* reset current local best-so-far */ f(x* L ) + ; /* reset current local best-so-far */ } return x* G ; return x* G ;} Pseudo-code of GSA (Koakutsu et al. [20]) Pseudo-code of GSA (Koakutsu et al. [20]) GSA_algorithm(N p, N a, T 0, ) { X {x 1,..., X Np }; /* initialize population */ X {x 1,..., X Np }; /* initialize population */ x* L the best solution among X; /* initialize local best-so-far */ x* L the best solution among X; /* initialize local best-so-far */ x* G x* L /* initialize global best-so-far */ x* G x* L /* initialize global best-so-far */ while (not reach CPU time limit) { while (not reach CPU time limit) { T T 0 ; /* initialize temperature */ T T 0 ; /* initialize temperature */ /* jump */ /* jump */ select the worst solution x i from X; select the worst solution x i from X; select two solutions x j, x k from X such that f(x j ) f(x k ); select two solutions x j, x k from X such that f(x j ) f(x k ); x i Crossover(x j, x k ); x i Crossover(x j, x k ); /* SA-based local search */ /* SA-based local search */ while (not frozen or not meet stopping criterion) { while (not frozen or not meet stopping criterion) { for (loop = 1; loop N a ; loop++) { for (loop = 1; loop N a ; loop++) { x’ Mutate(x i ); x’ Mutate(x i ); f f(x’) – f(x i ); f f(x’) – f(x i ); r random number between 0 and 1 r random number between 0 and 1 if ( f < 0 or r < exp(- f/T)) if ( f < 0 or r < exp(- f/T)) x i x’; x i x’; if (f(x i ) < f(x* L )) if (f(x i ) < f(x* L )) x* L x i ; /* update local best-so-far */ x* L x i ; /* update local best-so-far */} T T * /* lower temperature */ } if (f(x* L ) < f(x* G )) if (f(x* L ) < f(x* G )) x* G x* L ; /* update global best-so-far */ x* G x* L ; /* update global best-so-far */ /* update population */ /* update population */ x i x* L ; x i x* L ; f(x* L ) + ; /* reset current local best-so-far */ f(x* L ) + ; /* reset current local best-so-far */ } return x* G ; return x* G ;}

13
GSA to Estimate Null Values in Generating Weighted Fuzzy Rules from Relational Database Systems and It’s Estimating on Multiple Null Values Basic Concepts of Fuzzy Sets A fuzzy subset A of the universe of discourse U can be represented as follows: A fuzzy subset A of the universe of discourse U can be represented as follows: A = A (u 1 ) / u 1 + A (u 2 ) / u 2 + … + A (u n ) / u n (1) A = A (u 1 ) / u 1 + A (u 2 ) / u 2 + … + A (u n ) / u n (1) Where A is the membership function of the fuzzy subset A, A : U [0,1], and A (u i ) indicate the grade of membership of u i in the fuzzy set A. If U is continuous set, then the fuzzy subset A can be represented as follows: Where A is the membership function of the fuzzy subset A, A : U [0,1], and A (u i ) indicate the grade of membership of u i in the fuzzy set A. If U is continuous set, then the fuzzy subset A can be represented as follows: A = (2) A = (2) Part 1: Estimating Null Values in Relational Database Systems With GSA With GSA In [1], Chen et al. described how to estimate null values in relational database systems with Genetic Algorithms. In [1], Chen et al. described how to estimate null values in relational database systems with Genetic Algorithms. A linguistic term can be represented by a fuzzy set represented by a membership function. In that paper, the membership functions of the linguistic terms “L”, “SL”, “M”, “SH”, and “H” of the attributes “Salary” and “Experience” in relational database system are adopted from [6]. A linguistic term can be represented by a fuzzy set represented by a membership function. In that paper, the membership functions of the linguistic terms “L”, “SL”, “M”, “SH”, and “H” of the attributes “Salary” and “Experience” in relational database system are adopted from [6]. Basic Concepts of Fuzzy Sets A fuzzy subset A of the universe of discourse U can be represented as follows: A fuzzy subset A of the universe of discourse U can be represented as follows: A = A (u 1 ) / u 1 + A (u 2 ) / u 2 + … + A (u n ) / u n (1) A = A (u 1 ) / u 1 + A (u 2 ) / u 2 + … + A (u n ) / u n (1) Where A is the membership function of the fuzzy subset A, A : U [0,1], and A (u i ) indicate the grade of membership of u i in the fuzzy set A. If U is continuous set, then the fuzzy subset A can be represented as follows: Where A is the membership function of the fuzzy subset A, A : U [0,1], and A (u i ) indicate the grade of membership of u i in the fuzzy set A. If U is continuous set, then the fuzzy subset A can be represented as follows: A = (2) A = (2) Part 1: Estimating Null Values in Relational Database Systems With GSA With GSA In [1], Chen et al. described how to estimate null values in relational database systems with Genetic Algorithms. In [1], Chen et al. described how to estimate null values in relational database systems with Genetic Algorithms. A linguistic term can be represented by a fuzzy set represented by a membership function. In that paper, the membership functions of the linguistic terms “L”, “SL”, “M”, “SH”, and “H” of the attributes “Salary” and “Experience” in relational database system are adopted from [6]. A linguistic term can be represented by a fuzzy set represented by a membership function. In that paper, the membership functions of the linguistic terms “L”, “SL”, “M”, “SH”, and “H” of the attributes “Salary” and “Experience” in relational database system are adopted from [6]. NotationDenotes LLow SLSomewhat Low MMedium SHSomewhat High HHigh

14
… continue Here is relation in relational database [4], [6] Here is relation in relational database [4], [6] Degree of similarity between the values of the attribute “Degree” listed below: Degree of similarity between the values of the attribute “Degree” listed below: Here is relation in relational database [4], [6] Here is relation in relational database [4], [6] Degree of similarity between the values of the attribute “Degree” listed below: Degree of similarity between the values of the attribute “Degree” listed below: EMP-IDDegreeExperienceSalary S1Ph.D.7.263,000 S2Master2.037,000 S3Bachelor7.040,000 S4Ph.D.1.247,000 S5Master7.553,000 S6Bachelor1.526,000 S7Bachelor2.329,000 S8Ph.D.2.050,000 S9Ph.D.3.854,000 S10Bachelor3.535,000 S11Master3.540,000 S12Master3.641,000 S13Master10.068,000 S14Ph.D.5.057,000 S15Bachelor5.036,000 S16Master6.250,000 S17Bachelor0.523,000 S18Master7.255,000 S19Master6.551,000 S20Ph.D.7.865,000 S21Master8.164,000 S22Ph.D.8.570,000 BachelorMasterPh.D. Bachelor Master0.61 Ph.D

15
… continue

16
After fuzzification: After fuzzification: EMP-IDDegreeExperienceSalary S1Ph.D./1.0SH/0.963,000 S2Master/1.0L/0.537,000 S3Bachelor/1.0SH/1.040,000 S4Ph.D./1.0L/0.947,000 S5Master/1.0SH/0.7553,000 S6Bachelor/1.0L/0.7526,000 S7Bachelor/1.0SL/0.6529,000 S8Ph.D./1.0L/0.550,000 S9Ph.D./1.0SL/0.654,000 S10Bachelor/1.0SL/0.7535,000 S11Master/1.0SL/0.7540,000 S12Master/1.0SL/0.741,000 S13Master/1.0H/1.068,000 S14Ph.D./1.0M/1.057,000 S15Bachelor/1.0M/1.036,000 S16Master/1.0SH/0.650,000 S17Bachelor/1.0L/1.023,000 S18Master/1.0SH/0.955,000 S19Master/1.0SH/0.7551,000 S20Ph.D./1.0SH/0.665,000 S21Master/1.0H/0.5564,000 S22Ph.D./1.0H/0.7570,000

17
… continue Degree of similarity between two nonnumeric values listed below: Degree of similarity between two nonnumeric values listed below: Rank(Bachelor) = 1 Rank(Master) = 2 Rank(Ph.D.) = 3 Let X is a nonnumeric attribute. Based on the value T i.X of the attribute X of tuple T i and the value T j.X of the attribute X of tuple T j, where i j, the degree of closeness Closeness(T i, T j ) between tuples T i and T j can be calculated by (8) or (9), where Weight(T j.Degree) and Weight(T j.Experience) denote the weights of the attributes “Degree” and “Experience”, respectively, obtained from the fuzzified values of the attributes “Degree” and “Experience” of tuple T j, derived from a chromosome Let X is a nonnumeric attribute. Based on the value T i.X of the attribute X of tuple T i and the value T j.X of the attribute X of tuple T j, where i j, the degree of closeness Closeness(T i, T j ) between tuples T i and T j can be calculated by (8) or (9), where Weight(T j.Degree) and Weight(T j.Experience) denote the weights of the attributes “Degree” and “Experience”, respectively, obtained from the fuzzified values of the attributes “Degree” and “Experience” of tuple T j, derived from a chromosome If Rank(T i.X) Rank(T j.X) then Closeness(T i, T j ) = Similarity(T i.X, T j.X) Weight(T j.Degree) + Weight(T j.Experience)(8) Closeness(T i, T j ) = Similarity(T i.X, T j.X) Weight(T j.Degree) + Weight(T j.Experience)(8) If Rank(Ti.X) < Rank(Tj.X) then Closeness(T i, T j ) = 1/Similarity(T i.X, T j.X) Weight(T j.Degree) + Weight(T j.Experience)(9) Closeness(T i, T j ) = 1/Similarity(T i.X, T j.X) Weight(T j.Degree) + Weight(T j.Experience)(9) where Similarity(T i.X, T j.X) denotes the degree of similarity between T i.X and T j.X, and its value is obtained from a fuzzy similarity matrix of the linguistic terms of the attribute X defined by a domain expert. where Similarity(T i.X, T j.X) denotes the degree of similarity between T i.X and T j.X, and its value is obtained from a fuzzy similarity matrix of the linguistic terms of the attribute X defined by a domain expert. Degree of similarity between two nonnumeric values listed below: Degree of similarity between two nonnumeric values listed below: Rank(Bachelor) = 1 Rank(Master) = 2 Rank(Ph.D.) = 3 Let X is a nonnumeric attribute. Based on the value T i.X of the attribute X of tuple T i and the value T j.X of the attribute X of tuple T j, where i j, the degree of closeness Closeness(T i, T j ) between tuples T i and T j can be calculated by (8) or (9), where Weight(T j.Degree) and Weight(T j.Experience) denote the weights of the attributes “Degree” and “Experience”, respectively, obtained from the fuzzified values of the attributes “Degree” and “Experience” of tuple T j, derived from a chromosome Let X is a nonnumeric attribute. Based on the value T i.X of the attribute X of tuple T i and the value T j.X of the attribute X of tuple T j, where i j, the degree of closeness Closeness(T i, T j ) between tuples T i and T j can be calculated by (8) or (9), where Weight(T j.Degree) and Weight(T j.Experience) denote the weights of the attributes “Degree” and “Experience”, respectively, obtained from the fuzzified values of the attributes “Degree” and “Experience” of tuple T j, derived from a chromosome If Rank(T i.X) Rank(T j.X) then Closeness(T i, T j ) = Similarity(T i.X, T j.X) Weight(T j.Degree) + Weight(T j.Experience)(8) Closeness(T i, T j ) = Similarity(T i.X, T j.X) Weight(T j.Degree) + Weight(T j.Experience)(8) If Rank(Ti.X) < Rank(Tj.X) then Closeness(T i, T j ) = 1/Similarity(T i.X, T j.X) Weight(T j.Degree) + Weight(T j.Experience)(9) Closeness(T i, T j ) = 1/Similarity(T i.X, T j.X) Weight(T j.Degree) + Weight(T j.Experience)(9) where Similarity(T i.X, T j.X) denotes the degree of similarity between T i.X and T j.X, and its value is obtained from a fuzzy similarity matrix of the linguistic terms of the attribute X defined by a domain expert. where Similarity(T i.X, T j.X) denotes the degree of similarity between T i.X and T j.X, and its value is obtained from a fuzzy similarity matrix of the linguistic terms of the attribute X defined by a domain expert.

18
… continue Estimated value “ET i.Salary” of the attribute “Salary” of tuple T i as follows: Estimated value “ET i.Salary” of the attribute “Salary” of tuple T i as follows: ET i.Salary = T i.Salary Closeness (T i, T j )(10) Estimated error of each tuple by (11), where Error i denotes the estimated error between the estimated value ET i.Salary of the attribute “Salary” of tuple T i and the actual value T i.Salary of the attribute “Salary” of tuple T i Estimated error of each tuple by (11), where Error i denotes the estimated error between the estimated value ET i.Salary of the attribute “Salary” of tuple T i and the actual value T i.Salary of the attribute “Salary” of tuple T i Errori =(11) Let Avg_Error denote the average estimated error of the tuples based on the combination of weights of the attributes derived from the chromosome, where Let Avg_Error denote the average estimated error of the tuples based on the combination of weights of the attributes derived from the chromosome, where Avg_Error =(12) Then, we can obtain the fitness degree of this chromosome as follows: Then, we can obtain the fitness degree of this chromosome as follows: Fitness Degree = 1 – Avg_Error(13) Estimated value “ET i.Salary” of the attribute “Salary” of tuple T i as follows: Estimated value “ET i.Salary” of the attribute “Salary” of tuple T i as follows: ET i.Salary = T i.Salary Closeness (T i, T j )(10) Estimated error of each tuple by (11), where Error i denotes the estimated error between the estimated value ET i.Salary of the attribute “Salary” of tuple T i and the actual value T i.Salary of the attribute “Salary” of tuple T i Estimated error of each tuple by (11), where Error i denotes the estimated error between the estimated value ET i.Salary of the attribute “Salary” of tuple T i and the actual value T i.Salary of the attribute “Salary” of tuple T i Errori =(11) Let Avg_Error denote the average estimated error of the tuples based on the combination of weights of the attributes derived from the chromosome, where Let Avg_Error denote the average estimated error of the tuples based on the combination of weights of the attributes derived from the chromosome, where Avg_Error =(12) Then, we can obtain the fitness degree of this chromosome as follows: Then, we can obtain the fitness degree of this chromosome as follows: Fitness Degree = 1 – Avg_Error(13)

19
… continue Here is a table where 1 value is null value, and with GSA we try to obtained this value from other value together with formulas described above. Here is a table where 1 value is null value, and with GSA we try to obtained this value from other value together with formulas described above. EMP-IDDegreeExperienceSalary S1Ph.D.7.263,000 S2Master2.037,000 S3Bachelor7.040,000 S4Ph.D.1.247,000 S5Master7.553,000 S6Bachelor1.526,000 S7Bachelor2.329,000 S8Ph.D.2.050,000 S9Ph.D.3.854,000 S10Bachelor3.535,000 S11Master3.540,000 S12Master3.641,000 S13Master10.068,000 S14Ph.D.5.057,000 S15Bachelor5.036,000 S16Master6.250,000 S17Bachelor0.523,000 S18Master7.255,000 S19Master6.551,000 S20Ph.D.7.865,000 S21Master8.164,000 S22Ph.D.8.5NULL

20
EvaluationAndBestSelection {find the best solution among population. Also it initializes LocalBestChromosomeSoFar and GlobalBestChromosomeSoFar: X {x 1,..., X Np }; {initialize population} x* L the best solution among X; {initialize local best-so-far} x* G x*L {initialize global best-so-far} FitnessDegreeEval FitnessDegree from global best-so-far } for i:= 1 to number-of-generations do begin T T 0 ; T T 0 ; EvaluationAndWorstSelection; {select the worst solution x i from X} EvaluationAndWorstSelection; {select the worst solution x i from X} CrossOver; {select two solutions x j, x k from X such that f(x j ) f(x k ): CrossOver; {select two solutions x j, x k from X such that f(x j ) f(x k ): x i Crossover(x j, x k ); x i Crossover(x j, x k ); } Mutation; {update local best-so-far if value is better Mutation; {update local best-so-far if value is better repeat repeat for i:= 0 to number-of-mutation do begin for i:= 0 to number-of-mutation do begin f(x i ) Get Fitness Degree from chromosome before mutation f(x i ) Get Fitness Degree from chromosome before mutation x’ Mutate(x i ) x’ Mutate(x i ) f(x’) Get Fitness Degree from chromosome after mutation f(x’) Get Fitness Degree from chromosome after mutation f f(x i ) - f(x’) f f(x i ) - f(x’) r random number between 0 and 1 r random number between 0 and 1 f t f(x’) f t f(x’) if ( f >= 0) or (r >= exp(- f/T)) then begin if ( f >= 0) or (r >= exp(- f/T)) then begin x i x’; x i x’; f t f(xi); f t f(xi); end; end; if (f t >= FitnessDegreeEval) then begin if (f t >= FitnessDegreeEval) then begin x* L x i ; {update local best-so-far} x* L x i ; {update local best-so-far} FitnessDegreeEval f t FitnessDegreeEval f t FDLocalBestSoFar f t {Get local best Fitness Degree} FDLocalBestSoFar f t {Get local best Fitness Degree} end end T T * ; {lower temperature} T T * ; {lower temperature} until T <= FrozenValue; until T <= FrozenValue; } CountCloseness( x* L ); {get FD from LocalBestChromosomeSoFar} CountCloseness( x* L ); {get FD from LocalBestChromosomeSoFar} AvgError:= AvgError / NumData; AvgError:= AvgError / NumData; FDLocalBestSoFar:= 1 - AvgError; FDLocalBestSoFar:= 1 - AvgError; CountCloseness( x* G ); {get FD from GlobalBestChromosomeSoFar} CountCloseness( x* G ); {get FD from GlobalBestChromosomeSoFar} AvgError:= AvgError / NumData; AvgError:= AvgError / NumData; FDGlobalBestSoFar:= 1 - AvgError; FDGlobalBestSoFar:= 1 - AvgError; if FDLocalBestSoFar >= FDGlobalBestSoFar then begin if FDLocalBestSoFar >= FDGlobalBestSoFar then begin x* G x* L ; {update global best-so-far} x* G x* L ; {update global best-so-far} FitnessDegreeEval:= FDGlobalBestSoFar; FitnessDegreeEval:= FDGlobalBestSoFar; end; end; x i x* L ; {update population} x i x* L ; {update population}end;EvaluationAndBestSelection {find the best solution among population. Also it initializes LocalBestChromosomeSoFar and GlobalBestChromosomeSoFar: X {x 1,..., X Np }; {initialize population} x* L the best solution among X; {initialize local best-so-far} x* G x*L {initialize global best-so-far} FitnessDegreeEval FitnessDegree from global best-so-far } for i:= 1 to number-of-generations do begin T T 0 ; T T 0 ; EvaluationAndWorstSelection; {select the worst solution x i from X} EvaluationAndWorstSelection; {select the worst solution x i from X} CrossOver; {select two solutions x j, x k from X such that f(x j ) f(x k ): CrossOver; {select two solutions x j, x k from X such that f(x j ) f(x k ): x i Crossover(x j, x k ); x i Crossover(x j, x k ); } Mutation; {update local best-so-far if value is better Mutation; {update local best-so-far if value is better repeat repeat for i:= 0 to number-of-mutation do begin for i:= 0 to number-of-mutation do begin f(x i ) Get Fitness Degree from chromosome before mutation f(x i ) Get Fitness Degree from chromosome before mutation x’ Mutate(x i ) x’ Mutate(x i ) f(x’) Get Fitness Degree from chromosome after mutation f(x’) Get Fitness Degree from chromosome after mutation f f(x i ) - f(x’) f f(x i ) - f(x’) r random number between 0 and 1 r random number between 0 and 1 f t f(x’) f t f(x’) if ( f >= 0) or (r >= exp(- f/T)) then begin if ( f >= 0) or (r >= exp(- f/T)) then begin x i x’; x i x’; f t f(xi); f t f(xi); end; end; if (f t >= FitnessDegreeEval) then begin if (f t >= FitnessDegreeEval) then begin x* L x i ; {update local best-so-far} x* L x i ; {update local best-so-far} FitnessDegreeEval f t FitnessDegreeEval f t FDLocalBestSoFar f t {Get local best Fitness Degree} FDLocalBestSoFar f t {Get local best Fitness Degree} end end T T * ; {lower temperature} T T * ; {lower temperature} until T <= FrozenValue; until T <= FrozenValue; } CountCloseness( x* L ); {get FD from LocalBestChromosomeSoFar} CountCloseness( x* L ); {get FD from LocalBestChromosomeSoFar} AvgError:= AvgError / NumData; AvgError:= AvgError / NumData; FDLocalBestSoFar:= 1 - AvgError; FDLocalBestSoFar:= 1 - AvgError; CountCloseness( x* G ); {get FD from GlobalBestChromosomeSoFar} CountCloseness( x* G ); {get FD from GlobalBestChromosomeSoFar} AvgError:= AvgError / NumData; AvgError:= AvgError / NumData; FDGlobalBestSoFar:= 1 - AvgError; FDGlobalBestSoFar:= 1 - AvgError; if FDLocalBestSoFar >= FDGlobalBestSoFar then begin if FDLocalBestSoFar >= FDGlobalBestSoFar then begin x* G x* L ; {update global best-so-far} x* G x* L ; {update global best-so-far} FitnessDegreeEval:= FDGlobalBestSoFar; FitnessDegreeEval:= FDGlobalBestSoFar; end; end; x i x* L ; {update population} x i x* L ; {update population}end;

21
Procedure CountCloseness describe below: Procedure CountCloseness describe below: AvgError:= 0.0; for i:= 0 to NumData - 1 do begin {base on all data available} BestClosenessEval:= MaxInt; BestClosenessEval:= MaxInt; IdxClosestCloseness:= i; IdxClosestCloseness:= i; for j:= 0 to NumData - 1 do for j:= 0 to NumData - 1 do if i <> j then begin if i <> j then begin if Rank(Ti.X) Rank(Tj.X) then begin if Rank(Ti.X) Rank(Tj.X) then begin ClosenessE(Ti,Tj)= Similarity(Ti.X,Tj.X) Weight(Tj.Degree) + ClosenessE(Ti,Tj)= Similarity(Ti.X,Tj.X) Weight(Tj.Degree) + Weight(Tj.Experience); Weight(Tj.Experience); end end else begin {If Rank(Ti.X) < Rank(Tj.X)} else begin {If Rank(Ti.X) < Rank(Tj.X)} ClosenessE:= 1/Similarity(Ti.X,Tj.X) Weight(Tj.Degree) + ClosenessE:= 1/Similarity(Ti.X,Tj.X) Weight(Tj.Degree) + Weight(Tj.Experience); Weight(Tj.Experience); end; end; {find a tuples which is closest to 1.0 as a} {find a tuples which is closest to 1.0 as a} {closest tuple to tuple Ti} {closest tuple to tuple Ti} ClosestCloseness:= Abs(1 - ClosenessE); ClosestCloseness:= Abs(1 - ClosenessE); if ClosestCloseness <= BestClosenessEval then begin if ClosestCloseness <= BestClosenessEval then begin BestClosenessEval:= ClosestCloseness; BestClosenessEval:= ClosestCloseness; IdxClosestCloseness:= j; IdxClosestCloseness:= j; end; end; {Then we find Estimated Salary and Error for every record} {Then we find Estimated Salary and Error for every record} {if this record was null value, so we must find} {if this record was null value, so we must find} {another record that closest to 1} {another record that closest to 1} if IsNullValue(i) and IsNullValue(IdxClosestCloseness) then begin if IsNullValue(i) and IsNullValue(IdxClosestCloseness) then begin PreferIdx:= GetPreferIdx; PreferIdx:= GetPreferIdx; ET i.Salary:= T i. Salary GetClosenessValue(PreferIdx); ET i.Salary:= T i. Salary GetClosenessValue(PreferIdx); if T prefer-index.Salary <> 0 then if T prefer-index.Salary <> 0 then Error i := Error i := end end else begin else begin ET i.Salary:= T i. Salary GetClosenessValue(IdxClosestCloseness); ET i.Salary:= T i. Salary GetClosenessValue(IdxClosestCloseness); if T i.Salary <> 0 then if T i.Salary <> 0 then Error i := Error i := end; end; AvgError:= AvgError + Abs(Error i ); AvgError:= AvgError + Abs(Error i );end; Procedure CountCloseness describe below: Procedure CountCloseness describe below: AvgError:= 0.0; for i:= 0 to NumData - 1 do begin {base on all data available} BestClosenessEval:= MaxInt; BestClosenessEval:= MaxInt; IdxClosestCloseness:= i; IdxClosestCloseness:= i; for j:= 0 to NumData - 1 do for j:= 0 to NumData - 1 do if i <> j then begin if i <> j then begin if Rank(Ti.X) Rank(Tj.X) then begin if Rank(Ti.X) Rank(Tj.X) then begin ClosenessE(Ti,Tj)= Similarity(Ti.X,Tj.X) Weight(Tj.Degree) + ClosenessE(Ti,Tj)= Similarity(Ti.X,Tj.X) Weight(Tj.Degree) + Weight(Tj.Experience); Weight(Tj.Experience); end end else begin {If Rank(Ti.X) < Rank(Tj.X)} else begin {If Rank(Ti.X) < Rank(Tj.X)} ClosenessE:= 1/Similarity(Ti.X,Tj.X) Weight(Tj.Degree) + ClosenessE:= 1/Similarity(Ti.X,Tj.X) Weight(Tj.Degree) + Weight(Tj.Experience); Weight(Tj.Experience); end; end; {find a tuples which is closest to 1.0 as a} {find a tuples which is closest to 1.0 as a} {closest tuple to tuple Ti} {closest tuple to tuple Ti} ClosestCloseness:= Abs(1 - ClosenessE); ClosestCloseness:= Abs(1 - ClosenessE); if ClosestCloseness <= BestClosenessEval then begin if ClosestCloseness <= BestClosenessEval then begin BestClosenessEval:= ClosestCloseness; BestClosenessEval:= ClosestCloseness; IdxClosestCloseness:= j; IdxClosestCloseness:= j; end; end; {Then we find Estimated Salary and Error for every record} {Then we find Estimated Salary and Error for every record} {if this record was null value, so we must find} {if this record was null value, so we must find} {another record that closest to 1} {another record that closest to 1} if IsNullValue(i) and IsNullValue(IdxClosestCloseness) then begin if IsNullValue(i) and IsNullValue(IdxClosestCloseness) then begin PreferIdx:= GetPreferIdx; PreferIdx:= GetPreferIdx; ET i.Salary:= T i. Salary GetClosenessValue(PreferIdx); ET i.Salary:= T i. Salary GetClosenessValue(PreferIdx); if T prefer-index.Salary <> 0 then if T prefer-index.Salary <> 0 then Error i := Error i := end end else begin else begin ET i.Salary:= T i. Salary GetClosenessValue(IdxClosestCloseness); ET i.Salary:= T i. Salary GetClosenessValue(IdxClosestCloseness); if T i.Salary <> 0 then if T i.Salary <> 0 then Error i := Error i := end; end; AvgError:= AvgError + Abs(Error i ); AvgError:= AvgError + Abs(Error i );end;

22
… continue Function GetClosenessValue describe below: Function GetClosenessValue describe below: function GetClosenessValue(Idx) Result find value in ClosenessE which have the same index with Idx Result find value in ClosenessE which have the same index with Idx Function GetPreferIdx describe below: Function GetPreferIdx describe below: function GetPreferIdx Result find value in ClosenessE that closest to 1, and it's not null value Result find value in ClosenessE that closest to 1, and it's not null value Function GetClosenessValue describe below: Function GetClosenessValue describe below: function GetClosenessValue(Idx) Result find value in ClosenessE which have the same index with Idx Result find value in ClosenessE which have the same index with Idx Function GetPreferIdx describe below: Function GetPreferIdx describe below: function GetPreferIdx Result find value in ClosenessE that closest to 1, and it's not null value Result find value in ClosenessE that closest to 1, and it's not null value

23
… continue Experiments We run this program for different parameters, each for 10 times. We run this program for different parameters, each for 10 times. We get the results as below: We get the results as below: Experiments type 1: Mutation Rate = 0.01 = 1% Mutation Rate = 0.01 = 1% Initial Temperature = 100 Initial Temperature = 100 Alpha = 0.7 Alpha = 0.7 Frozen Value = Frozen Value = Index of Null Values = 21 (It means row/tuple 22th in relational database) Index of Null Values = 21 (It means row/tuple 22th in relational database)Experiments We run this program for different parameters, each for 10 times. We run this program for different parameters, each for 10 times. We get the results as below: We get the results as below: Experiments type 1: Mutation Rate = 0.01 = 1% Mutation Rate = 0.01 = 1% Initial Temperature = 100 Initial Temperature = 100 Alpha = 0.7 Alpha = 0.7 Frozen Value = Frozen Value = Index of Null Values = 21 (It means row/tuple 22th in relational database) Index of Null Values = 21 (It means row/tuple 22th in relational database)

24
… continue

25
Size Of Population30 Number of Generations100 Running # Avg. Estimated Error Ho ur Minu te Seco nd Miliseco nd Total Time h:2m:16s:781ms h:2m:10s:844ms h:2m:36s:797ms h:3m:12s:250ms h:3m:5s:406ms h:2m:45s:766ms h:2m:34s:469ms h:2m:44s:46ms h:2m:41s:235ms h:2m:32s:515ms Min Average Max

26
… continue Size Of Population40 Number of Generations150 Running # Avg. Estimated Error Ho ur Minu te Seco nd Miliseco nd Total Time h:6m:9s:578ms h:8m:23s:937ms h:6m:56s:344ms h:7m:13s:969ms h:9m:16s:703ms h:7m:40s:547ms h:6m:53s:187ms h:7m:9s:438ms h:7m:34s:594ms h:7m:39s:406ms Min Average Max

27
… continue Size Of Population50 Number of Generations200 Running # Avg. Estimated Error Ho ur Minu te Seco nd Miliseco nd Total Time h:10m:36s:531ms h:10m:31s:250ms h:9m:54s:484ms h:9m:47s:719ms h:9m:47s:735ms h:9m:54s:62ms h:9m:50s:469ms h:9m:48s:531ms h:9m:53s:828ms h:9m:45s:610ms Min Average Max

28
… continue Size Of Population60 Number of Generations300 Running # Avg. Estimated Error Ho ur Minu te Seco nd Miliseco nd Total Time h:20m:28s:453ms h:20m:32s:328ms h:20m:29s:500ms h:20m:30s:125ms h:20m:27s:78ms h:20m:23s:282ms h:20m:27s:984ms h:20m:30s:328ms h:20m:31s:578ms h:20m:30s:16ms Min Average Max

29
… continue Experiments type 2: Mutation Rate = 0.1 = 10% Mutation Rate = 0.1 = 10% Initial Temperature = 100 Initial Temperature = 100 Alpha = 0.7 Alpha = 0.7 Frozen Value = Frozen Value = Index of Null Values = 21 (It means row/tuple 22th in relational database) Index of Null Values = 21 (It means row/tuple 22th in relational database) Experiments type 2: Mutation Rate = 0.1 = 10% Mutation Rate = 0.1 = 10% Initial Temperature = 100 Initial Temperature = 100 Alpha = 0.7 Alpha = 0.7 Frozen Value = Frozen Value = Index of Null Values = 21 (It means row/tuple 22th in relational database) Index of Null Values = 21 (It means row/tuple 22th in relational database)

30
… continue Size Of Population30 Number of Generations100 Running # Avg. Estimated Error Ho ur Minu te Seco nd Miliseco nd Total Time h:21m:56s:125ms h:21m:35s:563ms h:20m:59s:672ms h:20m:53s:484ms h:20m:58s:453ms h:20m:57s:891ms h:21m:1s:203ms h:20m:57s:734ms h:21m:2s:641ms h:21m:10s:687ms Min Average Max

31
… continue Size Of Population40 Number of Generations100 Running # Avg. Estimated Error Ho ur Minu te Seco nd Miliseco nd Total Time h:46m:50s:906ms h:47m:0s:282ms h:46m:55s:15ms h:47m:2s:891ms h:47m:8s:125ms h:47m:1s:890ms h:47m:57s:907ms h:50m:1s:31ms h:50m:9s:594ms h:50m:36s:234ms Min Average Max

32
… continue Size Of Population50 Number of Generations100 Running # Avg. Estimated Error Ho ur Minu te Seco nd Miliseco nd Total Time h:23m:28s:125ms h:23m:14s:938ms h:23m:25s:219ms h:23m:18s:734ms h:23m:21s:969ms h:23m:24s:234ms h:23m:24s:188ms h:23m:30s:375ms h:23m:27s:437ms h:23m:30s:938ms Min Average Max

33
… continue Size Of Population60 Number of Generations100 Running # Avg. Estimated Error Ho ur Minu te Seco nd Miliseco nd Total Time h:17m:21s:94ms h:14m:42s:203ms h:14m:42s:250ms h:16m:31s:188ms h:18m:55s:156ms h:10m:8s:625ms h:8m:29s:797ms h:21m:7s:125ms h:18m:13s:125ms h:15m:50s:968ms Min Average Max

34
… continue Summaries from experiments Summaries from experiments Avg. Estimation Error Size Of Population Number of Generations Mutation Rate (%) Initial TemperatureAlphaFrozen Value Min. Estimation Error Size Of Population Number of Generations Mutation Rate (%) Initial TemperatureAlphaFrozen Value

35
… continue Summaries from experiments (continue) Summaries from experiments (continue) Max. Estimation Error Size Of Population Number of Generations Mutation Rate (%) Initial TemperatureAlphaFrozen Value

36
… continue For comparing, we toke result from Chen et al. [1] For comparing, we toke result from Chen et al. [1] Best chromosome: Best chromosome: Below is the result from with size of population: 60; number of generations: 300; Cross Over rate: 1.0; and Mutation rate: 0.2 Below is the result from with size of population: 60; number of generations: 300; Cross Over rate: 1.0; and Mutation rate: 0.2 For comparing, we toke result from Chen et al. [1] For comparing, we toke result from Chen et al. [1] Best chromosome: Best chromosome: Below is the result from with size of population: 60; number of generations: 300; Cross Over rate: 1.0; and Mutation rate: 0.2 Below is the result from with size of population: 60; number of generations: 300; Cross Over rate: 1.0; and Mutation rate: 0.2

37
EMP-IDDegreeExperienceSalarySalary (Estimated)Estimated Error S1Ph.D.7.263,00061, S2Master2.037,00036, S3Bachelor7.040,00040, S4Ph.D.1.247,00046, S5Master7.553,00056, S6Bachelor1.526,00026, S7Bachelor2.329,00027, S8Ph.D.2.050,00050, S9Ph.D.3.854,00053, S10Bachelor3.535,00035, S11Master3.540,00040, S12Master3.641,00040, S13Master10.068,00068, S14Ph.D.5.057,00056, S15Bachelor5.036,00034, S16Master6.250,00049, S17Bachelor0.523,00023, S18Master7.255,00051, S19Master6.551,00051, S20Ph.D.7.865,00064, S21Master8.164,00060, S22Ph.D.8.570,00069, Average Estimated Error0.018

38
… continue For another running we get average estimated errors for different parameters of the GA (Chen et al. [1]) For another running we get average estimated errors for different parameters of the GA (Chen et al. [1]) Size of Population Number of Generations Crossover Rate Mutation Rate Average Estimated Error

39
… continue Example a result from one of above (from this research, using GSA) Example a result from one of above (from this research, using GSA) Size of Population:60 Number of Generations:300 Mutation Rate (%):10 Initial Temperature:100 Alpha:0.7 Frozen Value:1E-5 Index of Null Values: 21 Best Chromosome Gene-1Gene-2Gene-3Gene-4Gene-5Gene-6Gene-7Gene Gene-9Gene-10Gene-11 Gene-12Gene-13Gene-14Gene Example a result from one of above (from this research, using GSA) Example a result from one of above (from this research, using GSA) Size of Population:60 Number of Generations:300 Mutation Rate (%):10 Initial Temperature:100 Alpha:0.7 Frozen Value:1E-5 Index of Null Values: 21 Best Chromosome Gene-1Gene-2Gene-3Gene-4Gene-5Gene-6Gene-7Gene Gene-9Gene-10Gene-11 Gene-12Gene-13Gene-14Gene

40
… continue Example a result from one of above (continue) Example a result from one of above (continue) Emp. IDDegreeExperience SalarySalary (Estimated)Estimated Error 1Ph.D.7.263,00062, Master2.037,00036, Bachelor 7.040,00040, Ph.D.1.247,00046, Master7.553,00052, Bachelor 1.526,00025, Bachelor 2.329,00028, Ph.D.2.050,00050, Ph.D.3.854,00053, Bachelor 3.535,00035, Master3.540,00039, Master3.641,00040, Master10.068,00068, Ph.D.5.057,00056, Bachelor 5.036,00036, Master6.250,00049, Bachelor 0.523,00022, Master7.255,00054, Master6.551,00050, Ph.D.7.865,00064, Master8.164,00063, Ph.D.8.570,00070, Avg Estimated Error: Time Elapsed: 3h:15m:50s:968ms Here, we can prove that this proposes method better than method proposed by C.M. Huang [1]. Here, we can prove that this proposes method better than method proposed by C.M. Huang [1]. Example a result from one of above (continue) Example a result from one of above (continue) Emp. IDDegreeExperience SalarySalary (Estimated)Estimated Error 1Ph.D.7.263,00062, Master2.037,00036, Bachelor 7.040,00040, Ph.D.1.247,00046, Master7.553,00052, Bachelor 1.526,00025, Bachelor 2.329,00028, Ph.D.2.050,00050, Ph.D.3.854,00053, Bachelor 3.535,00035, Master3.540,00039, Master3.641,00040, Master10.068,00068, Ph.D.5.057,00056, Bachelor 5.036,00036, Master6.250,00049, Bachelor 0.523,00022, Master7.255,00054, Master6.551,00050, Ph.D.7.865,00064, Master8.164,00063, Ph.D.8.570,00070, Avg Estimated Error: Time Elapsed: 3h:15m:50s:968ms Here, we can prove that this proposes method better than method proposed by C.M. Huang [1]. Here, we can prove that this proposes method better than method proposed by C.M. Huang [1].

41
GSA to Estimate Null Values in Generating Weighted Fuzzy Rules from Relational Database Systems and It’s Estimating on Multiple Null Values Part 2: Estimating Problems on Multiple Null Values In part 1, we concerning just about how to perform In part 1, we concerning just about how to perform At this part, we try to estimate many values, which are null values. At this part, we try to estimate many values, which are null values. Recalling procedure CountCloseness described previously in part 1, we consider part below: Recalling procedure CountCloseness described previously in part 1, we consider part below:…… {Then we find Estimated Salary and Error for every record} {Then we find Estimated Salary and Error for every record} {if this record was null value, so we must find} {if this record was null value, so we must find} {another record that closest to 1} {another record that closest to 1} if IsNullValue(i) and IsNullValue(IdxClosestCloseness) then begin if IsNullValue(i) and IsNullValue(IdxClosestCloseness) then begin PreferIdx:= GetPreferIdx; PreferIdx:= GetPreferIdx; ET i.Salary:= T i. Salary GetClosenessValue(PreferIdx); ET i.Salary:= T i. Salary GetClosenessValue(PreferIdx); if T prefer-index.Salary <> 0 then if T prefer-index.Salary <> 0 then Error i := Error i := end end else begin else begin ET i.Salary:= T i. Salary GetClosenessValue(IdxClosestCloseness); ET i.Salary:= T i. Salary GetClosenessValue(IdxClosestCloseness); if T i.Salary <> 0 then if T i.Salary <> 0 then Error i := Error i := end; end; Part 2: Estimating Problems on Multiple Null Values In part 1, we concerning just about how to perform In part 1, we concerning just about how to perform At this part, we try to estimate many values, which are null values. At this part, we try to estimate many values, which are null values. Recalling procedure CountCloseness described previously in part 1, we consider part below: Recalling procedure CountCloseness described previously in part 1, we consider part below:…… {Then we find Estimated Salary and Error for every record} {Then we find Estimated Salary and Error for every record} {if this record was null value, so we must find} {if this record was null value, so we must find} {another record that closest to 1} {another record that closest to 1} if IsNullValue(i) and IsNullValue(IdxClosestCloseness) then begin if IsNullValue(i) and IsNullValue(IdxClosestCloseness) then begin PreferIdx:= GetPreferIdx; PreferIdx:= GetPreferIdx; ET i.Salary:= T i. Salary GetClosenessValue(PreferIdx); ET i.Salary:= T i. Salary GetClosenessValue(PreferIdx); if T prefer-index.Salary <> 0 then if T prefer-index.Salary <> 0 then Error i := Error i := end end else begin else begin ET i.Salary:= T i. Salary GetClosenessValue(IdxClosestCloseness); ET i.Salary:= T i. Salary GetClosenessValue(IdxClosestCloseness); if T i.Salary <> 0 then if T i.Salary <> 0 then Error i := Error i := end; end;

42
… continue Here is a table where many values are null value, and with GSA we try to obtained this value from other value together with formulas described above. Here is a table where many values are null value, and with GSA we try to obtained this value from other value together with formulas described above. EMP-IDDegreeExperienceSalary S1Ph.D.7.263,000 S2Master2.0NULL S3Bachelor7.040,000 S4Ph.D.1.247,000 S5Master7.5NULL S6Bachelor1.526,000 S7Bachelor2.329,000 S8Ph.D.2.050,000 S9Ph.D.3.854,000 S10Bachelor3.535,000 S11Master3.5NULL S12Master3.641,000 S13Master10.0NULL S14Ph.D.5.057,000 S15Bachelor5.036,000 S16Master6.250,000 S17Bachelor0.523,000 S18Master7.255,000 S19Master6.551,000 S20Ph.D.7.865,000 S21Master8.164,000 S22Ph.D.8.5NULL

43
Because there is a checking process with regarding to null values, so we can set one or many null values that we want to estimate. This process performs in function GetPreferIdx as described previous. Because there is a checking process with regarding to null values, so we can set one or many null values that we want to estimate. This process performs in function GetPreferIdx as described previous. Of course as a boundary/quota, there is at least one value in column/field SALARY to estimate another (if it is a null value). Of course as a boundary/quota, there is at least one value in column/field SALARY to estimate another (if it is a null value).Experiments We run this program for different parameters, each for 10 times. We run this program for different parameters, each for 10 times. We get the results as below: We get the results as below: Experiments type 1 Size Of Population = 60 Size Of Population = 60 Number of Generations = 300 Number of Generations = 300 Mutation Rate = 0.01 = 1% Mutation Rate = 0.01 = 1% Initial Temperature = 100 Initial Temperature = 100 Alpha = 0.7 Alpha = 0.7 Frozen Value = Frozen Value = Index of Null Values = 0 (It means row/tuple 1st in relational database) Index of Null Values = 0 (It means row/tuple 1st in relational database) Because there is a checking process with regarding to null values, so we can set one or many null values that we want to estimate. This process performs in function GetPreferIdx as described previous. Because there is a checking process with regarding to null values, so we can set one or many null values that we want to estimate. This process performs in function GetPreferIdx as described previous. Of course as a boundary/quota, there is at least one value in column/field SALARY to estimate another (if it is a null value). Of course as a boundary/quota, there is at least one value in column/field SALARY to estimate another (if it is a null value).Experiments We run this program for different parameters, each for 10 times. We run this program for different parameters, each for 10 times. We get the results as below: We get the results as below: Experiments type 1 Size Of Population = 60 Size Of Population = 60 Number of Generations = 300 Number of Generations = 300 Mutation Rate = 0.01 = 1% Mutation Rate = 0.01 = 1% Initial Temperature = 100 Initial Temperature = 100 Alpha = 0.7 Alpha = 0.7 Frozen Value = Frozen Value = Index of Null Values = 0 (It means row/tuple 1st in relational database) Index of Null Values = 0 (It means row/tuple 1st in relational database) … continue

44
Index of Null Values = 0 (It means row/tuple 1 st in relational database) Index of Null Values = 0 (It means row/tuple 1 st in relational database) … continue Running # Avg. Estimated ErrorTotal Time h:22m:56s:46ms h:22m:47s:188ms h:22m:43s:484ms h:22m:45s:500ms h:22m:40s:922ms h:22m:39s:219ms h:22m:42s:437ms h:23m:13s:922ms h:22m:47s:47ms h:22m:46s:281ms Min h:22m:39s:219ms Average h:22m:48s:205ms Max h:23m:13s:922ms

45
Index of Null Values = 0,1 (It means row/tuple 1 st and 2 nd in relational database) Index of Null Values = 0,1 (It means row/tuple 1 st and 2 nd in relational database) … continue Running # Avg. Estimated ErrorTotal Time h:23m:0s:906ms h:23m:1s:281ms h:22m:59s:954ms h:22m:56s:937ms h:22m:53s:797ms h:22m:46s:844ms h:22m:52s:484ms h:22m:53s:688ms h:22m:53s:406ms h:22m:56s:109ms Min h:22m:46s:844ms Average h:22m:55s:541ms Max h:23m:1s:281ms

46
Index of Null Values = 0,1,2 Index of Null Values = 0,1,2 … continue Running # Avg. Estimated ErrorTotal Time h:23m:17s:62ms h:23m:10s:281ms h:23m:4s:672ms h:23m:9s:141ms h:23m:5s:422ms h:23m:2s:937ms h:23m:7s:172ms h:23m:11s:47ms h:23m:11s:422ms h:23m:12s:468ms Min h:23m:2s:937ms Average h:23m:9s:162ms Max h:23m:17s:62ms

47
Index of Null Values = 0,1,2,3 Index of Null Values = 0,1,2,3 … continue Running # Avg. Estimated ErrorTotal Time h:23m:27s:406ms h:23m:22s:313ms h:23m:20s:453ms h:23m:20s:469ms h:23m:19s:687ms h:23m:18s:360ms h:23m:20s:62ms h:23m:22s:875ms h:23m:22s:563ms h:23m:24s:218ms Min h:23m:18s:360ms Average h:23m:21s:841ms Max h:23m:27s:406ms

48
Index of Null Values = 0,1,2,3,4 Index of Null Values = 0,1,2,3,4 … continue Running # Avg. Estimated ErrorTotal Time h:23m:45s:500ms h:23m:46s:922ms h:23m:36s:156ms h:23m:39s:219ms h:23m:35s:843ms h:23m:33s:891ms h:23m:40s:875ms h:23m:40s:656ms h:24m:9s:657ms h:24m:42s:156ms Min h:23m:33s:891ms Average h:23m:49s:88ms Max h:24m:42s:156ms

49
Index of Null Values = 0,1,2,3,4,5 Index of Null Values = 0,1,2,3,4,5 … continue Running # Avg. Estimated ErrorTotal Time h:25m:0s:578ms h:24m:55s:828ms h:24m:52s:125ms h:24m:46s:94ms h:24m:48s:766ms h:24m:48s:109ms h:24m:47s:531ms h:24m:52s:610ms h:24m:57s:78ms h:24m:52s:703ms Min h:24m:46s:94ms Average h:24m:52s:142ms Max h:25m:0s:578ms

50
Index of Null Values = 0,1,2,3,4,5,6 Index of Null Values = 0,1,2,3,4,5,6 … continue Running # Avg. Estimated ErrorTotal Time h:26m:0s:546ms h:25m:45s:125ms h:25m:49s:547ms h:25m:54s:32ms h:25m:53s:890ms h:25m:54s:391ms h:25m:50s:312ms h:25m:46s:860ms h:25m:50s:218ms h:25m:56s:891ms Min h:25m:45s:125ms Average h:25m:52s:181ms Max h:26m:0s:546ms

51
Index of Null Values = 0,1,2,3,4,5,6,7 Index of Null Values = 0,1,2,3,4,5,6,7 … continue Running #Avg. Estimated ErrorTotal Time h:27m:12s:218ms h:27m:18s:485ms h:27m:1s:312ms h:27m:2s:63ms h:27m:44s:31ms h:28m:26s:109ms h:29m:48s:407ms h:28m:58s:812ms h:27m:18s:797ms h:38m:45s:266ms Min h:27m:1s:312ms Average h:28m:57s:550ms Max h:38m:45s:266ms

52
Index of Null Values = 0,1,2,3,4,5,6,7,8 Index of Null Values = 0,1,2,3,4,5,6,7,8 … continue Running # Avg. Estimated ErrorTotal Time h:49m:53s:547ms h:37m:49s:813ms h:30m:46s:46ms h:30m:18s:938ms h:30m:1s:0ms h:27m:1s:203ms h:27m:3s:625ms h:27m:6s:109ms h:27m:0s:422ms h:27m:8s:94ms Min h:27m:0s:422ms Average h:31m:24s:880ms Max h:49m:53s:547ms

53
Index of Null Values = 0,1,2,3,4,5,6,7,8,9 Index of Null Values = 0,1,2,3,4,5,6,7,8,9 … continue Running # Avg. Estimated ErrorTotal Time h:28m:36s:500ms h:28m:31s:531ms h:28m:38s:235ms h:28m:29s:390ms h:28m:23s:313ms h:28m:41s:312ms h:28m:34s:188ms h:28m:39s:15ms h:28m:26s:672ms h:28m:34s:860ms Min h:28m:23s:313ms Average h:28m:33s:502ms Max h:28m:41s:312ms

54
Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10 Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10 … continue Running # Avg. Estimated ErrorTotal Time h:29m:28s:156ms h:29m:21s:922ms h:32m:17s:750ms h:33m:6s:860ms h:31m:44s:203ms h:32m:17s:797ms h:32m:21s:360ms h:30m:7s:343ms h:30m:17s:438ms h:30m:0s:844ms Min h:29m:21s:922ms Average h:31m:6s:367ms Max h:33m:6s:860ms

55
Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11 Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11 … continue Running # Avg. Estimated ErrorTotal Time h:34m:5s:765ms h:33m:33s:797ms h:33m:43s:875ms h:33m:41s:16ms h:33m:27s:250ms h:33m:30s:531ms h:33m:47s:187ms h:33m:31s:641ms h:33m:35s:844ms h:33m:34s:437ms Min h:33m:27s:250ms Average h:33m:39s:134ms Max h:34m:5s:765ms

56
Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11,12 Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11,12 … continue Running #Avg. Estimated ErrorTotal Time h:36m:9s:94ms h:35m:53s:781ms h:36m:5s:407ms h:38m:38s:171ms h:41m:51s:375ms h:40m:25s:672ms h:36m:7s:860ms h:41m:35s:828ms h:42m:24s:359ms h:43m:48s:906ms Min h:35m:53s:781ms Average h:39m:18s:45ms Max h:43m:48s:906ms

57
Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11,12,13 Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11,12,13 … continue Running # Avg. Estimated ErrorTotal Time h:42m:1s:281ms h:37m:38s:547ms h:37m:34s:860ms h:37m:40s:718ms h:37m:28s:47ms h:37m:14s:188ms h:37m:41s:156ms h:37m:32s:953ms h:37m:36s:641ms h:37m:25s:422ms Min h:37m:14s:188ms Average h:37m:59s:381ms Max h:42m:1s:281ms

58
Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14 Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14 … continue Running #Avg. Estimated ErrorTotal Time h:40m:39s:125ms h:40m:49s:750ms h:40m:46s:688ms h:43m:11s:781ms h:42m:56s:94ms h:42m:14s:922ms h:40m:8s:671ms h:41m:11s:329ms h:48m:1s:203ms h:48m:29s:15ms Min h:40m:8s:671ms Average h:42m:50s:858ms Max h:48m:29s:15ms

59
Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 Index of Null Values = 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 … continue Running # Avg. Estimated ErrorTotal Time h:55m:2s:62ms h:52m:13s:797ms h:42m:11s:531ms h:42m:28s:141ms h:42m:32s:344ms h:43m:50s:797ms h:45m:44s:468ms h:48m:57s:360ms h:54m:33s:250ms h:50m:24s:422ms Min h:42m:11s:531ms Average h:47m:47s:817ms Max h:55m:2s:62ms

60
Summaries from experiments Summaries from experiments … continue # Null ValuesAvg. Estimated ErrorTotal Time h:22m:48s:205ms h:22m:55s:541ms h:23m:9s:162ms h:23m:21s:841ms h:23m:49s:88ms h:24m:52s:142ms h:25m:52s:181ms h:28m:57s:550ms h:31m:24s:880ms h:28m:33s:502ms h:31m:6s:367ms h:33m:39s:134ms h:39m:18s:45ms h:37m:59s:381ms h:42m:50s:858ms h:47m:47s:817ms

61
Conclusion SA generates a single sequence of solutions and searches for an optimum solution along this search path. SA generates a single sequence of solutions and searches for an optimum solution along this search path. At each step, SA generates a candidate solution x’ by changing a small fraction of a current solution x. At each step, SA generates a candidate solution x’ by changing a small fraction of a current solution x. A key point of SA is that SA accepts up-hill moves with the probability e - f/T. A key point of SA is that SA accepts up-hill moves with the probability e - f/T. This allows SA to escape from local minima. This allows SA to escape from local minima. But SA cannot cover a large region of the solution space within a limited computation time because SA is based on small moves. But SA cannot cover a large region of the solution space within a limited computation time because SA is based on small moves. GA maintains a population of solutions and uses them to search the solution space. GA maintains a population of solutions and uses them to search the solution space. GA uses the crossover operator which causes a large jump in the solution space. GA uses the crossover operator which causes a large jump in the solution space. GA can do globally search a large region of the solution space. GA can do globally search a large region of the solution space. But GA has no explicit ways to produce a sequence of small moves in the solution space. But GA has no explicit ways to produce a sequence of small moves in the solution space. Mutation on GA creates a single small move one at a time instead of a sequence of small moves. Mutation on GA creates a single small move one at a time instead of a sequence of small moves. As the result GA cannot search local region on the solution space exhaustively. As the result GA cannot search local region on the solution space exhaustively. GSA generates the seeds of SA sequentially, that is the seeds of a SA local search depends of the best-so-far solutions of all previous SA local searches. GSA generates the seeds of SA sequentially, that is the seeds of a SA local search depends of the best-so-far solutions of all previous SA local searches. This sequentially approach seems to generate better child solutions. This sequentially approach seems to generate better child solutions. GSA uses fewer crossover operations since it only uses crossover operations when the SA local search reaches a flat surface and it is time to jump in the solution space. GSA uses fewer crossover operations since it only uses crossover operations when the SA local search reaches a flat surface and it is time to jump in the solution space. GSA proposed to overcome: disability of cover a large region of the solution space of SA and disability of searching local region of the solution space of GA. GSA proposed to overcome: disability of cover a large region of the solution space of SA and disability of searching local region of the solution space of GA. SA generates a single sequence of solutions and searches for an optimum solution along this search path. SA generates a single sequence of solutions and searches for an optimum solution along this search path. At each step, SA generates a candidate solution x’ by changing a small fraction of a current solution x. At each step, SA generates a candidate solution x’ by changing a small fraction of a current solution x. A key point of SA is that SA accepts up-hill moves with the probability e - f/T. A key point of SA is that SA accepts up-hill moves with the probability e - f/T. This allows SA to escape from local minima. This allows SA to escape from local minima. But SA cannot cover a large region of the solution space within a limited computation time because SA is based on small moves. But SA cannot cover a large region of the solution space within a limited computation time because SA is based on small moves. GA maintains a population of solutions and uses them to search the solution space. GA maintains a population of solutions and uses them to search the solution space. GA uses the crossover operator which causes a large jump in the solution space. GA uses the crossover operator which causes a large jump in the solution space. GA can do globally search a large region of the solution space. GA can do globally search a large region of the solution space. But GA has no explicit ways to produce a sequence of small moves in the solution space. But GA has no explicit ways to produce a sequence of small moves in the solution space. Mutation on GA creates a single small move one at a time instead of a sequence of small moves. Mutation on GA creates a single small move one at a time instead of a sequence of small moves. As the result GA cannot search local region on the solution space exhaustively. As the result GA cannot search local region on the solution space exhaustively. GSA generates the seeds of SA sequentially, that is the seeds of a SA local search depends of the best-so-far solutions of all previous SA local searches. GSA generates the seeds of SA sequentially, that is the seeds of a SA local search depends of the best-so-far solutions of all previous SA local searches. This sequentially approach seems to generate better child solutions. This sequentially approach seems to generate better child solutions. GSA uses fewer crossover operations since it only uses crossover operations when the SA local search reaches a flat surface and it is time to jump in the solution space. GSA uses fewer crossover operations since it only uses crossover operations when the SA local search reaches a flat surface and it is time to jump in the solution space. GSA proposed to overcome: disability of cover a large region of the solution space of SA and disability of searching local region of the solution space of GA. GSA proposed to overcome: disability of cover a large region of the solution space of SA and disability of searching local region of the solution space of GA.

62
References [1] S.M. Chen and C.M. Huang, “Generating weighted fuzzy rules from relational database systems for estimating null values using genetic algorithms,” IEEE Transactions On Fuzzy Systems, Vol. 11, No. 4, pp , August [1] S.M. Chen and C.M. Huang, “Generating weighted fuzzy rules from relational database systems for estimating null values using genetic algorithms,” IEEE Transactions On Fuzzy Systems, Vol. 11, No. 4, pp , August [3] D.G. Burkhardt and P.P. Bonissone, “Automated fuzzy knowledge base Generation and tuning,” in Proc IEEE Int. Conf. Fuzzy Systems, San Diego, CA, 1992, pp [3] D.G. Burkhardt and P.P. Bonissone, “Automated fuzzy knowledge base Generation and tuning,” in Proc IEEE Int. Conf. Fuzzy Systems, San Diego, CA, 1992, pp [4] S.M. Chen and H.H. Chen, “Estimating null values in the distributed relational databases environment,” Cybern. Syst., Vol. 31, No. 8, pp , [4] S.M. Chen and H.H. Chen, “Estimating null values in the distributed relational databases environment,” Cybern. Syst., Vol. 31, No. 8, pp , [5] S.M. Chen, S.H. Lee, and C.H. Lee, “A new method for generating fuzzy rules from numerical data for handling classification problems,” Appl. Art. Intell., Vol. 15, No. 7, pp , [5] S.M. Chen, S.H. Lee, and C.H. Lee, “A new method for generating fuzzy rules from numerical data for handling classification problems,” Appl. Art. Intell., Vol. 15, No. 7, pp , [6] S.M. Chen and M.S. Yeh, “Generating fuzzy rules from relational database systems for estimating null values,” Cybern. Syst., Vol. 28, No. 8, pp , [6] S.M. Chen and M.S. Yeh, “Generating fuzzy rules from relational database systems for estimating null values,” Cybern. Syst., Vol. 28, No. 8, pp , [10] D. Sirag and P. Weisser, “Toward a unified thermodynamic genetic operator,” in Proc. 2nd Int. Conf. Genetic Algorithms, pp , [10] D. Sirag and P. Weisser, “Toward a unified thermodynamic genetic operator,” in Proc. 2nd Int. Conf. Genetic Algorithms, pp , [11] D. Adler, “Genetic algorithms and simulated annealing: a marriage proposal,” in Proc. Int. Conf. Neural Network, pp , [11] D. Adler, “Genetic algorithms and simulated annealing: a marriage proposal,” in Proc. Int. Conf. Neural Network, pp , [12] D. Brown, C. Huntley, and A. Spillane, “A parallel genetic heuristic for the quadratic assignment problem,” in Proc. 3rd Int. Conf. Genetic Algorithms, pp , [12] D. Brown, C. Huntley, and A. Spillane, “A parallel genetic heuristic for the quadratic assignment problem,” in Proc. 3rd Int. Conf. Genetic Algorithms, pp , [13] T.-T. Lin, C.-Y. Kao, and C.-C. Hsu, “Applying the genetic approach to simulated annealing in solving some NP-Hard problems,” IEEE Trans. System, Man, and Cybernetics., vol.23, no.6, pp , [13] T.-T. Lin, C.-Y. Kao, and C.-C. Hsu, “Applying the genetic approach to simulated annealing in solving some NP-Hard problems,” IEEE Trans. System, Man, and Cybernetics., vol.23, no.6, pp , [14] S. Koakutsu, Y. Sugai, H. Hirata, “Block placement by improved simulated annealing based on genetic algorithm,” Trans. of the institute of Electronics, Information and Communication Engineers of Japan, vol.J73-A, No.1, pp.87-94, [14] S. Koakutsu, Y. Sugai, H. Hirata, “Block placement by improved simulated annealing based on genetic algorithm,” Trans. of the institute of Electronics, Information and Communication Engineers of Japan, vol.J73-A, No.1, pp.87-94, [15] S. Koakutsu, Y. Sugai, H. Hirata, “Floorplanning by improved simulated annealing based on genetic algorithm,” Trans. of the institute of Electrical Engineers of Japan, vol.112-C, No.7, pp , [15] S. Koakutsu, Y. Sugai, H. Hirata, “Floorplanning by improved simulated annealing based on genetic algorithm,” Trans. of the institute of Electrical Engineers of Japan, vol.112-C, No.7, pp , [20] S. Koakutsu, M. Kang, and W. W.-M. Dai, “Genetic simulated annealing and application to non-slicing floorplan design,” in Proc. 5th ACM/SIGDA Physical Design Workshop, (Virginia, USA), pp , April [20] S. Koakutsu, M. Kang, and W. W.-M. Dai, “Genetic simulated annealing and application to non-slicing floorplan design,” in Proc. 5th ACM/SIGDA Physical Design Workshop, (Virginia, USA), pp , April [1] S.M. Chen and C.M. Huang, “Generating weighted fuzzy rules from relational database systems for estimating null values using genetic algorithms,” IEEE Transactions On Fuzzy Systems, Vol. 11, No. 4, pp , August [1] S.M. Chen and C.M. Huang, “Generating weighted fuzzy rules from relational database systems for estimating null values using genetic algorithms,” IEEE Transactions On Fuzzy Systems, Vol. 11, No. 4, pp , August [3] D.G. Burkhardt and P.P. Bonissone, “Automated fuzzy knowledge base Generation and tuning,” in Proc IEEE Int. Conf. Fuzzy Systems, San Diego, CA, 1992, pp [3] D.G. Burkhardt and P.P. Bonissone, “Automated fuzzy knowledge base Generation and tuning,” in Proc IEEE Int. Conf. Fuzzy Systems, San Diego, CA, 1992, pp [4] S.M. Chen and H.H. Chen, “Estimating null values in the distributed relational databases environment,” Cybern. Syst., Vol. 31, No. 8, pp , [4] S.M. Chen and H.H. Chen, “Estimating null values in the distributed relational databases environment,” Cybern. Syst., Vol. 31, No. 8, pp , [5] S.M. Chen, S.H. Lee, and C.H. Lee, “A new method for generating fuzzy rules from numerical data for handling classification problems,” Appl. Art. Intell., Vol. 15, No. 7, pp , [5] S.M. Chen, S.H. Lee, and C.H. Lee, “A new method for generating fuzzy rules from numerical data for handling classification problems,” Appl. Art. Intell., Vol. 15, No. 7, pp , [6] S.M. Chen and M.S. Yeh, “Generating fuzzy rules from relational database systems for estimating null values,” Cybern. Syst., Vol. 28, No. 8, pp , [6] S.M. Chen and M.S. Yeh, “Generating fuzzy rules from relational database systems for estimating null values,” Cybern. Syst., Vol. 28, No. 8, pp , [10] D. Sirag and P. Weisser, “Toward a unified thermodynamic genetic operator,” in Proc. 2nd Int. Conf. Genetic Algorithms, pp , [10] D. Sirag and P. Weisser, “Toward a unified thermodynamic genetic operator,” in Proc. 2nd Int. Conf. Genetic Algorithms, pp , [11] D. Adler, “Genetic algorithms and simulated annealing: a marriage proposal,” in Proc. Int. Conf. Neural Network, pp , [11] D. Adler, “Genetic algorithms and simulated annealing: a marriage proposal,” in Proc. Int. Conf. Neural Network, pp , [12] D. Brown, C. Huntley, and A. Spillane, “A parallel genetic heuristic for the quadratic assignment problem,” in Proc. 3rd Int. Conf. Genetic Algorithms, pp , [12] D. Brown, C. Huntley, and A. Spillane, “A parallel genetic heuristic for the quadratic assignment problem,” in Proc. 3rd Int. Conf. Genetic Algorithms, pp , [13] T.-T. Lin, C.-Y. Kao, and C.-C. Hsu, “Applying the genetic approach to simulated annealing in solving some NP-Hard problems,” IEEE Trans. System, Man, and Cybernetics., vol.23, no.6, pp , [13] T.-T. Lin, C.-Y. Kao, and C.-C. Hsu, “Applying the genetic approach to simulated annealing in solving some NP-Hard problems,” IEEE Trans. System, Man, and Cybernetics., vol.23, no.6, pp , [14] S. Koakutsu, Y. Sugai, H. Hirata, “Block placement by improved simulated annealing based on genetic algorithm,” Trans. of the institute of Electronics, Information and Communication Engineers of Japan, vol.J73-A, No.1, pp.87-94, [14] S. Koakutsu, Y. Sugai, H. Hirata, “Block placement by improved simulated annealing based on genetic algorithm,” Trans. of the institute of Electronics, Information and Communication Engineers of Japan, vol.J73-A, No.1, pp.87-94, [15] S. Koakutsu, Y. Sugai, H. Hirata, “Floorplanning by improved simulated annealing based on genetic algorithm,” Trans. of the institute of Electrical Engineers of Japan, vol.112-C, No.7, pp , [15] S. Koakutsu, Y. Sugai, H. Hirata, “Floorplanning by improved simulated annealing based on genetic algorithm,” Trans. of the institute of Electrical Engineers of Japan, vol.112-C, No.7, pp , [20] S. Koakutsu, M. Kang, and W. W.-M. Dai, “Genetic simulated annealing and application to non-slicing floorplan design,” in Proc. 5th ACM/SIGDA Physical Design Workshop, (Virginia, USA), pp , April [20] S. Koakutsu, M. Kang, and W. W.-M. Dai, “Genetic simulated annealing and application to non-slicing floorplan design,” in Proc. 5th ACM/SIGDA Physical Design Workshop, (Virginia, USA), pp , April 1996.

Similar presentations

© 2016 SlidePlayer.com Inc.

All rights reserved.

Ads by Google