
Genetic Algorithms Digest   Monday, August 12 1991   Volume 5 : Issue 22

 - Send submissions to GA-List@AIC.NRL.NAVY.MIL
 - Send administrative requests to GA-List-Request@AIC.NRL.NAVY.MIL

Today's Topics:
	- GAs vs. Bitwise Hill-Climbers (Building Block Hypothesis...Harmful)
	- New TCGA reports

**********************************************************************

CALENDAR OF GA-RELATED ACTIVITIES: (with GA-List issue reference)

 IJCAI 91, International Joint Conference on AI, Sydney, AU   Aug 25-30, 1991
 First European Conference on Artificial Life (v5n10)         Dec 11-13, 1991
 Canadian AI Conference, Vancouver, (CFP 1/7)                 May 11-15, 1992
 10th National Conference on AI, San Jose, (CFP 1/15)         Jul 12-17, 1992
 ECAI 92, 10th European Conference on AI (v5n13)              Aug  3-7,  1992
 Parallel Problem Solving from Nature, Brussels, (CFP 4/15)   Sep 28-30, 1992

 (Send announcements of other activities to GA-List@aic.nrl.navy.mil)

**********************************************************************
----------------------------------------------------------------------

From: gref@AIC.NRL.Navy.Mil
Date: Wed, 7 Aug 91 19:32:49 EDT
Subject: GAs vs. Bitwise Hill-Climbers (Building Block Hypothesis...Harmful)

   The ICGA-91 papers by Stewart Wilson and Dave Davis both address the
   comparison of GAs to bitwise hill-climbers.  Wilson takes the
   interesting approach of trying to define particular examples that
   illustrate that the set of functions that GAs can optimize is not a
   subset of the functions that can be optimized by one class of
   hill-climbers.  This is an interesting approach, but there are two
   possible objections to Stewart's example:

   1. It may not fool all hill-climbers, in particular the kind that Dave
   Davis describes (i.e., next-ascent vs. steepest-ascent).  (This was
   pointed out to me by Rich Caruana.)

   2. While the function is "GA-easy", this does not imply that it can be
   easily optimized by GAs (see my last note).

   I have created a function similar to Stewart's that answers both
   objections: Consider a binary string of length 5m (m >> 1).  Let x(i)
   refer to bits 5*i+1 through 5*i+5, for i from 0 to (m-1).  Let n(i) be
   the number of 0's in x(i).  Define g(i) = n(i) if n(i) > 0, and g(i) =
   10 if n(i) = 0.  Let f(x) = sum of g(i), for i = 0 to (m-1).  That is, a
   block 11111 of 5 1's gets 10 points and any other pattern gets one point
   for each 0.

   This function will mislead any bitwise hill-climber, whether it does
   steepest-ascent or next-ascent.  The hill-climber will transform any
   block x(i) into 00000, unless the original x(i) is within Hamming
   distance 1 from 11111.  It follows that the probability of any single
   block being optimized is 6/32 = 0.1875.  The probability of optimizing a
   string of m blocks is (0.1875)^m, which quickly converges to 0 with
   increasing m.

   I ran a next-ascent hill-climber similar to Davis's RBC on this problem
   with 50 bits (m = 10).  This program changes each bit (in random order)
   and keeps any improvement.  After all bits are tried, a new random order
   is selected and all bits are flipped again.  This repeats until no
   improvements are found.  I got the following results over 100 runs:

	   Best (count)	Worst (count)	Mean	Std	Evals per run
	   65.0 (3)	50.0 (54)	53.25	4.11	101

   Note that this RBC makes all its changes on the first pass, and the
   second 50 evals finds no change that gives any improvement.

   I also ran a steepest-ascent hill-climber on this problem.  This program
   changes each bit and keeps the change giving the most improvement.  This
   repeats until no improvements are found.  I got the following results
   over 100 runs:

	   Best (count)	Worst (count)	Mean	Std	Evals per run
	   75.0 (1)	50.0 (14)	59.95	6.17	978

   This does a little better than the next-ascent program, but stills fails
   to come close to optimizing the function.  A score of 75 means that 5
   blocks of 1's were found (out of 10).  A score of 50 corresponds to the
   local optimum of all 0's.  These results agree closely with our
   expectations.  These results strongly suggest that even a large
   population of hill-climbers (as discussed by Wilson) could not be
   expected to produce a single near-optimal solution to this problem.

   I also tried what I thought would be a more sophisticated next-ascent
   hill-climber.  This one changed each bit (in random order), followed by
   every pair of bits (also in random order). I got the following results
   over 100 runs:

	   Best (count)	Worst (count)	Mean	Std	Evals per run
	   65.0 (3)	50.0 (54)	53.25	4.11	2551

   This actually gives the identical results as the first program. The
   reason is that first pass (changing single bits) moves each block either
   to the optimum value of all 1's, or further from the optimum, so that
   when we change two bits, we tend to change both to 0's.

   The good news is that this problem is easily solved by a GA.  Using
   GENESIS with the usual parameters (popsize = 100, crossover = 0.6,
   mutation = 0.001), I got the following results over 100 runs (each run
   bounded by 2500 trials, to make it competitive to the third program
   above):

	   Best (count)	Worst (count)	Mean	Std	Evals per run
	   100.0 (16)	78.8 (1)	91.8	5.57	2100

   The GA found the optimum 16% of the time, and it found very good
   solutions (containing at least 8 blocks of 1's) in 71% of the runs. The
   worst run of the GA was better than the best run of the hill-climbers.

   This seems to be a function for which crossover is particularly
   effective in bringing together quickly building blocks associated with
   high payoff.  For example, running the GA 100 times with mutation alone
   (my best results were with a mutation rate of 0.005) yields results much
   worse than those with crossover (within the allotted time), but still
   better than the hill-climbers:

	   Best (count)	Worst (count)	Mean	Std	Evals per run
	   100.0 (1)	56.0 (2)	72.3	7.79	2169

   Bottom line: As Wilson suggested analytically and Davis showed
   empirically for RBC, there do exist functions that can be easily
   optimized by GAs, but not by bitwise hill-climbers.  The contribution
   here is that the example distinguishes GAs from every bit-wise
   hill-climber, and is simple enough that it might help us develop a more
   analytic characterization of such functions.

------------------------------

From: Robert Elliott Smith <rob@galab2.mh.ua.edu>
Date: Mon, 24 Jun 91 10:03:04 CDT
Subject: New TCGA reports

  I am pleased to announce that the following documents are available
  through The Clearinghouse for Genetic Algorithms (TCGA).  To request a
  report, or the TCGA catalog, please email to rob@galab2.mh.ua.edu, U.S.
  Mail to

  The Clearinghouse for Genetic Algorithms
  Department of Engineering Mechanics
  University of Alabama
  P.O. Box 870278
  Tuscaloosa, Alabama 35487 

  or phone (205) 348-1618.  For dissertations requested through TCGA, we
  must ask for $9.00 ($12.00 overseas) to defray copying, binding, and
  shipping cost.  Note that this is for dissertations only.

  TCGA Report #91001 :
		       "System Identification with 
		       Evolving Polynomial Networks"
				   by

		      Hillol Kargupta and R. E. Smith
			 University of Alabama 

			    Abstract
  The construction of models for prediction and control of initially
  unknown, potentially nonlinear systems is a difficult, fundamental problem
  in machine learning and engineering control.  In this paper, a {\em
  genetic algorithm} (GA) based technique is used to iteratively form
  polynomial networks that model the behavior of nonlinear systems. This
  approach is motivated by the {\em group method of data handling} (GMDH)
  (Ivakhnenko, 1971), but attempts to overcome the computational overhead
  and locality associated with the original GMDH. The approach presented
  here uses a multi-modal GA (Deb, 1989a) to select nodes for a network
  based on an information-theoretic fitness measure. Preliminary results
  show that the GA is successful in modeling continuous-time and
  discrete-time chaotic systems. Implications and extensions of this work
  are discussed.  (Note: a revised version of this report is due to appear
  in ICGA4)

  TCGA Report #91002 :
		 "SGA-C: A C-language Implementation of a
			Simple Genetic Algorithm"
				 by

			   Robert E. Smith
		      The University of Alabama
			 David E. Goldberg
		     The University of Illinois
			 Jeff A. Earickson
	    Alabama Supercomputer Network -The Boeing Company

			  Abstract
  SGA-C is a C-language translation and extension of the original Pascal SGA
  code presented by Goldberg \citeyear{Goldberg:89e}.  It has some
  additional features, but its operation is essentially the same as that of
  the original, Pascal version.  This report is included as a concise
  introduction to the SGA-C distribution.  It is presented with the
  assumptions that the reader has a general understanding of Goldberg's
  original Pascal SGA code, and a good working knowledge of the C
  programming language.  (NOTE: Program available on various media by
  request. Please be prepared to send formatted media.)

  TCGA Report #91003 (dissertation) :
	    Default Hierarchy Formation and Memory Exploitation 
		    in Learning Classifier Systems

				 by 
			Robert Elliott Smith
			  A  Dissertation
		     The University of Alabama

			      Abstract 
  Automated adaptation in a general setting remains a difficult and poorly
  understood problem. {\em Reinforcement learning control problems} model
  environments where an automated system must optimize a reinforcement
  signal by providing inputs to a black-box whose internal structure is
  initially unknown and persistently uncertain. {\em Learning classifier
  systems} (LCSs) are a class of rule-based systems for reinforcement
  learning control that use genetic algorithms (GAs) for rule discovery.
  Genetic algorithms are a class of computerized search procedures whose
  mechanics are based on natural genetics. This study examines two
  characteristic aspects of LCSs: default hierarchy formation and memory
  exploitation.

  Default hierarchies are sets of rules where the utilities of partially
  correct, but broadly applicable rules (defaults) are augmented by
  additional rules (exceptions). By forming default hierarchies, an LCS can
  store knowledge in parsimonious rule sets that can be incrementally
  refined.  To do this, an LCS must have conflict resolution mechanisms that
  cause exceptions to consistently override defaults. This study examines
  typical LCS conflict resolution mechanisms and shows that they are
  inadequate in many situations. A new conflict resolution strategy called
  the {\em priority tuning scheme} is introduced. Experimentation shows that
  this scheme properly organizes default hierarchies in situations where
  traditional schemes fail. Analysis reveals that this technique greatly
  enlarges the class of exploitable default hierarchies.

  LCSs have the potential to adaptively exploit memory and extend their
  capabilities beyond simple stimulus-response behavior. This study develops
  a class of problems that isolate memory exploitation from other aspects of
  LCS behavior. Experiments show that an LCS can form rule sets that exploit
  memory. However, the LCS does not form optimal rule sets because of a
  limitation in its allocation of credit scheme. This study demonstrates
  this limitation and suggests an alternate scheme that automatically
  evolves multi-rule corporations as a remedy.  Preliminary analysis
  illustrates the potential of this method.

  LCSs are a promising approach to reinforcement learning.
  This study has suggested several directions
  for refinement and improved understanding of LCSs.
  Further development of learning systems like LCSs should
  extend the applicability of automatic systems to tasks that currently
  require human intervention.

  TCGA Report #91004 (dissertation) :
		  Binary and Floating Point Optimization
		      Using Messy Genetic Algorithms
				  by
			      Kalyonmoy Deb
			     A Dissertation
			The University of Alabama

			      Abstract
  Over the years, simple tripartite genetic algorithms (GAs) have been found
  successful in a wide variety of problem domains. The working of a simple
  GA is based on the schema theorem, which implies that an optimal or
  near-optimal solution is formed by the combination of low-order building
  blocks in successive generations. There exists, however, a class of
  functions where low-order building blocks may not combine to form
  higher-order building blocks. These functions are termed as GA-deceptive
  functions. In addition, the underlying coding mechanism may be such that
  important allele combinations are distant along the string and are
  difficult to preserve due to the action of genetic operators. In the
  solution of a problem with a combination of GA-deceptive function and poor
  allele combinations, simple GAs digress from the globally optimal solution
  and converge to a false solution.  Even though the problem can be
  partially solved using inversion or other reordering operators, these
  remedies are not practical enough to be of any use. Messy GAs (Goldberg,
  Korb, and Deb, 1989) have been found to solve this class of problems
  successfully.  In a messy GA, salient, low-order building blocks are
  selected in its primordial phase. Thereafter, during the juxtapositional
  phase, these low-order building blocks are first combined to form
  higher-order building blocks. The messy GA then acts much like a simple
  GA, with tight building blocks combining together to form the optimal
  solution.  This dissertation examines the working of a messy GA, analyzes
  its operators, extends its use to solve problems of nonuniform building
  block size and scale, and applies messy GAs to solve a real-world
  engineering problem that is difficult to solve using a simple GA. A messy
  floating-point code is also designed to enable floating-point function
  optimization by adaptively assigning precision to a decision parameter
  where it is needed. Theoretical and empirical studies have demonstrated
  that messy GAs can be used to tackle hard combinatorial optimization
  problems which are difficult to solve using other techniques.

  TCGA Report # 91005:
		 SGA-Cube: A Simple Genetic Algorithm for
		  nCUBE 2 Hypercube Parallel Computers
				 by

			  Jeff A. Earickson
	    Alabama Supercomputer Network - The Boeing Company
			 Robert E. Smith
		     The University of Alabama
			David E. Goldberg
		   The University of Illinois

			   Abstract
  SGA-Cube is a C-language translation of the original Pascal SGA code
  presented by Goldberg \citeyear{Goldberg:89e} with modifications to allow
  execution on the nCUBE 2 Hypercube Parallel Computer. When run on the
  nCUBE 2, SGA-Cube takes advantage of the hypercube architecture, and is
  scalable to any hypercube dimension.  The hypercube implementation is
  modular, so that the algorithm for exploiting parallel processors can be
  easily modified.  In addition to its parallel capabilities, SGA-Cube can
  be compiled on various serial computers via compile-time options.  In
  fact, when compiled on a serial computer, SGA-Cube is essentially
  identical to SGA-C (Smith, Goldberg & Earickson, 1991).  SGA-Cube has been
  nominally tested on a Sun 470 workstation, a Vax Ultrix system, a Cray
  X-MP/24 running UNICOS 5.1, and the nCUBE 2.

  This report is included as a concise introduction to the SGA-Cube
  distribution.  It is presented with the assumptions that the reader has a
  general understanding of Goldberg's original Pascal SGA code, and a good
  working knowledge of the C programming language.  (NOTE: Program available
  on various media by request. Please be prepared to send formatted media.)

------------------------------
End of Genetic Algorithms Digest
******************************
