This work compares the performance of genetic programming (GP) against traditional fixed-length genome GA approaches on the optimization of wire antenna designs. We describe the implementation of a GP electromagnetic optimization system for wire structures. The results are compared with the traditional GA approach. Although the dimensionality of the search space is much higher for GP than GA, we find that the GP approach gives better results than GA for the same computational effort. In addition, we find that a more expressive antenna structure grammar, dramatically, improves the performance of the GP approach.

Genetic programming (GP) [

A GP approach (termed an “open-ended, constructive
EA”) is described by Lohn et al. [

In contrast to GP, the traditional fixed-length
genetic algorithm (GA) has been widely applied to electromagnetic optimization
of structures [

In this paper, we consider optimization of wire antenna
designs and directly compare the performance of GP-based optimization
strategies against the traditional fixed-length genome GA approach. We begin
with a description of our GP algorithm, and then we apply this to a standard GA
structure optimization problem, the crooked wire antenna of Linden and Altshuler
[

In the GP approach, we represent the antenna structure
as a function that

Structure generator functions are expressed as
programs in a language. This language consists of four functions that each
perform a different task in structure generation. These are “start”

An example of an individual starting at the origin

The start function

This is a terminal symbol for structures.

In this

The tree structure representing the function

The tree structures that are compositions of structure
functions described in Section

An initial population of individuals is randomly created. Each individual begins with a “start” function, with a random position parameter and a random child structure. In this work, the random child structure is created by selecting with equal probability a “wire,” “join,” or “end” function, each with randomly chosen parameters as appropriate (positions and further child structures). Different choices of probability might yield improved results but were not explored.

The selection of individuals for reproduction is
carried out by first evaluating the fitness,

A fraction of the next generation is created by direct
copying. This process is also called elitism. In the work presented here, the
fittest 1% of the current generation are selected for direct copying to the
next generation. Another 18% of the next generation are copied from the
previous generation by proportionate selection [

Individuals are selected for crossover by proportionate selection. Two individuals from the current generation, when selected for crossover, will generate two new individuals in the next generation. A node on each tree is selected at random and the child nodes are swapped. Thus, two individuals selected for crossover will produce two individuals in the next generation. This method of crossover between two individuals can grow or reduce the size of the individuals generated in subsequent generations.

We tested crossover rates between 20% and 90%, and found that using a crossover rate of 80% yielded the highest fitness after 50 generations. In the work presented here, 80% of the next generation are generated by crossover.

A small percentage of individuals are selected for mutation. Mutation introduces new structures into the next generation. A mutation was carried out by choosing a random node in the tree structure of an individual, deleting that node and its children and substituting a randomly generated structure in its place. In the work presented here, 1% of the next generation are generated by mutation.

After each generation has been selected each
individual's fitness is evaluated using a cost function, and this fitness
drives the selection process for the next generation. If, for example, an
individual is generated with no wire elements, that is,

The GP code was written in C++ and designed from the
ground up to operate efficiently in a cluster computing environment. A master
node executes the genetic programming code, while the evaluation of individuals
is performed on all the other nodes in the cluster using the message passing
interface (MPI) [

To improve speed, particularly on small geometries, we
use Nec2++ [

To compare the performance of the GP approach against
the chromosome-based GA approach, we consider the “crooked-wire problem” of
Linden and Altshuler [

The antenna geometry was only loosely constrained by
the antenna size, excitation source, number of wires, and presence of a ground
plane. The antenna was confined to a cube, half a wavelength on each side.
Binary strings were used to encode the antenna design, five bits were allowed
for each component of the coordinates of the endpoints of each wire. There were
therefore 32 possible positions in each dimension for each endpoint. The number
of wires was also a constrained—to seven. As there are five bits per
axis-coordinate, three coordinates per endpoint, and seven unique endpoints to
be designated (each wire endpoint forms the start of the next wire), the
chromosome consists of

In
the original crooked-wire GA optimization (see Section

Using a genetic algorithm, Linden produced a 7-wire
antenna with unusual shape that had a radiation pattern that varied by less
than 4 dB over the desired angles. This antenna, with a cost

Linden's GA optimized crooked-wire antenna with

The performance of the genetic programming approach was evaluated by applying it to the crooked-wire problem. Linden's original simulations used a population of 500 and evolved for 50 generations, or 25000 fitness evaluations. For our genetic programming system using the same population and running for the same number of generations, complete optimization time was around 5 hours on a single computer. We performed each optimization 30 times because, due to the randomness inherent in the genetic algorithm, each run produces a different design from the last but with similar performance.

Our GP algorithm attempts to maximize fitness, so a
modified fitness function,

Using the modified fitness

Figure

A GP-optimized seven-wire antenna with

Best individual cost versus generation for single-branch GP optimization.

Our structure generation language (see Section

The optimization was then run with a population of 500
for 50 generations, while still restricting the design to a total of seven
wires. For thirty optimization runs, after 50 generations the best individual
from each run ranged from

A GP-optimized multibranch antenna with

For a given computational effort, the grammar of the structure generation language can clearly influence the performance of the GP optimization.

We finally allowed an arbitrary number of wires in the
simulation. This was achieved by removing the penalty function

Coordinates (in mm) for the C = 20 GP-optimized antenna. All wires have a radius of 1 mm.

Wire | Start (mm) | End (mm) | ||||
---|---|---|---|---|---|---|

(tag) | ||||||

1 | 0 | 0 | 0 | −2.1 | 3.8 | 17.2 |

2 | −2.1 | 3.8 | 17.2 | 8.6 | −11 | 12 |

3 | 8.6 | −11 | 12 | 17.1 | 15.1 | |

4 | 8.6 | −11 | 12 | 2.4 | −5.3 | 7.8 |

5 | 2.4 | −5.3 | 7.8 | 27 | −10.3 | 20.6 |

6 | 8.6 | −11 | 12 | −3.4 | −7.6 | 18.3 |

7 | −3.4 | −7.6 | 18.3 | 26.8 | 0.9 | 9.9 |

8 | 8.6 | −11 | 12 | 3.6 | −1 | 6.7 |

9 | 3.6 | −1 | 6.7 | 29 | 15.1 | 3.9 |

10 | 29 | 15.1 | 3.9 | 30.8 | −22.2 | 8.6 |

A GP-optimized complex-geometry antenna with

We have carried out a direct comparison of GP against
a fixed-length chromosome GA approach. The results of this comparison,
described in Section

In addition, the flexibility of the GP approach allows
for a richer variety of antenna geometries and we find, for the crooked-wire
problem, that this flexibility enables the evolution of much better designs.
When we relaxed the seven-wire requirement of Linden's original crooked wire
geometry, our best design, described in Section

A natural extension of this work is to use
automatically defined functions (ADF-s). This enriches the grammar of the GP
language to include the definition and calling of functions. For many problems,
the use of ADF's reduces the computational effort required to achieve a
solution of a given fitness [