Genetic programming (GP) is a systematic, domain-independent method for getting computers to solve problems automatically starting from a high-level statement of what needs to be done. Using ideas from natural evolution, GP starts from an ooze of random computer programs, and progressively refines them through processes of mutation and sexual recombination, until high-fitness solutions emerge. All this without the user having to know or specify the form or structure of solutions in advance. GP has generated a plethora of human-competitive results and applications, including novel scientific discoveries and patentable inventions. This unique overview of this exciting technique is written by three of the most active scientists in GP. See www.gp-field-guide.org.uk for more information on the book.
The year is 2024, in the age of deep learning, convolutional neural networks, transformer architectures, etc., genetic programming isn't the rage anymore, and I don't see any hype around it. This book, published in March 2008, somehow ended up on my shelf in 2009, and I finally had the opportunity and time to read it. I found it the perfect introduction to the field: very well-written, with just enough theory and practical advice for people without any prior experience in this field.
The authors gently introduce the reader to the powerful programming ideas inspired by biological evolutionary mechanisms, applying concepts such as mutation and crossover to programming constructs. Each idea is very simple in itself, easy to explain to people who has some programming background, yet, their combination end up in not very long, but very interesting, powerful optimization programs.
I also appreciate the fact that authors warn the reader about pitfalls of genetic programming and important points you should be concerned with when implementing genetic programming in your favorite programming language. Moreover, the chapter about illustrative successful applications of genetic programming is definitely inspiring, seeing how you can optimize not only software but even hardware is striking. There's also a reference to automatically creating a sorting network, which reminded me of "Let Over Lambda" (another fine and mind-expanding book!).
The authors also include a genetic programming system, a single-file Java program called TinyGP to demonstrate what they described so far: they use TinyGP by feeding it the output of sine function in an interval, and let TinyGP work its way by "evolving" a program that is an approximation of that function. A toy example, and a very simple one at that, but therefore relatively easy to understand and build upon; making it pedagogically powerful. The fact that they selected Java as their implementation language turned out to be a wise choice, too, because even after 16 years, the code compiles as is, without a single change, thanks to the Java backward compatibility.
I created code repository on GitHub and copied TinyGP, because the URLs in the published version of the book doesn't work anymore:
I also created another code repository to modernize the Java implementation, and conduct further experiments and research departing from the original implementation:
If you are curious about the fundamentals of genetic programming and evolving computer programs subject to some constraints, I can easily recommend this book as a solid introduction with a well-explained working implementation in Java.
Great overview of Genetic Programming field. A very interesting alternative to Gradient Descent and Neural Networks in general. https://github.com/DEAP/deap is a nice framework to play with concepts from a book.
The "Field Guide" covers the basics of genetic programming, which is a sub-topic of genetic algorithms. A wide variety of techniques and approaches are mentioned in passing, but only Lisp-like systems are described in detail.
+ Starts with, then builds upon, basic concepts. + Written in plain English with minimal academic dressing + When a full description is offered, it is done so with enough detail to guide building an implementation. + Immense bibliography + Full code (Java) for a small genetic programming library
- Only one complete example. - Applications are hinted at, but are not described fully, much less shown.
Extremely unbalanced in terms of content. The basics of evolutionary algorithms are properly explained and covered. However, the book gives too much attention to tree-based GP and does not accomplish what it promises, i.e., of being a true "field guide". For instance, sections dedicated to more complex or different forms of GP such as Linear GP are much too short -- around 3 to 4 pages long. If you are keen on learning about tree-based GP, then read the book. If you are looking for a holistic view, or something a bit different from standard tree-based GP, then choose something else.
Halfway decent introduction to genetic programming but a lot of the material is a very terse literature review that explains little and often leaves the reader in the dark. (My favorite exemplar phrase was: "To better cover the Pareto front, niching via fitness sharing (Goldberg, 1989) was also performed.") Start here maybe but possibly finish elsewhere.
Great and compact introduction to the field of Genetic Programming. Lots of useful references. Reads like some type of summary of different ideas and implementations previously done.
I have read it while working on a research project and it has been a useful guide to point into some ideas. But, is not a book that provides algorithm implementations or refined tricks. However, is not its intention either. That is why, I'd recommend it if you are working with GPs or want to know just a bit about them.
Coolest subject ever. Think about using distributed human systems as fitness function.
Quotes:
"In chapter 8 we review systems where, instead of using mutation and recombination to create new programs, they are simply generated randomly according to a probability distribution which itself evolves."
"Note that tournament selection only looks at which program is better than another. It does not need to know how much better. This effectively automatically rescales fitness, so that the selection pressure on the population remains constant. Thus, a single extraordinarily good program cannot immediately swamp the next generation with its children; if it did, this would lead to a rapid loss of diversity with potentially disastrous consequences for a run."
"1. What is the terminal set? 2. What is the function set? 3. What is the fitness measure? 4. What parameters will be used for controlling the run? 5. What will be the termination criterion, and what will be designated the result of the run?"
"Fitness can be measured in many ways. For example, in terms of: the amount of error between its output and the desired output; the amount of time(fuel, money,etc.) required to bring a system to desired target state; the accuracy of the program in recognizing patters or classifying objects; the payoff that a game-playing program produces; the compliance of a structure with user-specified design criteria."
"The most important control parameter is the population size. Other control parameters include the probabilities of performing the genetic operations, the maximum size for programs and other details of the run."
"Typically, the number of generations is limited to between ten and fifty."
"The most common way of starting a GP run from an informed non-random point is seeding the initial population with an individual which, albeit not a solution, is thought to be a good starting point."
"Another alternative is to use co-evolution with multiple populations, where the fitness of individuals in one population depends on the behavior of individuals in other populations."
This entire review has been hidden because of spoilers.
I didn't get what I wanted out of the book, but I got exactly what I needed. This is a good high-level survey of the field with enough detail to be explanatory but not so much detail that the reader gets swamped.
The book has an extensive bibliography, solid suggestions for further study, and properly cites the volumes of academic work discussed.
The ability to read java or C will be helpful to the reader. Some fairly serious math is discussed as well, but I don't think it would get in the way of the casual reader.
Not enough here to call it a how-to guide, but more than enough to start a serious self-study of the topic if that is your goal.
I enjoyed reading this introduction to genetic programming.
The first chapter describes the basics of genetic programming very thoroughly, easy to understand and a lot of clear explanation.
In contrast, the second chapter describes many advanced techniques very shortly. Sometimes I only got to know that a certain technique 'exists', but no description how it works. I wish there was more explanation. However, references are always given to extra resources.
Chapter 3 contains examples of applications of genetic programming.