Carola Doerr

Optimal Parameter Choices Through Self-Adjustment: Applying the 1/5-th Rule in Discrete Settings

While evolutionary algorithms are known to be very successful for a broad range of applications, the algorithm designer is often left with many algorithmic choices, for example, the size of the population, the mutation rates, and the crossover rates of the algorithm. These parameters are known to have a crucial influence on the optimization time, and thus need to be chosen carefully, a task that often requires substantial efforts. Moreover, the optimal parameters can change during the optimization process. It is therefore of great interest to design mechanisms that dynamically choose best-possible parameters. An example for such an update mechanism is the one-fifth success rule for step-size adaption in evolutionary strategies. While in continuous domains this principle is well understood also from a mathematical point of view, no comparable theory is available for problems in discrete domains. In this work we show that the one-fifth success rule can be effective also in discrete settings. We regard the (1+(λ,λ)) GA proposed in [Doerr/Doerr/Ebel: From black-box complexity to designing new genetic algorithms, TCS 2015]. We prove that if its population size is chosen according to the one-fifth success rule then the expected optimization time on OneMax is linear. This is better than what any static population size λ can achieve and is asymptotically optimal also among all adaptive parameter choices.

Optimal Parameter Choices via Precise Black-Box Analysis

In classical runtime analysis it has been observed that certain working principles of an evolutionary algorithm cannot be understood by only looking at the asymptotic order of the runtime, but that more precise estimates are needed. In this work we demonstrate that the same observation applies to black-box complexity analysis. We prove that the unary unbiased black-box complexity of the classic OneMax function class is n ln(n) -- cn ± o(n) for a constant c between 0.2539 and 0.2665. Our analysis yields a simple (1+1)-type algorithm achieving this runtime bound via a fitness-dependent mutation strength. When translated into a fixed-budget perspective, our algorithm with the same budget computes a solution that asymptotically is 13% closer to the optimum (given that the budget is at least 0.2675n).

k-Bit Mutation with Self-Adjusting k Outperforms Standard Bit Mutation

When using the classic standard bit mutation operator, parent and offspring differ in a random number of bits, distributed according to a binomial law. This has the advantage that all Hamming distances occur with some positive probability, hence this operator can be used, in principle, for all fitness landscapes. The downside of this “one-size-fits-all” approach, naturally, is a performance loss caused by the fact that often not the ideal number of bits is flipped. Still, the fear of getting stuck in local optima has made standard bit mutation become the preferred mutation operator.

Playing Mastermind With Many Colors

We analyze the general version of the classic guessing game Mastermind with n positions and k colors. Since the case k ≤ n1 − ε, ε > 0 a constant, is well understood, we concentrate on larger numbers of colors. For the most prominent case k = n, our results imply that Codebreaker can find the secret code with O(nlog log n) guesses. This bound is valid also when only black answer pegs are used. It improves the O(nlog n) bound first proven by Chvátal. We also show that if both black and white answer pegs are used, then the O(nlog log n) bound holds for up to n2log log n colors. These bounds are almost tight, as the known lower bound of Ω(n) shows. Unlike for k ≤ n1 − ε, simply guessing at random until the secret code is determined is not sufficient. In fact, we show that an optimal nonadaptive strategy (deterministic or randomized) needs Θ(nlog n) guesses.

Calculation of Discrepancy Measures and Applications

In this book chapter we survey known approaches and algorithms to compute discrepancy measures of point sets. After providing an introduction which puts the calculation of discrepancy measures in a more general context, we focus on the geometric discrepancy measures for which computation algorithms have been designed. In particular, we explain methods to determine L 2-discrepancies and approaches to tackle the inherently difficult problem to calculate the star discrepancy of given sample sets. We also discuss in more detail three applications of algorithms to approximate discrepancies.

A Tight Runtime Analysis of the (1+(λ, λ)) Genetic Algorithm on OneMax

Understanding how crossover works is still one of the big challenges in evolutionary computation research, and making our understanding precise and proven by mathematical means might be an even bigger one. As one of few examples where crossover provably is useful, the (1+(λ, λ)) Genetic Algorithm (GA) was proposed recently in [Doerr, Doerr, Ebel. Lessons From the Black-Box: Fast Crossover-Based Genetic Algorithms. TCS 2015]. Using the fitness level method, the expected optimization time on general OneMax functions was analyzed and a O(max{n log(n) / λ, λ n}) bound was proven for any offspring population size λ ∈ [1..n]. We improve this work in several ways, leading to sharper bounds and a better understanding of how the use of crossover speeds up the runtime in this algorithm. We first improve the upper bound on the runtime to O(max{n log(n) / λ, n λ log log(λ)/log(λ)}). This improvement is made possible from observing that in the parallel generation of λ offspring via crossover (but not mutation), the best of these often is better than the expected value, and hence several fitness levels can be gained in one iteration. We then present the first lower bound for this problem. It matches our upper bound for all values of λ. This allows to determine the asymptotically optimal value for the population size. It is λ = Θ(√{log(n) log log(n)/ log log log(n)}), which gives an optimization time of Θ(n √{log(n) log log log(n) / log log(n)}). Hence the improved runtime analysis both gives a runtime guarantee improved by a super-constant factor and yields a better actual runtime (faster by more than a constant factor) by suggesting a better value for the parameter λ. We finally give a tail bound for the upper tail of the runtime distribution, which shows that the actual runtime exceeds our runtime guarantee by a factor of (1+δ) with probability O((n/λ2)-δ) only.

Elitist Black-Box Models: Analyzing the Impact of Elitist Selection on the Performance of Evolutionary Algorithms

Black-box complexity theory provides lower bounds for the runtime %classes of black-box optimizers like evolutionary algorithms and serves as an inspiration for the design of new genetic algorithms. Several black-box models covering different classes of algorithms exist, each highlighting a different aspect of the algorithms under considerations. In this work we add to the existing black-box notions a new \emph{elitist black-box model}, in which algorithms are required to base all decisions solely on (a fixed number of) the best search points sampled so far. Our model combines features of the ranking-based and the memory-restricted black-box models with elitist selection. We provide several examples for which the elitist black-box complexity is exponentially larger than that the respective complexities in all previous black-box models, thus showing that the elitist black-box complexity can be much closer to the runtime of typical evolutionary algorithms. We also introduce the concept of

The Query Complexity of Finding a Hidden Permutation

p

Money for Nothing: Speeding Up Evolutionary Algorithms Through Better Initialization

-Monte Carlo black-box complexity, which measures the time it takes to optimize a problem with failure probability at most p. Even for small

The Right Mutation Strength for Multi-Valued Decision Variables

p