Upper Bounds on the Time and Space Complexity of Optimizing Additively Separable Functions

Upper Bounds on the Time and Space Complexity of Optimizing Additively Separable Functions

Matthew J. StreeterCarnegie Mellon University

Pittsburgh, PAmatts@cs.cmu.edu

Outline

• Introduction

• Definitions & notation

• Detecting linkage

• Algorithm, analysis & performance

• Conclusions

Introduction

• An additively separable function f of order k is one that can be expressed as:

where each fi depends on at most k characters of s, and each character contributes to at most one fi

• Studied extensively in EC literature, particularly in relation to competent GAs.

€

f(s) = fi (s)i

∑

Introduction

David Goldberg,The Design of Innovation (p. 51-2)

“[W]e would like a procedure that scales polynomially, as O(jb) with b as small a number as possible (current estimates of b suggest that subquadratic—b≤2—solutions are possible).”

Introduction

• Previous bound: time O(j2); space O(1) (Munemoto & Goldberg 1999)

• New bound: time O(j*ln(j)); space O(1)

Definitions & notation

• si = ith character of binary string s

• s[ic] = a copy of s with si set to c

fi(s) = f(s[i (si)]) - f(s)

= effect on fitness of flipping ith bit (Munemoto & Goldberg 1999)

Definitions & notation

• Linkage: positions i and j are linked, written (i, j), if there is some string s such that:

fi(s[j0]) fi(s[j1])

• Grouping: i and j are grouped, written (i, j), if i=j or if there is some sequence i0, i1, ..., in such that:

i0 = i

in = j

(im, im+1) for 0 m < n

Definitions & notation

• Linkage group: a non-empty set g such that if i g then j g iff. (i, j)

• Linkage group partition: the unique set f = {g1, g2, ..., gn} of linkage groups of f.

Example

f(s) = s1s2 + s2s3 + s4s5

• Linkage:(1, 2) (2, 3) (4, 5)

(2, 1) (3, 2) (5, 4)

• Linkage groups: {1,2,3} and {4,5}, so f = {{1,2,3}, {4,5}}

• f is an additively separable function of order 3

Relationship to additively separable functions

• If f = {g1, g2, ..., gn} then f can be written as:

where each fi depends only on the positions in gi

So f is additively separable of orderk = max1≤i≤n |gi|

• So once we know f, we can find the global optimum of f in time O(2k*j) by local search

€

f(s) = fi (s)i

∑

Algorithm overview

• Start with a random string and the trivial linkage group partition = {{1}, {2}, ..., {j}}.

• Repeatedly perform a randomized test to detect pairs of positions that are linked

• Every time we find a new link (i,j), merge i’s and j’s subset to form a new subset g’, and use local search to make optimal w.r.t. g’

• Once = f, we will have found a globally optimal string

Detecting linkage: O(j2) approach

• For fixed i and j, pick a random string s and check if fi(s[j0]) fi(s[j1]).

• Test requires 4 function evaluations, and is conclusive with probability at least 2-k.

• Leads to an algorithm that requires O(2k*j2) function evaluations. (Munemoto & Goldberg 1999)

Detecting linkage: O(j*ln(j)) approach

• For fixed i, generate two random strings s and t that have the same character at i, and check whether fi(s) fi(t).

• Suppose fi(s) fi(t). Let d be the hamming distance from s to t.– If d=1, call the position that differs j and we have (i,

j) by definition – Otherwise create a string s’ that differs from both s

and t in d/2 positions. We must have either fi(s’) fi(s) or fi(s’) fi(t), so just recurse until we get d=1.

Examplef(s) = s1s2 + s2s3 + s4s5 i = 2

Iteration 1

s f2(s)

s(1) 00000 0

t(1) 10111 2

s(1)’ 00011 0

Iteration 2

s f2(s)

s(2) 00011 0

t(2) 10111 2

s(2)’ 00111 1

Iteration 3

s f2(s)

s(2) 00111 1

t(2) 10111 2

Conclusion: (1, 2)

How to use this?

• Some links are more “obvious” than others

• Ideally we would like to only discover novel links (those that let us update )

• We would like test to be conclusive with probability at least 2-k

Discovering novel links

• Binary search starting at s and t will always return a position j where s and t disagree (sj tj)

• So, when looking for a link from i, just make sure s and t agree on all the positions in whichever subset in contains i

Probability that test is conclusive

• Let g be the subset in that contains i, and let gf be i’s true linkage group (g gf)

• Can show that with probability at least 2-|g|, will choose an s such that for some t, fi(t) fi(s)

• Because there only |gf| - |g| positions left in t that affect fi(t), test will be conclusive with probability at least:

€

2− g

2− g f − g( ) = 2

− g f ≥ 2−k

Finding f

• On each iteration, let i run from 1 to j and perform test for link out of i

Analysis

• Each conclusive test requires time O(ln(j)) and we do at most j-1 of them, so total time is O(j*ln(j))

• Time for local search is O(2k*j)

• Only thing left is time for inconclusive tests, each of which is O(1).

• Need to know the number t of rounds needed to discover the correct with probability ≥ p

Calculating number of rounds

• To discover f it is sufficient that each position participate in 1 conclusive test

• If this hasn’t happened yet, it happens with probability at least 2-k

• This means we get a lower bound by analyzing the following algorithm:

for n from 1 to t do:for i from 1 to j do:

with probability 2-k, mark iif all positions are marked, return ‘success’

return ‘failure’

Calculating number of rounds

• The probability that this algorithm succeeds isp = (1-(1-2-k)t)

• To succeed with probability p, we must set

t

• Some calculus shows that this is O(2k*ln(j))

€

ln 1− p1

l

⎛

⎝ ⎜

⎞

⎠ ⎟

⎛

⎝

⎜ ⎜

⎞

⎠

⎟ ⎟

ln 1− 2−k( )

Performance

• Near-linear scaling as expected

• Have solved up to 100,000 bit problems with this algorithm

• Ran on folded trap functions with k=5, 5 ≤ j ≤ 1000

QuickTime™ and aTIFF (LZW) decompressor

are needed to see this picture.

Limitations

• Function must be strictly additively separable

• On any real problem, this algorithm will become an exhaustive search

• Can start to address this using averaging and thresholding (Munemoto & Goldberg 1999)

• I believe these limitations can be overcome

Conclusions

• New upper bounds on time complexity (O(2k*j*ln(j))) and space complexity (O(1)) of optimizing additively separable functions

• Algorithm not practical as-is

• Linkage detection algorithm presented here could be used to construct more powerful competent GAs