sequence alignment i lecture #2

.

Sequence Alignment ILecture #2

This class has been edited from Nir Friedman’s lecture which is available at www.cs.huji.ac.il/~nir. Changes made by Dan Geiger, then Shlomo Moran, and finally Benny Chor.

Background Readings: Gusfield, chapter 11. Durbin et. al., chapter 2.

2

Sequence Comparison

Much of bioinformatics involves sequences DNA sequences RNA sequences Protein sequences

We can think of these sequences as strings of letters

DNA & RNA: alphabet ∑of 4 letters (A,C,T/U,G) Protein: alphabet ∑ of 20 letters (A,R,N,D,C,Q,…)

3

Sequence Comparison (cont)

Finding similarity between sequences is important for many biological questions

For example: Find similar proteins

Allows to predict function & structure Locate similar subsequences in DNA

Allows to identify (e.g) regulatory elements Locate DNA sequences that might overlap

Helps in sequence assembly

g1

g2

4

Sequence Alignment

Input: two sequences over the same alphabet

Output: an alignment of the two sequences

Example: GCGCATGGATTGAGCGA TGCGCCATTGATGACCA

A possible alignment:

-GCGC-ATGGATTGAGCGA

TGCGCCATTGAT-GACC-A

5

Alignments

-GCGC-ATGGATTGAGCGA

TGCGCCATTGAT-GACC-A

Three “components”: Perfect matches Mismatches Insertions & deletions (indel)

Formal definition of alignment:

6

Choosing Alignments

There are many (how many?) possible alignments

For example, compare:

-GCGC-ATGGATTGAGCGA

TGCGCCATTGAT-GACC-A

to

------GCGCATGGATTGAGCGA

TGCGCC----ATTGATGACCA--

Which one is better?

7

Scoring Alignments

Motivation: Similar (“homologous”) sequences evolved from a

common ancestor In the course of evolution, the sequences changed

from the ancestral sequence by random mutations: Replacements: one letter changed to another Deletion: deletion of a letter Insertion: insertion of a letter

Scoring of sequence similarity should reflect how many and which operations took place

8

A Naive Scoring Rule

Each position scored independently, using: Match: +1 Mismatch : -1 Indel -2

Score of an alignment is sum of position scores

9

Example

-GCGC-ATGGATTGAGCGA

TGCGCCATTGAT-GACC-A

Score: (+1x13) + (-1x2) + (-2x4) = 3

------GCGCATGGATTGAGCGA

TGCGCC----ATTGATGACCA--

Score: (+1x5) + (-1x6) + (-2x11) = -23

according to this scoring, first alignment is better

10

More General Scores

The choice of +1,-1, and -2 scores is quite arbitrary Depending on the context, some changes are more

plausible than others Exchange of an amino-acid by one with

similar properties (size, charge, etc.)

vs. Exchange of an amino-acid by one with very

different properties Probabilistic interpretation: (e.g.) How likely is one

alignment versus another ?

11

Additive Scoring Rules

We define a scoring function by specifying

(x,y) is the score of replacing x by y (x,-) is the score of deleting x (-,x) is the score of inserting x

The score of an alignment is defined as the

sum of position scores

: ( { }) ( { })

12

The Optimal Score

The optimal (maximal) score between two sequences is the maximal score of all alignments of these sequences, namely,

Computing the maximal score or actually finding an alignment that yields the maximal score are closely related tasks with similar algorithms.

We now address these problems.

1 21 2 alignment of s &sV(s ,s ) max score(alignment)

13

Computing Optimal Score

How can we compute the optimal score ? If |s| = n and |t| = m, the number A(m,n) of

possible alignments is large!

Exercise: Show that

So it is not a good idea to go over all alignments The additive form of the score allows us to apply

dynamic programming to compute optimal score efficiently.

2

( , )m n m n

A m nm m

14

Recursive Argument

Suppose we have two sequences:s[1..n+1] and t[1..m+1]

The best alignment must be one of three cases:

1. Last match is (s[n+1],t[m +1] )2. Last match is (s[n +1],-)3. Last match is (-, t[m +1] )

(s[1..n 1], t[1..m 1]) (s[1.., n], t[1..m])

(s[n 1], t[m 1])

V V

15

Recursive Argument

Suppose we have two sequences:s[1..n+1] and t[1..m+1]

The best alignment must be one of three cases:

1. Last match is (s[n+1],t[m +1] )2. Last match is (s[n +1],-)3. Last match is (-, t[m +1] )

(s[1..n 1], t[1..m 1]) (s[1.., n], t[1..m 1])

(s[n 1], )

V V

16

Recursive Argument

Suppose we have two sequences:s[1..n+1] and t[1..m+1]

The best alignment must be one of three cases:

1. Last match is (s[n+1],t[m +1] )2. Last match is (s[n +1],-)3. Last match is (-, t[m +1] )

(s[1..n 1], t[1..m 1]) (s[1.., n 1], t[1..m]V )

( , t[m 1])

V

17

Useful Notation

(ab)use of notation:

V[i,j] = value of optimal alignment between

i prefix of s and j prefix of t.

[i, j] (s[1..i],t[1.V )V .j]

18

Recursive Argument

(ab)use of notation:

V[i,j] = value of optimal alignment between

i prefix of s and j prefix of t. Using our recursive argument, we get the following

recurrence for V:

[i, j] (s[i 1], t[ j 1])

[i 1, j 1] max [i, j 1] (s[i 1], )

V

V V

V[i 1, j] ( , t[ j 1])

[i, j] (s[1..i], t[1.V )V .j]

V[i,j] V[i+1,j]

V[i,j+1] V[i+1,j+1]

19

Recursive Argument

Of course, we also need to handle the base cases in the recursion (boundary of matrix):

V[0,0] 0

V[i 1,0] V[i,0] (s[i 1], )

V[0, j 1] V[0, j] ( , t[ j 1])

0 A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2

A 2 -4

A 3 -6

C 4 -8

AA- -

We fill the “interior of matrix” using our recurrence rule

ST

vs.

20

Dynamic Programming Algorithm

We continue to fill the matrix using the recurrence rule

0

A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2

A 2 -4

A 3 -6

C 4 -8

ST

21

Dynamic Programming Algorithm

0

A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2 1

A 2 -4

A 3 -6

C 4 -8

V[0,0] V[0,1]

V[1,0] V[1,1]

+1-2 -A A-

-2 (A- versus -A)

versus

ST

22

Dynamic Programming Algorithm

0

A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0

A 3 -6 -3

C 4 -8 -5

ST

(hey, what is the scoring function (x,y) ? )

23

Dynamic Programming Algorithm

0

A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

Conclusion: V(AAAC,AGC) = -1

ST

24

Reconstructing the Best Alignment

To reconstruct the best alignment, we record which case(s) in the recursive rule maximized the score

0A1

G2

C3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

ST

25

Reconstructing the Best Alignment

We now trace back a path that corresponds to the best alignment

0A1

G2

C3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

AAACAG-C

ST

26

Reconstructing the Best Alignment

More than one alignment could have the best score

(sometimes, even exponentially many)

0A1

G2

C3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

ST

AAACA-GC

AAAC-AGC

AAACAG-C

27

Time Complexity

Space: O(mn)Time: O(mn) Filling the matrix O(mn) Backtrace O(m+n)

0A1

G2

C3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

ST

28

Space Complexity

In real-life applications, n and m can be very large The space requirements of O(mn) can be fairly

demanding If m = n = 10,000, we need 100MB space If m = n = 100,000, we need 10GB space

We can afford to perform extra computation to save space Looping over million operations takes less than

seconds on modern workstations

Can we trade space with time?

29

Why Do We Need So Much Space?

Compute V(i,j), column by column, storing only two columns in memory

(or line by line if lines are shorter).0

-2

-4

-6

-8

-2

1

-1

-3

-5

-4

-1

0

-2

-4

-6

-3

-2

-1

-1

0A1

G2

C3

0

A 1

A 2

A 3

C 4

Note however that This “trick” fails if we want to

reconstruct the optimal alignment. Trace back information seemingly

requires keeping all back pointers, O(mn) memory.

Will get back to this.

To compute just the value V[n,m]=V(s[1..n],t[1..m]), we need only O(min(n,m)) space:

30

Local Alignment

The alignment version we studies so far is called

global alignment: We align the whole sequence s

to the whole sequence t.

Global alignment is appropriate when s,t are highly

similar (examples?), but makes little sense if they

are highly dissimilar. For example, when s (“the query”)

is very short, but t (“the database”) is very long.

31

Local Alignment

When s and t are not necessarily similar, we may want to consider a different question:

Find similar subsequences of s and t Formally, given s[1..n] and t[1..m] find i,j,k, and l

such that V(s[i..j],t[k..l]) is maximal

This version is called local alignment.

32

Local Alignment

As before, we use dynamic programming We now want to setV[i,j] to record the maximum

value over all alignments of a suffix of s[1..i] and a suffix of t[1..j] In other words, we look for a suffix of a prefix. How should we change the recurrence rule?

Same as before but with an option to start afresh

The result is called the Smith-Waterman algorithm, after its inventors (1981).

33

Local Alignment

New option: We can start a new match instead of extending a

previous alignment

V[i, j] (s[i 1], t[ j 1])

V[i 1, j 1] max V[i, j 1] (s[i 1], )

V[i 1, j] ( , t[ j 1])

0

Alignment of empty suffixesV[0,0] 0

V[i 1,0] max( , V[i,0] (s[i 1], ))

V[0, j 1] max( , V[0, j] ( , t[ j 1 )0 ]

0

)

34

Local Alignment Example

0

A 1

T 2

C 3

T 4

A 5

A 6

0 0 0 0 0 0 0 0

T 1 0

A 2 0

A 3 0

T 4 0

A 5 0

s = TAATAt = TACTAA

ST

35

Local Alignment Example

0

T 1

A 2

C 3

T 4

A 5

A 6

0 0 0 0 0 0 0 0

T 1 0 1 0 0 1 0 0

A 2 0 0 2 0 0 2 1

A 3 0

T 4 0

A 5 0

s = TAATAt = TACTAA

ST

36

Local Alignment Example

0T1

A2

C3

T4

A5

A6

0 0 0 0 0 0 0 0

T 1 0 1 0 0 1 0 0

A 2 0 0 2 0 0 2 1

A 3 0 0 1 1 0 1 3

T 4 0 0 0 0 2 0 1

A 5 0 0 1 0 0 3 1

s = TAATAt = TACTAA

ST

What score should we take?1 (lower right corner); 3 (max); or something else?

37

Local Alignment Example

0T1

A2

C3

T4

A5

A6

0 0 0 0 0 0 0 0

T 1 0 1 0 0 1 0 0

A 2 0 0 2 0 0 2 1

A 3 0 0 1 1 0 1 3

T 4 0 0 0 0 2 0 1

A 5 0 0 1 0 0 3 1

s = TAATAt = TACTAA

ST

38

Local Alignment Example

0T1

A2

C3

T4

A5

A6

0 0 0 0 0 0 0 0

T 1 0 1 0 0 1 0 0

A 2 0 0 2 0 0 2 1

A 3 0 0 1 1 0 1 3

T 4 0 0 0 0 2 0 1

A 5 0 0 1 0 0 3 1

s = TAATAt = TACTAA

ST