Algebraic Dynamic Programming. Dynamic Programming, Old Country Style

Transcription

1 Algebraic Dynamic Programming Session 2 Dynamic Programming, Old Country Style Robert Giegerich (Lecture) Stefan Janssen (Exercises) Faculty of Technology Summer robert@techfak.uni-bielefeld.de

2 Programme of the day Review a classical application of dynamic programming in biosequence analysis Find out about sources of intrinsic difficulties in dynamic programming An anonymous referee wrote back in 2000:

3 Programme of the day Review a classical application of dynamic programming in biosequence analysis Find out about sources of intrinsic difficulties in dynamic programming An anonymous referee wrote back in 2000: The development of successful dynamic programming recurrences is a matter of experience, talent and luck.

4 Virtues of DP DP solves combinatorial optimization problems over an exponential search space in polynomial time via recursive problem decomposition and tabulation of intermediate results whenever Bellman s Principle of Optimality holds.

5 Simple string edit distance Today s example: edit distance via string alignment DA R L I N G A I R L I N E D A R L I N G d m i m m m m r A I R L I N E Standard edit distance model of x and y is based on operations r/m: replacement (resp. match) d: deletion from x i: insertion into y A variety of scoring schemes δ for r,d,i...

6 Simple string edit distance Variations of a fundamental theme String edit distance comes in many variations: many types of sequences and alphabets text, program code, DNA, proteins, numerical measurement series,... many different scoring schemes, even within the same domain: e.g. for protein sequences: Dayhoff matrices or BLOSUM matrices depending on evolutionary distance; additive versus affine gap scores,... many variants of the question asked: distance versus similarity, global/local alignment, small-in-large and free shift alignment,...

7 DP recurrences Edit distance computation via DP Ali δ (i, j) = best alignment score for suffixes x i+1... x m and y j+1... y n under additive score function δ Ali δ (i, j) is an m by n table that stores results of sub-alignments for re-use essential for polynomial efficiency!

8 DP recurrences Edit distance computation via DP ctd. Ali δ (m, n) = 0 (1) Ali δ (i, n) = Ali δ (i + 1, n) + δ(x i+1 ε) (2) Ali δ (m, j) = Ali δ (m, j + 1) + δ(ε y j+1 ) (3) Ali δ (i, j) = min Ali δ (i + 1, j) + δ(x i+1 ε) Ali δ (i, j + 1) + δ(ε y j+1 ) Ali δ (i + 1, j + 1) + δ(x i+1 y j+1 ) (4)

9 DP recurrences Edit distance computation via DP index bounds for i = m 1 to 0 Ali δ (m, n) = 0 (5) Ali δ (i, n) = Ali δ (i + 1, n) + δ(x i+1 ε)(6) for j = n 1 to 0 Ali δ (m, j) = Ali δ (m, j + 1) + δ(ε y j+1 (7) ) for i = m 1 to 0, for j = n 1 to 0 Ali δ (i, j) = min Ali δ (i + 1, j) + δ(x i+1 ε) Ali δ (i, j + 1) + δ(ε y j+1 ) Ali δ (i + 1, j + 1) + δ(x i+1 y j+1 ) (8)

10 DP recurrences DP as a programming method... (1) WHY does this find the optimal alignment?

11 DP recurrences DP as a programming method... (1) WHY does this find the optimal alignment? Bellman s Principle of Optimality! (Proof by induction)

12 DP recurrences DP as a programming method... (1) WHY does this find the optimal alignment? Bellman s Principle of Optimality! (Proof by induction) (2) What type of problem decomposition is this?

13 DP recurrences DP as a programming method... (1) WHY does this find the optimal alignment? Bellman s Principle of Optimality! (Proof by induction) (2) What type of problem decomposition is this? Plain structural recursion over an invisible alignment data type...

14 DP recurrences How does this scale up? More sophisticated problems need more recurrences/tables (= subproblem types) manifold case distinctions intricate search space higher asymptotic complexity This just means: more recurrences

15 DP recurrences Some examples of larger problems Here are data from some larger problems: We specify the number of DP tables that are computed, the number of different cases that make up the central case distinction, and asymptotic runtime complexity. application tables cases runtime edit distance (affine gaps) [Gotoh 1982] 3 15 n 2 spliced alignment [Usuka/Brendel 2000] 4 22 n 2 pknotsrg-enf [Reeder/Giegerich 2004] 47(17) 140 n 4 The last example has 47 recurrences, but only 17 tables are actually stored. The other 20 recurrences are recomputed on demand.

16 DP recurrences Edit distance with affine gap costs We omit the δ-subscript and for-loops... Ali(m, n) = 0 (9) Ali(i, n) = Del(i + 1, n) + OPEN (10) Ali(m, j) = Ins(m, j + 1) + OPEN (11) Del(i + 1, j) + OPEN Ali(i, j) = min Ins(i, j + 1) + OPEN (12) Ali(i + 1, j + 1) + δ(x i+1, y j+1 ) The new tables Del and Ins store scores of alignments that extend an already openend gap in x or y.

17 DP recurrences Del(m, n) = 0 (13) Del(i, n) = Del(i + 1, n) + EXTEND (14) Ali(i, j) Del(i, j) = min Del(i + 1, j) + EXTEND (15) Ins(i, j + 1) + OPEN Ins(m, n) = 0 (16) Ins(m, j) = Ins(m, j + 1) + EXTEND (17) Ali(i, j) Ins(i, j) = min Del(i + 1, j) + OPEN (18) Ins(i, j + 1) + EXTEND

18 DP recurrences A mild critique We usually say the score scheme δ, including OPEN and EXTEND, is a parameter of the algorithm but how about 0, +, min?

19 Non-separation of concerns Critique of traditional-style DP DP does not scale well simple problems are simple to solve large problems are catastrophic because DP recurrences lack abstraction problem decomposition (top-down) computation (bottom-up) table design correctness and efficiency concerns All issues are intermingled in the DP recurrences

20 Bad habits Bad habit 1: incomplete scoring abstraction Ali(m, n) = 0 (19) Ali(i, n) = Del(i + 1, n) + OPEN (20) Ali(m, j) = Ins(m, j + 1) + OPEN (21) Del(i + 1, j) + OPEN Ali(i, j) = min Ins(i, j + 1) + OPEN (22) Ali(i + 1, j + 1) + δ(x i+1, y j+1 ) Del(m, n) = 0 (23) Del(i, n) = Del(i + 1, n) + EXTEND (24) Ali(i, j) Del(i, j) = min Del(i + 1, j) + EXTEND (25) Ins(i, j + 1) + OPEN

21 Bad habits Bad habit 1: incomplete scoring abstraction Ali(m, n) = 0 (19) Ali(i, n) = Del(i + 1, n) + OPEN (20) Ali(m, j) = Ins(m, j + 1) + OPEN (21) Del(i + 1, j) + OPEN Ali(i, j) = min Ins(i, j + 1) + OPEN (22) Ali(i + 1, j + 1) + δ(x i+1, y j+1 ) Del(m, n) = 0 (23) Del(i, n) = Del(i + 1, n) + EXTEND (24) Ali(i, j) Del(i, j) = min Del(i + 1, j) + EXTEND (25) Ins(i, j + 1) + OPEN

22 Bad habits Bad habit 1: incomplete scoring abstraction Ali(m, n) = 0 (19) Ali(i, n) = Del(i + 1, n) + OPEN (20) Ali(m, j) = Ins(m, j + 1) + OPEN (21) Del(i + 1, j) + OPEN Ali(i, j) = min Ins(i, j + 1) + OPEN (22) Ali(i + 1, j + 1) + δ(x i+1, y j+1 ) Del(m, n) = 0 (23) Del(i, n) = Del(i + 1, n) + EXTEND (24) Ali(i, j) Del(i, j) = min Del(i + 1, j) + EXTEND (25) Ins(i, j + 1) + OPEN Del(i, j) = h [Ali(i, j), xdel(x i, Del(i + 1, j)), ins(y j, Ins(i, j + 1))]

23 Bad habits Bad habit 2: program restricted to single answer It always happens: someone asks: Are there several optimal answers? someone asks for k-best answers someone aks for all answers (on small examples) Always provide lists of answers let the scoring scheme (h) decide how many!

24 Bad habits Bad habit 2: program restricted to single answer It always happens: someone asks: Are there several optimal answers? someone asks for k-best answers someone aks for all answers (on small examples) Always provide lists of answers let the scoring scheme (h) decide how many! Added benefit avoid (ab)use of + or to label non-candidates use [] instead

25 Bad habits Bad habit 3: subword decomposition via subscript fiddling (Ali) rling irline r + + i r + i ling irline (Del) rling rline (Ins) ling rline (Ali)

26 Bad habits Bad habit 3: subword decomposition via subscript fiddling (Ali) rling irline r + + i r + i ling irline (Del) rling rline (Ins) ling rline (Ali) Rules of string decomposition are more clearly written as a CFG: Ali $ a Del Ins a a Ali a (26) Del $ a Del Ins a Ali (27) Ins $ Ins a a Del Ali (28) Each derivation of DARLING $ ENILRIA describes an alignment. Even simpler with a two-track grammar...

27 Bad habits Bad habit 4: redundant search space analysis [ a b [ a b ] ] [ ] a and are equivalent b [ a b (1 gap) competes with ] (2 gaps)

28 Bad habits Bad habit 4: redundant search space analysis [ a b [ a b ] ] [ ] a and are equivalent b [ a b (1 gap) competes with ] (2 gaps) Refine grammar: (axiom is Ali) Rep a Ali a $ Ali Rep a Del Ins a Del Rep a Del Ins a Ins Rep Ins a

29 Bad habits Bad habit 5: over-tabulation Note: Rep needs no DP table In general: With many nonterminal symbols, only some represent subproblems whose answer must be stored. Others an be (re-)calculated in O(1). Large example mentioned above: 47 nonterminals, 17 tables (optimal)

30 Bad habits Bad habit 6: backtracing To retrieve candidate with optimal score, trace back through optimal decisions. It requires ambitious programming to enumerate k best scores with their candidates. This is not treated in the textbooks.

31 Bad habits Bad habit 6: backtracing To retrieve candidate with optimal score, trace back through optimal decisions. It requires ambitious programming to enumerate k best scores with their candidates. This is not treated in the textbooks. I never got around to program the full backtracing...

32 Bad habits Bad habit 6: backtracing To retrieve candidate with optimal score, trace back through optimal decisions. It requires ambitious programming to enumerate k best scores with their candidates. This is not treated in the textbooks. I never got around to program the full backtracing... Solution: Substitute backtracing by a forward calculation for free!

33 Bad habits Bad habit 7: No reuse Adapting a DP algorithm to a problem variant means changing the code and extensive testing.

34 Promises The promise of algebraic dynamic programming We can spend a constant factor runtime overhead and avoid all the bad habits We obtain more reliable (and even faster) code more quickly We make DP fun

35 Solutions Summary: Bad habits and their remedies 1 incomplete scoring abstraction... evaluation algebras

36 Solutions Summary: Bad habits and their remedies 1 incomplete scoring abstraction... evaluation algebras

37 Solutions Summary: Bad habits and their remedies 1 incomplete scoring abstraction... evaluation algebras 2 single answer... answer lists

38 Solutions Summary: Bad habits and their remedies 1 incomplete scoring abstraction... evaluation algebras 2 single answer... answer lists 3 subscript fiddling... tree grammar

39 Solutions Summary: Bad habits and their remedies 1 incomplete scoring abstraction... evaluation algebras 2 single answer... answer lists 3 subscript fiddling... tree grammar 4 search space redundancy... grammar refinement

40 Solutions Summary: Bad habits and their remedies 1 incomplete scoring abstraction... evaluation algebras 2 single answer... answer lists 3 subscript fiddling... tree grammar 4 search space redundancy... grammar refinement 5 overtabulation... annotated grammar

41 Solutions Summary: Bad habits and their remedies 1 incomplete scoring abstraction... evaluation algebras 2 single answer... answer lists 3 subscript fiddling... tree grammar 4 search space redundancy... grammar refinement 5 overtabulation... annotated grammar 6 backtracing... pretty printing algebras

42 Solutions Summary: Bad habits and their remedies 1 incomplete scoring abstraction... evaluation algebras 2 single answer... answer lists 3 subscript fiddling... tree grammar 4 search space redundancy... grammar refinement 5 overtabulation... annotated grammar 6 backtracing... pretty printing algebras 7 more power... product algebras

43 Solutions Sneak Preview Next session s topics: The Reverse Engineering view on Dynamic Programming: Given a DP algorithm, what is its invisible data type? Basic definitions of algebraic dynamic programming.