Hands-On Genetic Algorithms with Python: Apply genetic algorithms to solve real-world AI and machine learning problems

Hands-On Genetic Algorithms with Python

Copyright © 2024 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

Group Product Manager: Ali Abidi

Publishing Product Manager: Tejashwini R

Book Project Manager: Shambhavi Mishra

Content Development Editor: Joseph Sunil

Technical Editor: Rahul Limbachiya

Copy Editor: Safis Editing

Proofreader: Joseph Sunil

Indexer: Rekha Nair

Production Designer: Aparna Bhagat

Senior DevRel Marketing Executive: Vinishka Kalra

First published: January 2020

Second Edition: June 2024

Production reference: 1140624

Published by Packt Publishing Ltd.

Grosvenor House

11 St Paul’s Square

Birmingham

B3 1RB, UK.

ISBN 978-1-80512-379-8

www.packtpub.com

This book is dedicated to the loving memory of my parents, Gideon and Devorah Wirsansky. Your love and wisdom continue to guide and inspire me throughout my journey.

– Eyal Wirsansky

Contributors

About the author

Eyal Wirsansky is a senior data scientist, a seasoned software engineer, a leader in the technology community, and an artificial intelligence researcher.

In his graduate studies, he concentrated on genetic algorithms and neural networks, leading to the creation of an innovative supervised machine learning algorithm that blends these two approaches.

With a career spanning over 25 years, Eyal has pioneered developments in Voice over IP, healthcare, software development tools, and drone technology. He is currently a key member of the data platform team at Gradle, Inc., focusing on developing machine learning-driven features to boost developer productivity.

Beyond his professional endeavors, Eyal serves as an adjunct professor at Jacksonville University, where he teaches artificial intelligence. He leads the Jacksonville, Florida Java User Group and the AI for Enterprise virtual user group and is the author behind the developer-focused artificial intelligence blog, AI4Java.

About the reviewer

Ali Oztas is a data scientist with 5.5 years of experience mostly specializing in Natural Language Processing and Time Series. His masters’ thesis was about runtime analysis of genetic algorithms, which is where he was introduced to the main topic of the book. Currently, he is working with Large Language Models and discovering new ways to use them.

Table of Contents

Preface

Part 1: The Basics of Genetic Algorithms

1

An Introduction to Genetic Algorithms

What are genetic algorithms?

Darwinian evolution

The genetic algorithms analogy

The theory behind genetic algorithms

The schema theorem

Differences from traditional algorithms

Population-based

Genetic representation

Fitness function

Probabilistic behavior

Advantages of genetic algorithms

Global optimization

Handling complex problems

Handling a lack of mathematical representation

Resilience to noise

Parallelism

Continuous learning

Limitations of genetic algorithms

Special definitions

Hyperparameter tuning

Computationally intensive

Premature convergence

No guaranteed solution

Use cases for genetic algorithms

Summary

Further reading

2

Understanding the Key Components of Genetic Algorithms

The basic flow of a genetic algorithm

Creating the initial population

Calculating the fitness

Applying selection, crossover, and mutation

Checking the stopping conditions

Selection methods

Roulette wheel selection

Stochastic universal sampling

Rank-based selection

Fitness scaling

Tournament selection

Crossover methods

Single-point crossover

Two-point and k-point crossover

Uniform crossover

Crossover for ordered lists

Mutation methods

Flip-bit mutation

Swap mutation

Inversion mutation

Scramble mutation

Real-coded genetic algorithms

Blend crossover

Simulated binary crossover

Real mutation

Understanding elitism

Niching and sharing

Serial niching versus parallel niching

The art of solving problems using genetic algorithms

Summary

Further reading

Part 2: Solving Problems with Genetic Algorithms

3

Using the DEAP Framework

Technical requirements

Python version

Using a virtual environment

Installing the necessary libraries

Introduction to DEAP

Using the creator module

Creating the Fitness class

Creating the Individual class

Using the Toolbox class

Creating genetic operators

Creating the population

Calculating the fitness

The OneMax problem

Solving the OneMax problem with DEAP

Choosing the chromosome

Calculating the fitness

Choosing the genetic operators

Setting the stopping condition

Implementing with DEAP

Using built-in algorithms

The Statistics object

The algorithm

The logbook

Running the program

Adding the hall of fame feature

Experimenting with the algorithm’s settings

Population size and number of generations

Crossover operator

Mutation operator

Selection operator

Summary

Further reading

4

Combinatorial Optimization

Technical requirements

Search problems and combinatorial optimization

Solving the knapsack problem

The Rosetta Code knapsack 0-1 problem

Solution representation

Python problem representation

Genetic algorithm solution

Solving the TSP

TSPLIB benchmark files

Solution representation

Python problem representation

Genetic algorithm solution

Improving the results with enhanced exploration and elitism

Solving the VRP

Solution representation

Python problem representation

Genetic algorithm solution

Summary

Further reading

5

Constraint Satisfaction

Technical requirements

Constraint satisfaction in search problems

Solving the N-Queens problem

Solution representation

Python problem representation

Genetic algorithms solution

Solving the nurse scheduling problem

Solution representation

Hard constraints versus soft constraints

Python problem representation

Genetic algorithms solution

Solving the graph coloring problem

Solution representation

Using hard and soft constraints for the graph coloring problem

Python problem representation

Genetic algorithms solution

Summary

Further reading

6

Optimizing Continuous Functions

Technical requirements

Chromosomes and genetic operators for real numbers

Using DEAP with continuous functions

Optimizing the Eggholder function

Optimizing the Eggholder function with genetic algorithms

Improving the speed with an increased mutation rate

Optimizing Himmelblau’s function

Optimizing Himmelblau’s function with genetic algorithms

Using niching and sharing to find multiple solutions

Simionescu’s function and constrained optimization

Constrained optimization with genetic algorithms

Optimizing Simionescu’s function using genetic algorithms

Using constraints to find multiple solutions

Summary

Further reading

Part 3: Artificial Intelligence Applications of Genetic Algorithms

7

Enhancing Machine Learning Models Using Feature Selection

Technical requirements

Supervised machine learning

Classification

Regression

Supervised learning algorithms

Feature selection in supervised learning

Selecting the features for the Friedman-1 regression problem

Solution representation

Python problem representation

Genetic algorithms solution

Selecting the features for classifying the Zoo dataset

Python problem representation

Genetic algorithms solution

Summary

Further reading

8

Hyperparameter Tuning of Machine Learning Models

Technical requirements

Hyperparameters in machine learning

Hyperparameter tuning

The Wine dataset

The adaptive boosting classifier

Tuning the hyperparameters using conventional versus genetic grid search

Testing the classifier’s default performance

Running the conventional grid search

Running the genetic-algorithm-driven grid search

Tuning the hyperparameters using a direct genetic approach

Hyperparameter representation

Evaluating the classifier accuracy

Tuning the hyperparameters using genetic algorithms

Dedicated libraries

Summary

Further reading

9

Architecture Optimization of Deep Learning Networks

Technical requirements

ANNs and DL

MLP

DL and convolutional NNs

Optimizing the architecture of a DL classifier

The Iris flower dataset

Representing the hidden layer configuration

Evaluating the classifier’s accuracy

Optimizing the MLP architecture using genetic algorithms

Combining architecture optimization with hyperparameter tuning

Solution representation

Evaluating the classifier’s accuracy

Optimizing the MLP’s combined configuration using genetic algorithms

Summary

Further reading

10

Reinforcement Learning with Genetic Algorithms

Technical requirements

Reinforcement learning

Genetic algorithms and reinforcement learning

Gymnasium

The env interface

Solving the MountainCar environment

Solution representation

Evaluating the solution

The Python problem representation

Genetic algorithms solution

Solving the CartPole environment

Controlling the CartPole with a neural network

Solution representation and evaluation

The Python problem representation

A genetic algorithm solution

Summary

Further reading

11

Natural Language Processing

Technical requirements

Understanding NLP

Word embeddings

Word embeddings and genetic algorithms

Finding the mystery word using genetic algorithms

Python implementation

Document classification

N-grams

Selecting a subset of n-grams

Using genetic algorithms to search for a fixed-size subset

Python implementation

Summary

Further reading

12

Explainable AI, Causality, and Counterfactuals with Genetic Algorithms

Technical requirements

Unlocking the black box – XAI

Unraveling cause and effect – causality in AI

What-if scenarios – counterfactuals

Genetic algorithms in counterfactual analysis – navigating alternative scenarios

The German Credit Risk dataset

Exploring counterfactual scenarios for credit risk prediction

The Applicant class

The CreditRiskData class

Counterfactuals with genetic algorithms

The genetic algorithm solution

More what-if scenarios

Extending to other datasets

Summary

Further reading

Part 4: Enhancing Performance with Concurrency and Cloud Strategies

13

Accelerating Genetic Algorithms – the Power of Concurrency

Technical requirements

Long runtimes in real-world genetic algorithms

Parallelizing genetic algorithms

Multithreading

Multiprocessing

Back to the OneMax problem

A baseline benchmark program

Simulating computational intensity

Multiprocessing using the Pool class

Increasing the number of processes

Multiprocessing using the SCOOP library

Distributed computing with SCOOP

Summary

Further reading

14

Beyond Local Resources – Scaling Genetic Algorithms in the Cloud

Technical requirements

The next level in genetic algorithm performance –embracing a client-server architecture

Implementing a client-server model

Using a separate environment

Revisiting the One-Max problem, yet again

Creating the server component

Creating the client component

Running the asynchronous client

Using a production-grade app server

Using the Gunicorn server

Using the Waitress server

Breaking out of the box

Reaching for the sky with cloud computing

AWS Lambda and API Gateway – a winning combination

Serverless Python with Zappa

Deploying the server module to the Lambda service

Running the client with the Lambda-based server

Undeploying the server

Summary

Further reading

Part 5: Related Technologies

15

Evolutionary Image Reconstruction with Genetic Algorithms

Technical requirements

Reconstructing images with polygons

Image processing in Python

Python image processing libraries

Drawing images with polygons

Measuring the difference between images

Using genetic algorithms to reconstruct images

Solution representation and evaluation

Python problem representation

Genetic algorithm implementation

Image reconstruction results

Reducing the triangle count

Other experiments

Summary

Further reading

16

Other Evolutionary and Bio-Inspired Computation Techniques

Technical requirements

Evolutionary computation and bio-inspired computing

Genetic programming

Genetic programming example – even parity check

Genetic programming implementation

NEAT

NEAT example – even parity check

NEAT implementation

Particle swarm optimization

PSO example – function optimization

Particle swarm optimization implementation

Other related techniques

Evolution strategies

Differential evolution

Ant colony optimization

Artificial immune systems

Artificial life

Summary

Further reading

Index

Other Books You May Enjoy

Preface

Welcome to the exciting world of genetic algorithms and their application in artificial intelligence (AI), presented through the lens of Python programming. This book is a comprehensive guide that takes you from the fundamental principles of genetic algorithms to their powerful applications in AI, leveraging the practicality and simplicity of Python.

In the realm of computer science and problem-solving, genetic algorithms stand out for their unique approach to finding solutions. Mirroring the process of natural selection, these algorithms develop answers to problems in a way that’s both fascinating and effective. Our journey begins with laying down the theoretical foundations of these algorithms, detailing core components and functionalities such as selection, crossover, and mutation. This sets the stage for advanced concepts and practical applications.

As we journey from theoretical foundations to practical implementations, we transition to tackling real-world problems using Python. These range from simple puzzles to complex optimization challenges. The focus then intensifies on AI applications, where genetic algorithms become pivotal tools in enhancing machine learning models, solving intricate reinforcement learning tasks, and delving into natural language processing and the emerging field of explainable AI.

Recognizing the importance of performance optimization in algorithmic applications, this book embarks on using concurrency and cloud computing to enhance the efficiency, speed, and scalability of genetic algorithms.

Our journey culminates in the fascinating realm of image reconstruction and other biologically inspired algorithms, revealing the unexpected and creative potential of genetic algorithms.

By the end of this journey, you will have gained a robust understanding of genetic algorithms, empowered with hands-on experience in applying them across various domains. This book is not just an academic exploration but also a practical guide that will prepare you to implement genetic algorithms in real-world scenarios effectively.

Whether you are a student, a professional in the field of AI, or just a curious mind eager to explore the fascinating intersection of biology and computing, this book promises to be a valuable resource. Join us as we unlock the potential of genetic algorithms in the dynamic field of AI.

Who this book is for

This book is for data scientists, software developers, and AI enthusiasts eager to break into genetic algorithms and apply them to real-world, intelligent applications as quickly as possible. It’s crafted for those who wish to master genetic algorithms swiftly and effectively.

The primary audience for this book comprises three distinct groups:

Data scientists: This book is a treasure trove for data scientists looking to integrate genetic algorithms into their toolbox. You will learn how to apply these algorithms to complex data problems, enhancing your predictive models and analytical capabilities.

Software developers: As a software developer, this book serves as a gateway to integrating genetic algorithms into software solutions. Whether you’re involved in developing AI applications, optimization tools, or complex system simulations, understanding how to implement and fine-tune genetic algorithms can significantly enhance the functionality and efficiency of your software. The book offers real-world examples and step-by-step guides, helping you to seamlessly incorporate these algorithms into your projects.

AI enthusiasts: If you are passionate about AI and keen on expanding your knowledge in this domain, this book will be particularly beneficial. You will get a thorough grounding in genetic algorithms, an essential part of AI, and a hands-on approach to applying them in various AI-driven applications. The skills and knowledge acquired will be a significant stepping stone in your journey toward becoming an AI expert.

What this book covers

Chapter 1

, An Introduction to Genetic Algorithms, introduces the basics and theory of genetic algorithms, drawing parallels with Darwinian evolution. It contrasts these algorithms with traditional ones, discussing their advantages, limitations, and practical applications. The chapter concludes by highlighting scenarios where genetic algorithms are particularly effective.

Chapter 2

, Understanding the Key Components of Genetic Algorithms, provides a comprehensive exploration of genetic algorithms, starting with an outline of a genetic algorithm’s basic flow. It then explores its core components and progresses to examine real coded genetic algorithms while covering advanced concepts such as elitism, niching, and sharing. It concludes with insights into the art of problem-solving using genetic algorithms.

Chapter 3

, Using the DEAP Framework, introduces the DEAP framework (a versatile tool for solving real-world problems with genetic algorithms), guides you through its main modules, and demonstrates how to construct essential genetic algorithm components. This is demonstrated by programming a solution to the OneMax problem, followed by experiments with different settings of the genetic algorithm, revealing the impact of various modifications.

Chapter 4

, Combinatorial Optimization, explores the application of genetic algorithms in combinatorial optimization while providing Python-based solutions using the DEAP framework. Key optimization problems covered include the Knapsack, Traveling Salesman, and Vehicle Routing problems. Additionally, the chapter discusses genotype-to-phenotype mapping and the balance between exploration and exploitation.

Chapter 5

, Constraint Satisfaction, starts by defining the concept of constraint satisfaction and its relevance to search problems and combinatorial optimization. It then presents practical examples of these problems and their solutions using the DEAP framework. Key problems explored include the N-Queen, nurse scheduling, and graph coloring problems. Additionally, it explores the distinction between hard and soft constraints and their integration into the solution process.

Chapter 6

, Optimizing Continuous Functions, explores the application of genetic algorithms in optimizing continuous search spaces, using real number-based genetic operators and DEAP framework tools. This chapter presents Python-based solutions for optimizing functions such as the Eggholder, Himmelblau’s, and Simionescu’s functions, incorporating techniques such as niching and sharing, and addressing constraints.

Chapter 7

, Enhancing Machine Learning Models Using Feature Selection, explains the use of genetic algorithms to enhance supervised machine learning models through feature selection. It begins with an introduction to machine learning, focusing on regression and classification tasks, and discusses the benefits of feature selection in improving model performance. The chapter then demonstrates the use of genetic algorithms in identifying key features in a test regression problem and in optimizing a classification model using the Zoo dataset by isolating the most effective features.

Chapter 8

, Hyperparameter Tuning of Machine Learning Models, explores the enhancement of supervised machine learning models through genetic algorithm-based hyperparameter tuning. After introducing hyperparameter tuning and the grid search concept in machine learning, it uses the Wine dataset and the adaptive boosting classifier as case studies. The chapter compares conventional grid search with a genetic algorithm-driven grid search for hyperparameter tuning, concluding with an attempt to further refine results using a direct genetic algorithm approach.

Chapter 9

, Architecture Optimization of Deep Learning Networks, focuses on enhancing artificial neural network-based models through genetic algorithm-driven optimization of network architecture. It begins with an introduction to neural networks and deep learning, followed by a case study using the Iris dataset and the Multilayer Perceptron classifier. The chapter demonstrates network architecture optimization through a genetic algorithm-based solution and extends this approach to include simultaneous optimization of network architecture and model hyperparameters.

Chapter 10

, Reinforcement Learning with Genetic Algorithms, illustrates the application of genetic algorithms in reinforcement learning, using two benchmark environments from the Gymnasium toolkit. It begins with an overview of reinforcement learning and an introduction to the Gymnasium toolkit and its Python interface. The focus then shifts to tackling the MountainCar and CartPole environments, developing genetic algorithm-based solutions for these specific challenges.

Chapter 11

, Natural Language Processing, dives into the intersection of genetic algorithms and NLP. It introduces NLP and word embeddings and demonstrates their use in a Semantle-like mystery-word game where a genetic algorithm guesses the mystery word. The chapter also examines n-grams and document classification, employing genetic algorithms to select a concise and efficient feature subset, thereby enhancing understanding of the classifier’s functionality.

Chapter 12

, Explainable AI, Causality, and Counterfactuals with Genetic Algorithms, investigates the use of genetic algorithms for generating what if scenarios in explainable AI and causality, emphasizing counterfactual analysis. It introduces these fields and the concept of counterfactuals, followed by a practical application of the German Credit Risk dataset using genetic algorithms, uncovering valuable insights through counterfactual analysis.

Chapter 13

, Accelerating Genetic Algorithms – the Power of Concurrency, explores enhancing genetic algorithms’ performance using concurrency, focusing on multiprocessing. It discusses the benefits of applying concurrency and demonstrates it through Python’s built-in functionalities as well as an external library. Various multiprocessing approaches are tested on a CPU-intensive variant of the OneMax problem, evaluating the performance improvements achieved.

Chapter 14

, Beyond Local Resources – Scaling Genetic Algorithms in the Cloud, expands on enhancing genetic algorithm performance through a client-server model, using asynchronous I/O and cloud-based server computations on AWS Lambda. It discusses the split-architecture benefits, applies it to the OneMax problem, and guides through deploying a Flask server and an asyncio client, culminating in AWS Lambda deployment to showcase cloud-enhanced genetic algorithm efficiency.

Chapter 15

, Evolutionary Image Reconstruction with Genetic Algorithms, explores genetic algorithms in image processing, focusing on reconstructing images with semi-transparent polygons. It starts with an overview of image processing in Python and explains creating images from scratch with polygons and calculating image differences. It concludes with developing a genetic algorithm-based program to reconstruct a famous painting using polygons, examining the evolutionary process and results.

Chapter 16

, Other Evolutionary and Bio-Inspired Computation Techniques, introduces a variety of problem-solving and optimization techniques related to genetic algorithms. It covers genetic programming, NeuroEvolution of Augmenting Topologies (NEAT), and particle swarm optimization, demonstrating each through problem-solving Python programs. The chapter concludes with an overview of several other related computation paradigms.

To get the most out of this book

To maximize the benefits of this book, having a working knowledge of Python is essential. This prerequisite ensures that you can seamlessly understand and apply the concepts and examples provided. Whether you’re looking to enhance your current role or transition into a new area of expertise, this book offers the practical knowledge and insights needed to succeed in the fascinating world of genetic algorithms.

If you are using the digital version of this book, we advise you to type the code yourself or access the code from the book’s GitHub repository (a link is available in the next section). Doing so will help you avoid any potential errors related to the copying and pasting of code.

Download the example code files

You can download the example code files for this book from GitHub at https://github.com/PacktPublishing/Hands-On-Genetic-Algorithms-with-Python-Second-Edition

. If there’s an update to the code, it will be updated in the GitHub repository.

We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/

. Check them out!

Conventions used

There are a number of text conventions used throughout this book.

Code in text: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: The server is built using Flask, while the client leverages Python’s asyncio library for asynchronous operations.

A block of code is set as follows:

def busy_wait(duration):

    current_time = time.time()

    while (time.time() < current_time + duration):

        pass

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

@app.route(/)

def welcome():

    return

Welcome to our Fitness Evaluation Server!

Any command-line input or output is written as follows:

pip install Flask

Bold: Indicates a new term, an important word, or words that you see onscreen. For instance, words in menus or dialog boxes appear in bold. Here is an example: Clicking on the function’s name will bring us to the Function overview screen.

Tips or important notes

Appear like this.

Get in touch

Feedback from our readers is always welcome.

General feedback: If you have questions about any aspect of this book, email us at [email protected]

and mention the book title in the subject of your message.

Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit www.packtpub.com/support/errata

and fill in the form.

Piracy: If you come across any illegal copies of our works in any form on the internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected]

with a link to the material.

If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit authors.packtpub.com

.

Share Your Thoughts

Once you’ve read Hands-On Genetic Algorithms with Python, Second Edition, we’d love to hear your thoughts! Please click here to go straight to the Amazon review page

for this book and share your feedback.

Your review is important to us and the tech community and will help us make sure we’re delivering excellent quality content.

Download a free PDF copy of this book

Thanks for purchasing this book!

Do you like to read on the go but are unable to carry your print books everywhere?

Is your eBook purchase not compatible with the device of your choice?

Don’t worry, now with every Packt book you get a DRM-free PDF version of that book at no cost.

Read anywhere, any place, on any device. Search, copy, and paste code from your favorite technical books directly into your application. 

The perks don’t stop there, you can get exclusive access to discounts, newsletters, and great free content in your inbox daily

Follow these simple steps to get the benefits:

Scan the QR code or visit the link below

https://packt.link/free-ebook/978-1-80512-379-8

Submit your proof of purchase

That’s it! We’ll send your free PDF and other benefits to your email directly

Part 1: The Basics of Genetic Algorithms

In this section, you will be introduced to the key concepts of genetic algorithms, beginning with the Darwinian evolution analogy, basic principles, and theoretical foundations. We will then dive deeper into the components and implementation details of these algorithms, exploring their flow and various methods of selection, crossover, and mutation. The section also focuses on real-coded genetic algorithms and advanced concepts such as elitism, niching, and sharing, all setting the stage for problem-solving in subsequent sections.

This part contains the following chapters:

Chapter 1

, An Introduction to Genetic Algorithms

Chapter 2

, Understanding the Key Components of Genetic Algorithms

1

An Introduction to Genetic Algorithms

Drawing its inspiration from Charles Darwin’s theory of natural evolution, one of the most fascinating techniques for problem-solving is the algorithm family suitably named evolutionary computation. Within this family, the most prominent and widely used branch is known as genetic algorithms. This chapter is the beginning of your journey to mastering this extremely powerful, yet extremely simple, technique.

In this chapter, we will introduce genetic algorithms and their analogy to Darwinian evolution before diving into their basic principles of operation and their underlying theory. We will then go over the differences between genetic algorithms and traditional ones and cover the advantages and limitations of genetic algorithms and their uses. We will conclude by reviewing cases where the use of a genetic algorithm may prove beneficial.

In this introductory chapter, we will cover the following topics:

What are genetic algorithms?

The theory behind genetic algorithms

Differences between genetic algorithms and traditional algorithms

Advantages and limitations of genetic algorithms

When to use genetic algorithms

What are genetic algorithms?

Genetic algorithms are a family of search algorithms that are inspired by the principles of evolution in nature. By imitating the process of natural selection and reproduction, genetic algorithms can produce high-quality solutions for various problems involving search, optimization, and learning. At the same time, their analogy to natural evolution allows genetic algorithms to overcome some of the hurdles that are encountered by traditional search and optimization algorithms, especially for problems with a large number of parameters and complex mathematical representations.

In the rest of this section, we will review the basic ideas of genetic algorithms, as well as their analogy to the evolutionary processes transpiring in nature.

Darwinian evolution

Genetic algorithms implement a simplified version of the Darwinian evolution that takes place in nature. The principles of the Darwinian evolution theory can be summarized using the following principles:

The principle of variation: The traits (attributes) of individual specimens belonging to a population may vary. As a result, the specimens differ from each other to some degree, for example, in their behavior or appearance.

The principle of inheritance: Some traits are consistently passed on from specimens to their offspring. As a result, offspring resemble their parents more than they resemble unrelated specimens.

The principle of selection: Populations typically struggle for resources within their given environment. The specimens possessing traits that are better adapted to the environment will be more successful at surviving and will also contribute more offspring to the next generation.

In other words, evolution maintains a population of individual specimens that vary from each other. Those who are better adapted to their environment have a greater chance of surviving, breeding, and passing their traits to the next generation. This way, as generations go by, species become more adapted to their environment and the challenges presented to them.

An important enabler of evolution is crossover or recombination – where offspring are created with a mix of their parents’ traits. Crossover helps in maintaining the diversity of the population and in bringing together better traits over time. In addition, mutations – random variations in traits – can play a role in evolution by introducing changes that can result in a leap forward every once in a while.

The genetic algorithms analogy

Genetic algorithms seek to find the optimal solution for a given problem, whereas Darwinian evolution maintains a population of individual specimens. Genetic algorithms maintain a population of candidate solutions, called individuals, for that given problem. These candidate solutions are evaluated iteratively and used to create a new generation of solutions. Those who are better at solving this problem have a greater chance of being selected and passing their qualities to the next generation of candidate solutions. This way, as generations go by, candidate solutions get better at solving the problem at hand.

In the following sections, we will describe the various components of genetic algorithms that enable this analogy for Darwinian evolution.

Genotype

In nature, breeding, reproduction, and mutation are facilitated via the genotype – a collection of genes that are grouped into chromosomes. If two specimens breed to create offspring, each chromosome of the offspring will carry a mix of genes from both parents. Mimicking this concept, in the case of genetic algorithms, each individual is represented by a chromosome representing a collection of genes. For example, a chromosome can be expressed as a binary string, where each bit represents a single gene:

Figure 1.1: Simple binary-coded chromosome

Figure 1.1 shows an example of one such binary-coded chromosome, representing one particular individual.

Population

At any point in time, genetic algorithms maintain a population of individuals – a collection of candidate solutions for the problem at hand. Since each individual is represented by some chromosome, this population of individuals can be seen as a collection of such chromosomes:

Figure 1.2: The population of individuals represented by binary-coded chromosomes

The population continually represents the current generation and evolves when the current generation is replaced by a new one.

Fitness function

At each iteration of the algorithm, the individuals are evaluated using a fitness function (also called the target function). This is the function we seek to optimize or the problem we are attempting to solve.

Individuals who achieve a better fitness score represent better solutions and are more likely to be chosen to reproduce and be represented in the next generation. Over time, the quality of the solutions improves, the fitness values increase, and the process can stop once a solution is found with a satisfactory fitness value.

Selection

After calculating the fitness of every individual in the population, a selection process is used to determine which of the individuals in the population will get to reproduce and create the offspring that will form the next generation.

This selection process is based on the fitness score of the individuals. Those with higher score values are more likely to be chosen and pass their genetic material to the next generation.

Individuals with low fitness values can still be chosen but with a lower probability. This way, their genetic material is not completely excluded, maintaining genetic diversity.

Crossover

To create a pair