# GECCO '21: Proceedings of the Genetic and Evolutionary Computation Conference

Full Citation in the ACM Digital Library## SESSION: Theory

### Lazy parameter tuning and control: choosing all parameters randomly from a power-law distribution

Most evolutionary algorithms have multiple parameters and their values drastically affect the performance. Due to the often complicated interplay of the parameters, setting these values right for a particular problem is a challenging task. This task becomes even more complicated when the optimal parameter values change significantly during the run of the algorithm since then a dynamic parameter choice is necessary.

In this work, we propose a lazy but effective solution, namely choosing all parameter
values in each iteration randomly from a suitably scaled power-law distribution. We
demonstrate the effectiveness of this approach via runtime analyses of the (1 + (*λ, λ*)) genetic algorithm with all three parameters chosen in this manner. We show that
this algorithm on the one hand can imitate simple hill-climbers like the (1+1) EA,
giving the same asymptotic runtime on some simple problems. On the other hand, this
algorithm is also very efficient on jump functions, where the best static parameters
are very different from those necessary to optimize simple problems. We prove a performance
guarantee that is comparable to, and sometimes even better than, the best performance
known for static parameters. We complement our theoretical results with a rigorous
empirical study confirming what the asymptotic runtime results suggest.

### Generalized jump functions

Jump functions are the most studied non-unimodal benchmark in the theory of evolutionary algorithms (EAs). They have significantly improved our understanding of how EAs escape from local optima. However, their particular structure - to leave the local optimum the EA can only jump directly to the global optimum - raises the question of how representative the recent findings are.

For this reason, we propose an extended class Jump_{k,δ} of jump functions that incorporate a valley of low fitness of width *δ* starting at distance *k* from the global optimum. We prove that several previous results extend to this more
general class: for all *k = o* (*n*^{1/3}) and *δ* ≤ *k*, the optimal mutation rate for the (1 + 1) EA is [EQUATION], and the fast (1 + 1)
EA runs faster than the classical (1 + 1) EA by a factor super-exponential in *δ.* However, we also observe that some known results do not generalize: the randomized
local search algorithm with stagnation detection, which is faster than the fast (1
+ 1) EA by a factor polynomial in *k* on Jump_{k}, is slower by a factor polynomial in *n* on some Jump_{k,δ} instances.

Computationally, the new class allows experiments with wider fitness valleys, especially when they lie further away from the global optimum.

### Non-elitist evolutionary algorithms excel in fitness landscapes with sparse deceptive regions and dense valleys

It is largely unknown how the runtime of evolutionary algorithms depends on fitness landscape characteristics for broad classes of problems. Runtime guarantees for complex and multi-modal problems where EAs are typically applied are rarely available.

We present a parameterised problem class SparseLocalOpt_{α,ε} where the class with parameters *α, ϵ ∈* [0, 1] contains all fitness landscapes with deceptive regions of sparsity *ε* and fitness valleys of density *α.* We study how the runtime of EAs depends on these fitness landscape parameters.

We find that for any constant density and sparsity *α, ε ∈* (0, 1), SparseLocalOpt_{α,ε} has exponential elitist (*μ + λ*) black-box complexity, implying that a wide range of elitist EAs fail even for mildly
deceptive and multi-modal landscapes. In contrast, we derive a set of sufficient conditions
for non-elitist EAs to optimise any problem in SparseLocalOpt_{α,ε} in expected polynomial time for broad values of *α* and *ε.* These conditions can be satisfied for tournament selection and linear ranking selection,
but not for (*μ, λ*)-selection.

### Lower bounds from fitness levels made easy

One of the first and easy to use techniques for proving run time bounds for evolutionary
algorithms is the so-called method of fitness levels by Wegener. It uses a partition
of the search space into a sequence of levels which are traversed by the algorithm
in increasing order, possibly skipping levels. An easy, but often strong upper bound
for the run time can then be derived by adding the reciprocals of the probabilities
to leave the levels (or upper bounds for these). Unfortunately, a similarly effective
method for proving lower bounds has not yet been established. The strongest such method,
proposed by Sudholt (2013), requires a careful choice of the viscosity parameters
*γ _{i,j}*, 0 ≤

*i*≤

*j*≤

*n.*

In this paper we present two new variants of the method, one for upper and one for
lower bounds. Besides the level leaving probabilities, they only rely on the probabilities
that levels are visited at all. We show that these can be computed or estimated without
greater difficulties and apply our method to reprove the following known results in
an easy and natural way. (i) The precise run time of the (1 + 1) EA on LeadingOnes.
(ii) A lower bound for the run time of the (1 + 1) EA on OneMax, tight apart from
an *O*(*n*) term. (iii) A lower bound for the run time of the (1 + 1) EA on long *k*-paths.

### Self-adjusting population sizes for non-elitist evolutionary algorithms: why success rates matter

Recent theoretical studies have shown that self-adjusting mechanisms can provably outperform the best static parameters in evolutionary algorithms on discrete problems. However, the majority of these studies concerned elitist algorithms and we do not have a clear answer on whether the same mechanisms can be applied for non-elitist algorithms.

We study one of the best-known parameter control mechanisms, the one-fifth success
rule, to control the offspring population size *λ* in the non-elitist (1, *λ*) EA. It is known that the (1, *λ*) EA has a sharp threshold with respect to the choice of *λ* where the runtime on OneMax changes from polynomial to exponential time. Hence, it
is not clear whether parameter control mechanisms are able to find and maintain suitable
values of *λ.*

We show that the answer crucially depends on the success rate *s* (i. e. a one-(*s* + 1)-th success rule). We prove that, if the success rate is appropriately small,
the self-adjusting (1, *λ*) EA optimises OneMax in *O*(*n*) expected generations and *O*(*n* log *n*) expected evaluations. A small success rate is crucial: we also show that if the
success rate is too large, the algorithm has an exponential runtime on OneMax.

### More precise runtime analyses of non-elitist EAs in uncertain environments

Real-world optimisation problems often involve uncertainties. In the past decade, several rigorous analysis results for evolutionary algorithms (EAs) on discrete problems show that EAs can cope with low-level uncertainties, and sometimes benefit from uncertainties. Using non-elitist EAs with large population size is a promising approach to handle higher levels of uncertainties. However, the performance of non-elitist EAs in some common fitness-uncertainty scenarios is still unknown.

We analyse the runtime of non-elitist EAs on OneMax and LeadingOnes under prior and posterior noise models, and the dynamic binary value problem (DynBV). Our analyses are more extensive and precise than previous analyses of non-elitist EAs. In several settings, we prove that the non-elitist EAs beat the current state of the art results. Previous work shows that the population size and mutation rate can dramatically impact the performance of non-elitist EAs. The optimal choices of these parameters depend on the level of uncertainties in the fitness functions. We provide more precise guidance on how to choose mutation rate and population size as a function of the level of uncertainties.

### Convergence rate of the (1+1)-evolution strategy with success-based step-size adaptation on convex quadratic functions

The (1+1)-evolution strategy (ES) with success-based step-size adaptation is analyzed
on a general convex quadratic function and its monotone transformation, that is, *f*(*x*) = *g*((*x - x**)^{T}*H*(*x - x**)), where *g*: R → R is a strictly increasing function, *H* is a positive-definite symmetric matrix, and *x** ∈ R^{d} is the optimal solution of *f.* The convergence rate, that is, the decrease rate of the distance from a search point
*m _{t}* to the optimal solution

*x**, is proven to be in

*O*(exp(-

*L*/Tr(

*H*))), where

*L*is the smallest eigenvalue of

*H*and Tr(

*H*) is the trace of

*H.*This result generalizes the known rate of

*O*(exp(-1/

*d*)) for the case of

*H*=

*I*(

_{d}*I*is the identity matrix of dimension

_{d}*d*) and

*O*(exp(-1/(

*d*·

*ξ*))) for the case of

*H*= diag(

*ξ*·

*I*

_{d/2},

*I*

_{d/2}). To the best of our knowledge, this is the first study in which the convergence rate of the (1+1)-ES is derived explicitly and rigorously on a general convex quadratic function, which depicts the impact of the distribution of the eigenvalues in the Hessian

*H*on the optimization and not only the impact of the condition number of

*H.*

### Stagnation detection in highly multimodal fitness landscapes

Stagnation detection has been proposed as a mechanism for randomized search heuristics to escape from local optima by automatically increasing the size of the neighborhood to find the so-called gap size, i. e., the distance to the next improvement. Its usefulness has mostly been considered in simple multimodal landscapes with few local optima that could be crossed one after another. In multimodal landscapes with a more complex location of optima of similar gap size, stagnation detection suffers from the fact that the neighborhood size is frequently reset to 1 without using gap sizes that were promising in the past.

In this paper, we investigate a new mechanism called radius memory which can be added
to stagnation detection to control the search radius more carefully by giving preference
to values that were successful in the past. We implement this idea in an algorithm
called SD-RLS^{m} and show compared to previous variants of stagnation detection that it yields speed-ups
for linear functions under uniform constraints and the minimum spanning tree problem.
Moreover, its running time does not significantly deteriorate on unimodal functions
and a generalization of the Jump benchmark. Finally, we present experimental results
carried out to study SD-RLS^{m} and compare it with other algorithms.

### Runtime analysis of RLS and the (1+1) EA for the chance-constrained knapsack problem with correlated uniform weights

Addressing a complex real-world optimization problem is a challenging task. The chance-constrained knapsack problem with correlated uniform weights plays an important role in the case where dependent stochastic components are considered. We perform runtime analysis of a randomized search algorithm (RSA) and a basic evolutionary algorithm (EA) for the chance-constrained knapsack problem with correlated uniform weights. We prove bounds for both algorithms for producing a feasible solution. Furthermore, we investigate the behaviour of the algorithms and carry out analyses on two settings: uniform profit value and the setting in which every group shares an arbitrary profit profile. We provide insight into the structure of these problems and show how the weight correlations and the different profit profiles influence the runtime behavior of both algorithms in the chance-constrained setting.