Tutorials#
Step-by-step tutorials with runnable code. Most come with a class in the
org.uma.evolver.example.tutorial package, so you can run it and experiment with it; the quick
start (E4) only uses the command line. They are grouped in three levels:
Introductory: the basic concepts, needed for everything else.
Intermediate: designing experiments, analyzing and validating their results.
Advanced: meta-optimizers, encodings, alternative tuners and extending Evolver.
The algorithms themselves (what each one does, and where it works well or poorly) are described in the algorithm guides.
Introductory#
Tutorial |
What you will learn |
|---|---|
What a parameter space is, the types of parameters and their relations, and how a configuration is a point of the space (NSGA-II for continuous and binary problems). |
|
Configuring and running Evolver’s algorithms from a parameter space, reading their results, and running them on other problems and encodings: Evolver as an alternative to jMetal. |
|
Base-level algorithm, meta-optimizer, training problem and quality indicators: a complete training run, from Java and from the command line, and choosing the configuration it finds. |
|
Build Evolver, run a configurable algorithm, tune it, and run it with the configuration found, from the command line. |
Intermediate#
Tutorial |
What you will learn |
|---|---|
Reducing and extending a YAML parameter space, the limits that the algorithms set, measuring the size of a space, and comparing two spaces by validating the configurations they produce (the space of the 2019 irace study against the full one). |
|
Designing a training run (training set, meta-objectives, budgets, independent runs) and validating its result against other algorithms, on problems seen and not seen during the training. |
|
Reading the output files of a training run, its convergence and the population of the meta-optimizer, choosing a configuration from the final front, and validating the choice. |
|
Designing a validation study and analyzing it: medians and IQRs, boxplots, the Wilcoxon test, effect sizes, the Friedman test with Holm’s procedure, critical difference plots and a Bayesian test, repeating with Evolver the first study of automatic configuration with jMetal. |
|
What each indicator needs when a problem has no reference front, estimating extreme points for the hypervolume and what goes wrong with bad ones, training with HV− and EP, and validating with a reference front built from the study (the bi-objective TSP). |
|
Tuning NSGA-II for a binary problem (ZDT5) and a permutation one (the bi-objective TSP): the parameter spaces and operators of each encoding, and validating without a known front. |
|
The two budgets of a training: the evaluations of each base-level run, and the stopping condition of the meta-optimizer, by number of configurations or by computing time; when to use each and what they change in the results. |
Advanced#
Tutorial |
What you will learn |
|---|---|
Which of the components that a training changed explain the improvement: choosing the
components, deriving valid variants of a configuration with |
|
What the six meta-optimizers have in common and what sets them apart: operators, flat and tree encodings, parallel evaluation and the number of cores, when each one checks the time limit, and reasons to choose one. |
|
The grammar of a parameter space, the inactive variables and neutral mutations of the flat encoding measured on NSGA-II, and a training with each encoding in the same time. |
|
Tuning an Evolver algorithm with irace: generating the parameter file from a YAML space, the target runner, the scenario, running irace, and applying the configuration it finds. |
|
The request, status and results files of |
|
Using a problem of your own, given by its class name, from a request and in a training, and adding an operator to the catalogue (a Gaussian mutation, as an example that is not part of Evolver): the class, the three changes, the test and a patch. |
More tutorials are planned for the intermediate and advanced levels.