Genetic programming is an optimization technique inspired by biological evolution that uses techniques like mutation, crossover, fitness functions and multiple generations to evolve programs that can solve complex problems. It works by initializing a random population of computer programs and then applying genetic operations to the fittest programs each generation to evolve increasingly better solutions over time without needing human guidance. Common applications of genetic programming include automatic programming, symbolic regression, data modeling, engineering design, game strategies and more.

1. Genetic programing

2. • Optimization strategy that mimic natural
selection
• Survival of the fittest
• “Select The Best, Discard The Rest”

3. • .

4. Genetic Algorithm
• Genetic Algorithm (GA) represents​ a subset of Ignite
Machine Learning APIs. GA is a method of solving
optimization problems by simulating the process of
biological evolution. GAs are excellent for searching
through large and complex data sets for an optimal
solution. Real world applications of GAs include automotive
design, computer gaming, robotics, investments,
traffic/shipment routing and more.
• All genetic operations such as Fitness Calculation,
Crossover, and Mutation are modeled as a ComputeTask for
distributive behavior. Also, these ComputeTasks leverage
Apache Ignite's Affinity Collocation to route ComputeJobs
to respective nodes where Chromosomes are stored.

5. The following diagram depicts the
architecture of Genetic Algorithms:

6. The following diagram depicts the
steps performed by Genetic Algorithm:

7. Usage Guide
• In order to begin using Genetic Algorithm, follow
these steps:
• Create a GAConfiguration
• Define the Gene and Chromosome
• Implement a fitness function
• Define terminate condition
• Evolve the population
• We will use a HelloWorldGAExaMPLE
• Our goal will be to derive the phrase: "HELLO
WORLD

8. • Define the Gene and Chromosome
• Next, we define our Gene. For our problem
domain, an optimal solution is the phrase
"HELLO WORLD". Since the discrete parts are
letters, we use Character to model our Gene.
Next, we need to initialize a Gene pool
of 27 Gene objects utilizing Characters. The
code below depicts this process.

9. • List<Gene> genePool = new ArrayList(); char[]
chars = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
'W', 'X', 'Y', 'Z', ' ' }; for (int i = 0; i <
chars.length; i++) { Gene gene = new
Gene(new Character(chars[i]));
genePool.add(gene); }
gaConfig.setGenePool(genePool);

11. • Create a GAConfiguration
• To begin, we create a GAConfiguration object.
This class is utilized to customize the behavior of
GA.
• Java
• ignite = Ignition.start("examples/config/example-
ignite.xml"); // Create GAConfiguration gaConfig
= new GAConfiguration();

18. Flow chart

19. • Genetic Programming (GP) is a type of
Evolutionary Algorithm (EA), a subset of
machine learning. EAs are used to discover
solutions to problems humans do not know
how to solve, directly. Free of human
preconceptions or biases, the adaptive nature
of EAs can generate solutions that are
comparable to, and often better than the best
human efforts.*

20. • Inspired by biological evolution and its fundamental
mechanisms, GP software systems implement an
algorithm that uses random mutation, crossover, a
fitness function, and multiple generations of evolution
to resolve a user-defined task.
• GP can be used to discover a functional relationship
between features in data (symbolic regression), to
group data into categories (classification), and to assist
in the design of electrical circuits, antennae, and
quantum algorithms. GP is applied to software
engineering through code synthesis, genetic
improvement, automatic bug-fixing, and in developing
game-playing strategies, … and more.

21. Types of GP include:
• Tree-based Genetic Programming
• Stack-based Genetic Programming
• Linear Genetic Programming (LGP)
• Grammatical Evolution
• Extended Compact Genetic Programming (ECGP)
• Cartesian Genetic Programming (CGP)
• Probabilistic Incremental Program Evolution (PIPE)
• Strongly Typed Genetic Programming (STGP)
• Genetic Improvement of Software for Multiple
Objectives (GISMO)

22. • Generational GP Algorithm
According to “A Field Guide to Genetic Programming”, there are
three basic steps to generational, Tree-based GP:
• Generate an initial, stochastic population.
• Iteratively perform selection, genetic operation, and evaluation:
– Evaluate each program (hypothesis) in the current population against
the given dataset and determine how well it performed, the value
recorded as a fitness score.
– Randomly select programs and compare their fitness scores.
– Apply one of three genetic operators to a copy of the leading program:
• reproduction
• mutation
• crossover
– … then move the program into the subsequent generation.

23. – Evaluate all programs (hypotheses) in each new generation.
• Repeat until the user-defined termination criteria are met.
• In GP, each generation is composed of a population of individual programs. Each
program is a mathematical function that when executed against the given data,
produces a value.
• The initial population (generation 0) is composed of randomly constructed
programs built upon user-defined arithmetic, trigonometric, or boolean operators,
and user-defined operands, variables which represent specific data parameters. The
quantity of programs in the initial and all subsequent populations is defined by the
user, and remains constant throughout the entire run.
• The entire initial population is evaluated, meaning each individual program is
executed against the given dataset, producing a single outcome per program. This
outcome is measured against the known solution, and recorded as the fitness
score. From this initial population, individuals programs are randomly selected for a
tournament in which the program with the best fitness score is copied into the
subsequent generation, following application of a genetic operator:

24. • ith reproduction, the program is copied without modification.
• With mutation, a portion of the program is randomly modified.
• With crossover, two programs are selected to contribute a portion
of their own code to a new program.
• Each mutation and crossover might result in a reduction or
improvement in the fitness score for each individual program. As
with the initial population, all programs in each new generation are
evaluated, randomly selected for a tournament, and then evolved
for the subsequent generation. Because those programs selected
exhibit the highest fitness score, their contribution to the next
generation enables an overall improvement. This process continues
until the user-defined termination criteria are met.

26. • Dynamic process control
• Optimization of induction rules
• Discovery of new connectivity topologies (NNs)
• Simulation of biological models of behavior
• Complex design of engineering structures
• Pattern recognition
• Scheduling, transportation and routing
• Layout and circuit design
• Telecommunication, graph-based problems