Join the Patreon to get Exclusive Downloads, Direct Support, Early Access, Voting Access, our Books for Free, and so much more!

Practical Evolutionary Algorithms

A practical book on Evolutionary Algorithms that teaches you the concepts and how they’re implemented in practice.

Get the book

Using a Framework with a Custom Objective Function

Dr. Shahin Rostami

2020-01-20

6 min read

Contents Chat Share Follow Download Source

Preamble
Introduction
The Custom Objective Function
Visualising Solutions in Objective Space
Conclusion

Get access to this section and more

Below is a featured selection from this section. You can access this notebook and more by getting the e-book on Practical Evolutionary Algorithms.

Preamble¶

In [1]:

# used to create block diagrams
%reload_ext xdiag_magic
%xdiag_output_format svg
    
import numpy as np                   # for multi-dimensional containers
import pandas as pd                  # for DataFrames
import plotly.graph_objects as go    # for data visualisation
import platypus as plat              # multi-objective optimisation framework

Introduction¶

When applying multi-objective optimisation algorithms to real-world problems, we will often need to implement the objective functions ourselves. This problem comes in two parts:

We need to design an objective function that correctly represents our real-world problem, taking the problem variables and producing the correct objective values;
We need to implement this objective function in a way that can work with our optimiser.

This comes down to passing the desired number of problem variables to a custom objective function and receiving the desired number of objective values.

In [2]:

%%blockdiag
{
    orientation = portrait
    "Problem Variables" -> "Objective Function" -> "Objective Values"
    "Objective Function" [color = '#ffffcc']
}

When preparing to implement multi-objective optimisation experiments, it's often more convenient to use a ready-made framework/library instead of programming everything from scratch. Many libraries and frameworks have been implemented in many different programming languages. With our focus on multi-objective optimisation, our choice is an easy one. We will choose Platypus which has a focus on multi-objective problems and optimisation.

Platypus is a framework for evolutionary computing in Python with a focus on multiobjective evolutionary algorithms (MOEAs). It differs from existing optimization libraries, including PyGMO, Inspyred, DEAP, and Scipy, by providing optimization algorithms and analysis tools for multiobjective optimization.

In this section, we will use the Platypus framework to apply the Non-dominated Sorting Genetic Algorithm II (NSGA-II)¹ to a custom objective function.

The Custom Objective Function¶

For our custom objective function we will look to implement F2 from Schaffer 1985², which is described as being a two-valued function of one variable. The function has been listed in Equation 1.

$$ \text{Minimize} = \begin{cases} f_{1}\left(x\right) = x^{2} \\ \tag{1} f_{2}\left(x\right) = \left(x-2\right)^{2} \\ \end{cases} $$

Let's implement this objective function using Python.

In [3]:

def schaffer_f1(x):
    f1 = x[0]**2
    f2 = (x[0]-2)**2
    return [f1, f2]

Now let's get this Python function into the Platypus Problem object which can be used during the evaluation stage of Platypus' optimisation process.

First, we will instantiate an instance of the Problem object, passing in the parameters $1$ and $2$, indicating that we want 1 problem variable and 2 objective values, respectively.

In [4]:

problem = plat.Problem(1, 2)

Next, we need to specify the type of the problem variables and their boundaries. In this case, we want real-valued problem variables between -10 and 10.

In [5]:

problem.types[:] = plat.Real(-10, 10)

Finally, we will assign our implementation of the Schaffer F1 function to our Problem object.

In [6]:

problem.function = schaffer_f1

Now we're ready to apply an optimisation algorithm to the problem. Let's create an instance of the NSGA-II optimiser, and pass in our problem object as a parameter for its configurations.

In [7]:

algorithm = plat.NSGAII(problem)

Now we can execute the optimisation process. Let's give the optimiser a budget of 10,000 function evaluations as a termination criterion. This may take some time to complete depending on your processor speed and the number of function evaluations.

In [8]:

algorithm.run(10000)

Finally, we can display the results. In this case, we will be printing the objective values for each solution in the final population of the above execution.

In [9]:

for solution in algorithm.result:
    print(solution.objectives)

[3.9996322358184786, 8.453544443958733e-09]
[1.127924708147307e-09, 3.9998656627665743]
[0.9798470709617833, 1.020358071685673]
[0.38454443571031444, 1.9040785578226482]
[1.4000522224087213, 0.6671001247703413]
[1.0396611912826064, 0.96111009309569]
[3.120557393450522, 0.05451760477056071]
[0.15507594797751703, 2.579888604313192]
[0.05586760781523832, 3.1104144228061585]
[3.795712518927766, 0.0026771473383199176]
[0.12995986105920465, 2.6879620188460915]
[0.442734545468221, 1.7812025190797471]
[0.043914191052792075, 3.2056856680087042]
[3.9594481993794433, 0.00010330233728202961]
[1.462877051366248, 0.6248988763576042]
[0.9137834265475023, 1.0901026311933664]
[2.137411567917473, 0.28945593481973475]
[2.6281127195597533, 0.14353073511726708]
[0.1028805437839336, 2.819880660485834]
[2.2400471434314926, 0.2533323268644064]
[3.4949642404701513, 0.017034858112865314]
[0.16933601693373196, 2.5233177087306577]
[2.316596485257274, 0.2284486746241924]
[0.3122278938999198, 2.077133644791235]
[0.11845798135379029, 2.7417489701024493]
[0.03361445590868618, 3.300244634782279]
[0.0013879830400626606, 3.8523654054184067]
[0.022446195795436358, 3.4231640145761197]
[3.6121173809489924, 0.009888885620541785]
[5.5417156423586535e-05, 3.970278336997728]
[0.7531515748749863, 1.2817793392886352]
[3.335016828058249, 0.030205451374249754]
[2.974568926306082, 0.07579346823402558]
[0.6227290456133345, 1.4662017243608552]
[3.2455494485962753, 0.03938603263488005]
[1.70759398929653, 0.48059639710802016]
[0.009755198821972788, 3.6146815586590724]
[0.46852012022794337, 1.730578936848159]
[1.3281261056874352, 0.7183519581831387]
[0.4939912910703839, 1.6826107303625057]
[2.6773901390817945, 0.13229715079593576]
[2.7385527095743996, 0.11912347789661137]
[2.092858211254413, 0.30617251216286745]
[2.480997613339696, 0.18052447131019167]
[1.1429696226288717, 0.86657932682308]
[0.06781547066310753, 3.026159322690217]
[0.34232161644788617, 2.0019913271155922]
[1.0911922688466036, 0.9127863166268271]
[2.53733751871492, 0.1657285932206128]
[1.9164303143764225, 0.37902252462292085]
[0.8708387093981126, 1.1380891396613748]
[0.5159551289638773, 1.6427544636044185]
[0.18887275289624061, 2.4504930342099436]
[1.7712990008141112, 0.44769270310334053]
[1.5092097159097293, 0.5952138414145473]
[2.009733593994548, 0.33913067156092297]
[0.2820492177046786, 2.157716973615996]
[0.22423802971923834, 2.330086907050349]
[0.5387984568342028, 1.602682772916547]
[1.857169082454968, 0.4060494434010344]
[0.19545949273320382, 2.4270274517061075]
[0.29733282327112676, 2.1162034891100303]
[0.012438897673796682, 3.5663196728238167]
[0.6634371702923297, 1.405371068342083]
[2.3972773833404246, 0.20401990980948848]
[0.09064792531822503, 2.886336169545825]
[1.1770953571782887, 0.8373343367011681]
[0.035626971593630895, 3.2806226368391247]
[2.3857770761352266, 0.20739272274933312]
[0.7857648657640396, 1.240029701905262]
[0.7093285874093915, 1.3404626953694212]
[0.835113707012082, 1.1797314681493236]
[3.060507547326951, 0.06278500658334013]
[0.6783991787108243, 1.3837995278620008]
[0.7218287854266984, 1.3234084808105706]
[2.908479834012355, 0.08677349731054121]
[2.2629525429238626, 0.24570726898149148]
[3.3772159881142443, 0.026334693342310037]
[3.0300527064539917, 0.06723407437230668]
[3.2462927428403665, 0.039304198000999005]
[1.1060600033932322, 0.8992845097054939]
[0.005923729525801859, 3.698060655395711]
[0.5928784144324736, 1.5129344813519414]
[0.015966538093391217, 3.51053146857975]
[1.2002788819194288, 0.8179892850635956]
[3.6381177868037446, 0.008577526155013114]
[1.5587974579738235, 0.564725038837195]
[0.3627011361291642, 1.9537141751709635]
[1.8397673605122788, 0.4142463930662528]
[0.5699165074201945, 1.5502039186589538]
[0.8939168750213298, 1.1120297798873044]
[2.7886571769423756, 0.10894798932963871]
[3.426846159564005, 0.02214909938496754]
[0.26078850951633015, 2.2180902566504592]
[1.6348737998360936, 0.5203864553041416]
[0.2413675085210735, 2.2762008142334933]
[0.5577668809982602, 1.5704151949773184]
[0.7990044851918896, 1.2235224529240398]
[0.213883802440122, 2.36398087551613]
[2.8132404469853185, 0.1041535380412187]

Visualising Solutions in Objective Space¶

In the last section, we concluded by printing the objective values for every solution. This information will be easier to digest using a plot, so let's quickly put the data into a Pandas DataFrame and then use Plotly to create a scatterplot. Let's start by moving our Platypus data structure to a DataFrame.

In [10]:

objective_values = np.empty((0, 2))

for solution in algorithm.result:
    y = solution.objectives
    objective_values = np.vstack([objective_values, y])
    
# convert to DataFrame
objective_values = pd.DataFrame(objective_values, columns=['f1','f2'])

With that complete, we can have a peek at our DataFrame to make sure we've not made any obvious mistakes.

In [11]:

objective_values

Out[11]:

	f1	f2
0	3.999632e+00	8.453544e-09
1	1.127925e-09	3.999866e+00
2	9.798471e-01	1.020358e+00
3	3.845444e-01	1.904079e+00
4	1.400052e+00	6.671001e-01
...	...	...
95	2.413675e-01	2.276201e+00
96	5.577669e-01	1.570415e+00
97	7.990045e-01	1.223522e+00
98	2.138838e-01	2.363981e+00
99	2.813240e+00	1.041535e-01

100 rows × 2 columns

With no obvious issues, let's visualise the results using a scatterplot.

In [12]:

fig = go.Figure()
fig.add_scatter(x=objective_values.f1, y=objective_values.f2, mode='markers')
fig.show()

Great! If you search the literature for the true Pareto-optimal front for Schaffer F1, you can see that our approximation is looking as expected.

Conclusion¶

In this section, we have demonstrated how we can use a popular multi-objective optimisation algorithm, NSGA-II, to approximate multiple trade-off solutions to the Schaffer F1 test problem. We did this using the Platypus framework, and by implementing our custom objective function. You can use this approach to write your own objective functions that can be optimised by any algorithm in the Platypus framework.

Deb, K., Pratap, A., Agarwal, S., & Meyarivan, T. A. M. T. (2002). A fast and elitist multiobjective genetic algorithm: NSGA-II. IEEE transactions on evolutionary computation, 6(2), 182-197. ↩
Schaffer, J.. (1985). Multiple Objective Optimization with Vector Evaluated Genetic Algorithms. Proceedings of the First Int. Conference on Genetic Algortihms, Ed. G.J.E Grefensette, J.J. Lawrence Erlbraum. 93-100. ↩

Get access to this section and more

You can access this notebook and more by getting the e-book on Practical Evolutionary Algorithms.