sequence alignment. 2 sequence comparison much of bioinformatics involves sequences u dna sequences...
TRANSCRIPT
Sequence Alignment
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 Protein: alphabet ∑ of 20 letters
3
Sequence Comparison
Finding similarity between sequences is important for many biological questions
Biological evolution (mutation, deletion, duplication, addition, move of subsequences…)
Homologous (share a common ancestor) sequences are (relatively) similar
Algorithms try to detect similar sequence that possibly share a common function
4
Sequence Comparison (cont)
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
Complete DNA Sequences
More than 1000 complete genomes have been sequenced
Evolution
Evolution at the DNA level
…ACGGTGCAGTTACCA…
…AC----CAGTCCACCA…
Mutation
SEQUENCE EDITS
REARRANGEMENTS
Deletion
InversionTranslocationDuplication
Evolutionary Rates
OK
OK
OK
X
X
Still OK?
next generation
Sequence conservation implies function
Alignment is the key to• Finding important regions• Determining function• Uncovering evolutionary events
Sequence Alignment
-AGGCTATCACCTGACCTCCAGGCCGA--TGCCC---TAG-CTATCAC--GACCGC--GGTCGATTTGCCCGAC
DefinitionGiven two strings x = x1x2...xM, y = y1y2…yN,
an alignment is an assignment of gaps to positions0,…, N in x, and 0,…, N in y, so as to line up each
letter in one sequence with either a letter, or a gapin the other sequence
AGGCTATCACCTGACCTCCAGGCCGATGCCCTAGCTATCACGACCGCGGTCGATTTGCCCGAC
What is a good alignment?
AGGCTAGTT, AGCGAAGTTT
AGGCTAGTT- 6 matches, 3 mismatches, 1 gap
AGCGAAGTTT
AGGCTA-GTT- 7 matches, 1 mismatch, 3 gaps
AG-CGAAGTTT
AGGC-TA-GTT- 7 matches, 0 mismatches, 5 gaps
AG-CG-AAGTTT
Scoring Function
• Sequence edits:AGGCCTC
Mutations AGGACTC
Insertions AGGGCCTC
Deletions AGG . CTC
Scoring Function:Match: +mMismatch: -sGap: -d
Score F = (# matches) m - (# mismatches) s – (#gaps) d
Alternative definition:
minimal edit distance
“Given two strings x, y,find minimum # of edits (insertions, deletions,
mutations) to transform one string to the other”
13
Simple Scoring Rule
Score each position independently: Match m: +1 Mismatch s: -1 Indel d: -2Score of an alignment is sum of position scores
Scoring Function:Match: m m≥0Mismatch: s s≤0Gap: d s≤0
Score F = (#matches)m + (#mismatches)s + (#gaps)d
14
Alignments
-GCGC-ATGGATTGAGCGATGCGCCATTGAT-GACC-A
Three elements: Matches Mismatches Insertions & deletions (indel)
15
Example
Example:
-GCGC-ATGGATTGAGCGATGCGCCATTGAT-GACC-A
Score: (+1x13) + (-1x2) + (-2x4) = 3
------GCGCATGGATTGAGCGATGCGCC----ATTGATGACCA--
Score: (+1x5) + (-1x6) + (-2x11) = -23
16
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.)
· Exchange of an amino-acid by one with opposite properties
Probabilistic interpretation: (e.g.) How likely is one alignment versus another ?
17
Additive Scoring Rules
We define a scoring function by specifying a function
· (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 the sum of position scores
}){(}){(:
How do we compute the best alignment?
AGTGCCCTGGAACCCTGACGGTGGGTCACAAAACTTCTGGA
AGTGACCTGGGAAGACCCTGACCCTGGGTCACAAAACTC
Too many possible alignments:
>> 2N
(exercise)
19
The Optimal Score
The optimal alignment score between two sequences is the maximal score over all alignments of these sequences:
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 two problems.
nment)score(aligmax),d( & of alignment 21 ss21 ss
Alignment is additive
Observation:The score of aligning x1……xM
y1……yN
is additive
Say that x1…xi xi+1…xM aligns to y1…yj yj+1…yN
The two scores add up:
F(x[1:M], y[1:N]) = F(x[1:i], y[1:j]) + F(x[i+1:M], y[j+1:N])
Dynamic Programming
• There are only a polynomial number of subproblems Align x1…xi to y1…yj
• Original problem is one of the subproblems Align x1…xM to y1…yN
• Each subproblem is easily solved from smaller subproblems We will show next
• Then, we can apply Dynamic Programming!!!
Let F(i, j) = optimal score of aligning
x1……xi
y1……yj
F is the DP “Matrix” or “Table”
“Memoization”
Dynamic Programming (cont’d)
Notice three possible cases:
1. xi aligns to yj
x1……xi-1 xi
y1……yj-1 yj
2. xi aligns to a gapx1……xi-1 xi
y1……yj -
3. yj aligns to a gapx1……xi -y1……yj-1 yj
m, if xi = yj
F(i, j) = F(i – 1, j – 1) + -s, if
not
F(i, j) = F(i – 1, j) – d
F(i, j) = F(i, j – 1) – d
Dynamic Programming (cont’d)
How do we know which case is correct?
Inductive assumption:F(i, j – 1), F(i – 1, j), F(i – 1, j – 1) are optimal
Then, F(i – 1, j – 1) + s(xi, yj)
F(i, j) = max F(i – 1, j) – d F(i, j – 1) – d
Where s(xi, yj) = m, if xi = yj; -s, if not
G -
A G T A
0 -1 -2 -3 -4
A -1 1 0 -1 -2
T -2 0 0 1 0
A -3 -1 -1 0 2
F(i,j) i = 0 1 2 3 4
Example
x = AGTA m = 1y = ATA s = -1
d = -1
j = 0
1
2
3
F(1, 1) = max{F(0,0) + s(A, A), F(0, 1) – d, F(1, 0) – d} =
max{0 + 1, -1 – 1, -1 – 1} = 1
AA
TT
AA
Procedure to output Alignment
• Follow the backpointers
• When diagonal,OUTPUT xi, yj
• When up,OUTPUT yj
• When left,OUTPUT xi
The Needleman-Wunsch Matrix
x1 ……………………………… xMy1 …
……
……
……
……
……
… y
N
Every nondecreasing path
from (0,0) to (M, N)
corresponds to an alignment of the two sequences
An optimal alignment is composed of optimal subalignments
The Needleman-Wunsch Algorithm
1. Initialization.a. F(0, 0) = 0b. F(0, j) = - j dc. F(i, 0) = - i d
2. Main Iteration. Filling-in partial alignmentsa. For each i = 1……M
For each j = 1……N F(i – 1,j – 1) + s(xi, yj)
[case 1]F(i, j) = max F(i – 1, j) – d [case
2] F(i, j – 1) – d [case
3]
DIAG, if [case 1]Ptr(i, j) = LEFT, if [case 2]
UP, if [case 3]
3. Termination. F(M, N) is the optimal score, andfrom Ptr(M, N) can trace back optimal alignment
Performance
• Time:O(NM)
• Space:O(NM)
• Later we will cover more efficient methods
28
Recursive Argument
Of course, we also need to handle the base cases in the recursion:
])[,(],[],[
)],[(],[],[
],[
1jtj0V1j0V
1is0iV01iV
000V
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 matrix using the recurrence rule:
ST
versus
29
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
30
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
31
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
32
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: d(AAAC,AGC) = -1
ST
33
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
34
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
35
Reconstructing the Best Alignment
Sometimes, more than one alignment has the best 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
AAACA-GC
AAAC-AGC
AAACAG-C
36
The Needleman-Wunsch Matrix
x1 ……………………………… xM
y1 …
……
……
……
……
……
…
yN
Every nondecreasing path
from (0,0) to (M, N)
corresponds to an alignment of the two sequences
An optimal alignment is composed of optimal subalignments
37
The Needleman-Wunsch AlgorithmGlobal Alignment Algorithm
1. Initialization.a. F(0, 0) = 0b. F(0, j) = j dc. F(i, 0) = i d
2. Main Iteration. Filling-in partial alignmentsa. For each i = 1……M
For each j = 1……N F(i-1,j-1) + s(xi, yj)
[case 1]F(i, j) = max F(i-1, j) + d
[case 2] F(i, j-1) + d [case
3]
DIAG, if [case 1]Ptr(i,j) = LEFT, if [case 2]
UP, if [case 3]
3. Termination. F(M, N) is the optimal score, andfrom Ptr(M, N) can trace back optimal alignment
38
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
39
Space Complexity
In real-life applications, n and m can be very large The space requirements of O(mn) can be too
demanding· If m = n = 1000, we need 1MB space· If m = n = 10000, we need 100MB 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?
40
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 when we
need to reconstruct the optimizing sequence.
Trace back information requires O(mn) memory bytes.
To compute V[n,m]=d(s[1..n],t[1..m]), we need only O(min(n,m)) space:
Bounded Dynamic Programming
Assume we know that x and y are very similar
Assumption: # gaps(x, y) < k(N)
xi Then, | implies | i – j | < k(N)
yj
We can align x and y more efficiently:
Time, Space: O(N k(N)) << O(N2)
Bounded Dynamic Programming
Initialization:
F(i,0), F(0,j) undefined for i, j > k
Iteration:
For i = 1…M
For j = max(1, i – k)…min(N, i+k)
F(i – 1, j – 1)+ s(xi, yj)
F(i, j) = max F(i, j – 1) – d, if j > i – k(N)
F(i – 1, j) – d, if j < i + k(N)
Termination: same
x1 ………………………… xM
y1 …
……
……
……
……
…
yN
k(N)
A variant of the basic algorithm:
• Maybe it is OK to have an unlimited # of gaps in the beginning and end:
----------CTATCACCTGACCTCCAGGCCGATGCCCCTTCCGGC ||||||| |||| | || ||GCGAGTTCATCTATCAC--GACCGC--GGTCG--------------
• Then, we don’t want to penalize gaps in the ends
Different types of overlaps
Example:2 overlapping“reads” from a sequencing project
Example:Search for a mouse genewithin a human chromosome
The Overlap Detection variant
Changes:
1. InitializationFor all i, j,
F(i, 0) = 0F(0, j) = 0
2. Termination maxi F(i, N)
FOPT = max maxj F(M, j)
x1 ……………………………… xM
y1 …
……
……
……
……
……
…
yN
46
The Overlap Detection variantChanges:
1. InitializationFor all i, j,
V(i, 0) = 0V(0, j) = 0
2. Termination maxi V(i,
N)VOPT = max
maxj V(M, j)
x1 ……………………………… xM
y1 …
……
……
……
……
……
…
yN
47
Overlap Alignment Example
H E A G A W G H E E
0 0 0 0 0 0 0 0 0 0 0
P 0
A 0
W 0
H 0
E 0
A 0
E 0
s = PAWHEAEt = HEAGAWGHEE
Scoring system: Match: +4 Mismatch: -1 Indel: -5
48
Recurrence: as in global alignment
Score: maximum value at the bottom line and rightmost line in the matrix
Overlap Alignment
Initialization: V[i,0]=0 , V[0,j]=0
])[,(],[
)],[(],[
])[],[(],[
max],[
1jtj1iV
1is1jiV
1jt1isjiV
1j1iV
49
Overlap Alignment Example
H E A G A W G H E E
0 0 0 0 0 0 0 0 0 0 0
P 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
A 0 -1
W 0 -1
H 0 4
E 0 -1
A 0 -1
E 0 -1
s = PAWHEAEt = HEAGAWGHEE
Scoring system: Match: +4 Mismatch: -1 Indel: -5
50
Overlap Alignment Example
H E A G A W G H E E
0 0 0 0 0 0 0 0 0 0 0
P 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
A 0 -1 -2 3 -2 3 -2 -2 -2 -2 -2
W 0 -1 -2 -2 2 -2 7 2 -3 -3 -1
H 0 4 -1 -3 -3 1 2 6 6 1 -2
E 0 -1 8 3 -2 -3 0 1 5 10 5
A 0 -1 3 12 7 2 -2 -1 0 5 9
E 0 -1 3 7 11 6 1 -3 -2 4 9
s = PAWHEAEt = HEAGAWGHEE
Scoring system: Match: +4 Mismatch: -1 Indel: -5
51
Overlap Alignment Example
The best overlap is:
PAWHEAE------ ---HEAGAWGHEE
Pay attention! A different scoring system could yield a different result, such as:
---PAW-HEAE HEAGAWGHEE-
The local alignment problem
Given two strings x = x1……xM,
y = y1……yN
Find substrings x’, y’ whose similarity (optimal global alignment value)is maximum
x = aaaacccccggggttay = ttcccgggaaccaacc
Why local alignment – examples
• Genes are shuffled between genomes
• Portions of proteins (domains) are often conserved
54
Cross-species genome similarity
98% of genes are conserved between any two mammals >70% average similarity in protein sequence
hum_a : GTTGACAATAGAGGGTCTGGCAGAGGCTC--------------------- @ 57331/400001mus_a : GCTGACAATAGAGGGGCTGGCAGAGGCTC--------------------- @ 78560/400001rat_a : GCTGACAATAGAGGGGCTGGCAGAGACTC--------------------- @ 112658/369938fug_a : TTTGTTGATGGGGAGCGTGCATTAATTTCAGGCTATTGTTAACAGGCTCG @ 36008/68174 hum_a : CTGGCCGCGGTGCGGAGCGTCTGGAGCGGAGCACGCGCTGTCAGCTGGTG @ 57381/400001mus_a : CTGGCCCCGGTGCGGAGCGTCTGGAGCGGAGCACGCGCTGTCAGCTGGTG @ 78610/400001rat_a : CTGGCCCCGGTGCGGAGCGTCTGGAGCGGAGCACGCGCTGTCAGCTGGTG @ 112708/369938fug_a : TGGGCCGAGGTGTTGGATGGCCTGAGTGAAGCACGCGCTGTCAGCTGGCG @ 36058/68174
hum_a : AGCGCACTCTCCTTTCAGGCAGCTCCCCGGGGAGCTGTGCGGCCACATTT @ 57431/400001mus_a : AGCGCACTCG-CTTTCAGGCCGCTCCCCGGGGAGCTGAGCGGCCACATTT @ 78659/400001rat_a : AGCGCACTCG-CTTTCAGGCCGCTCCCCGGGGAGCTGCGCGGCCACATTT @ 112757/369938fug_a : AGCGCTCGCG------------------------AGTCCCTGCCGTGTCC @ 36084/68174 hum_a : AACACCATCATCACCCCTCCCCGGCCTCCTCAACCTCGGCCTCCTCCTCG @ 57481/400001mus_a : AACACCGTCGTCA-CCCTCCCCGGCCTCCTCAACCTCGGCCTCCTCCTCG @ 78708/400001rat_a : AACACCGTCGTCA-CCCTCCCCGGCCTCCTCAACCTCGGCCTCCTCCTCG @ 112806/369938fug_a : CCGAGGACCCTGA------------------------------------- @ 36097/68174
“atoh” enhancer in human, mouse, rat, fugu fish
The Smith-Waterman algorithm
Idea: Ignore badly aligning regions
Modifications to Needleman-Wunsch:
Initialization: F(0, j) = F(i, 0) = 0
0
Iteration: F(i, j) = max F(i – 1, j) – d
F(i, j – 1) – d
F(i – 1, j – 1) + s(xi, yj)
The Smith-Waterman algorithm
Termination:
1. If we want the best local alignment…
FOPT = maxi,j F(i, j)
Find FOPT and trace back
2. If we want all local alignments scoring > t
?? For all i, j find F(i, j) > t, and trace back?
Complicated by overlapping local alignments
Waterman–Eggert ’87: find all non-overlapping local alignments with minimal recalculation of the DP matrix
57
Local Alignment
New option: We can start a new match instead of extending a
previous alignment
0
1jtj1iV1is1jiV
1jt1isjiV
1j1iV])[,(],[)],[(],[
])[],[(],[
max],[
Alignment of empty suffixes
]))1[,(],0[,0max(]1,0[
))],1[(]0,[,0max(]0,1[
0]0,0[
jtjVjV
isiViV
V
58
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
59
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
60
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
61
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
62
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
63
Alignment with gaps
Observation: Insertions and deletions often occur in blocks longer than a single nucleotide.
mlengthofgapPmlengthofgapP )1()(
Consequence: Standard scoring of alignment studied in lecture, which give a constant penalty d per gap unit , does not score well this phenomenon; Hence, a better gap score model is needed.Question: Can you think of an appropriate change to the scoring system for gaps?
Scoring the gaps more accurately
Current model:
Gap of length nincurs penalty nd
However, gaps usually occur in bunches
Convex gap penalty function:
(n):for all n, (n + 1) - (n) (n) - (n – 1)
(n)
(n)
Convex gap dynamic programming
Initialization: same
Iteration:
F(i – 1, j – 1) + s(xi, yj)
F(i, j) = max maxk=0…i-1F(k, j) – (i – k)
maxk=0…j-1F(i, k) – (j – k)
Termination: same
Running Time: O(N2M) (assume N>M)
Space: O(NM)
Compromise: affine gaps
(n) = d + (n – 1)e | | gap gap open extend
To compute optimal alignment,
At position i, j, need to “remember” best score if gap is open best score if gap is not open
F(i, j): score of alignment x1…xi to y1…yj
if xi aligns to yj
G(i, j): score if xi aligns to a gap after yj
H(i, j): score if yj aligns to a gap after xi
V(i, j) = best score of alignment x1…xi to y1…yj
de
(n)
67
Needleman-Wunsch with affine gaps
Why do we need two matrices?
• xi aligns to yj
x1……xi-1 xi xi+1
y1……yj-1 yj -
2. xi aligns to a gap
x1……xi-1 xi xi+1
y1……yj …- -
Add -d
Add -e
Needleman-Wunsch with affine gaps
Why do we need matrices F, G, H?
• xi aligns to yj
x1……xi-1 xi xi+1
y1……yj-1 yj -
• xi aligns to a gap after yj
x1……xi-1 xi xi+1
y1……yj …- -
Add -d
Add -e
G(i+1, j) = F(i, j) – d
G(i+1, j) = G(i, j) – e
Because, perhaps
G(i, j) < V(i, j)
(it is best to align xi to yj if we were aligningonly x1…xi to y1…yj and not the rest of x, y),
but on the contrary
G(i, j) – e > V(i, j) – d
(i.e., had we “fixed” our decision that xi alignsto yj, we could regret it at the next step whenaligning x1…xi+1 to y1…yj)
Needleman-Wunsch with affine gaps
Initialization: V(i, 0) = d + (i – 1)eV(0, j) = d + (j – 1)e
Iteration:V(i, j) = max{ F(i, j), G(i, j), H(i, j) }
F(i, j) = V(i – 1, j – 1) + s(xi, yj)
V(i – 1, j) – d G(i, j) = max
G(i – 1, j) – e
V(i, j – 1) – d H(i, j) = max
H(i, j – 1) – e
Termination: V(i, j) has the best alignmentTime?
Space?
To generalize a bit…
… think of how you would compute optimal alignment with this gap function
….in time O(MN)
(n)
71
Remark: Edit Distance
Instead of speaking about the score of an alignment, one often talks about an edit distance between two sequences, defined to be the “cost” of the “cheapest” set of edit operations needed to transform one sequence into the other.
· Cheapest operation is “no change”· Next cheapest operation is “replace”· The most expensive operation is “add space”.
Our goal is now to minimize the cost of operations, which is exactly what we actually did.
72
Where do scoring rules come from ?
We have defined an additive scoring function by specifying a function ( , ) such that· (x,y) is the score of replacing x by y· (x,-) is the score of deleting x· (-,x) is the score of inserting x
But how do we come up with the “correct” score ?
Answer: By encoding experience of what are similar sequences for the task at hand.
76
Substitution matrix There exist several matrix based on this scoring scheme but
differing by the way the statistic is computed The two major one are PAM and BLOSUM PAM 1 correspond to statistics computed from an global
alignments of proteins with at most 1% of mutations Other PAM matrix (until PAM 250) are extrapolated by
matrix products BLOSUM 62 correspond to statistics from local alignments
with 62% of similarity. Other BLOSUM matrix are build from other alignments
PAM100 ==> Blosum90 PAM120 ==> Blosum80 PAM160 ==> Blosum60 PAM200 ==> Blosum52
PAM250 ==> Blosum45
Linear-Space Alignment
Subsequences and Substrings
Definition A string x’ is a substring of a string x,if x = ux’v for some prefix string u and suffix string v
(similarly, x’ = xi…xj, for some 1 i j |x|)
A string x’ is a subsequence of a string xif x’ can be obtained from x by deleting 0 or more letters
(x’ = xi1…xik, for some 1 i1 … ik |x|)
Note: a substring is always a subsequence
Example: x = abracadabray = cadabr; substringz = brcdbr; subseqence, not substring
Hirschberg’s algortihm
Given a set of strings x, y,…, a common subsequence is a string u that is a subsequence of all strings x, y, …
• Longest common subsequence Given strings x = x1 x2 … xM, y = y1 y2 … yN, Find longest common subsequence u = u1 … uk
• Algorithm:F(i – 1, j)
• F(i, j) = max F(i, j – 1)F(i – 1, j – 1) + [1, if xi = yj; 0 otherwise]
• Ptr(i, j) = (same as in N-W)
• Termination: trace back from Ptr(M, N), and prepend a letter to u whenever • Ptr(i, j) = DIAG and F(i – 1, j – 1) < F(i, j)
• Hirschberg’s original algorithm solves this in linear space
F(i,j)
Introduction: Compute optimal score
It is easy to compute F(M, N) in linear space
Allocate ( column[1] )
Allocate ( column[2] )
For i = 1….M
If i > 1, then:
Free( column[ i – 2 ] )
Allocate( column[ i ] )
For j = 1…N
F(i, j) = …
Linear-space alignment
To compute both the optimal score and the optimal alignment:
Divide & Conquer approach:
Notation:
xr, yr: reverse of x, y
E.g. x = accgg;
xr = ggcca
Fr(i, j): optimal score of aligning xr1…xr
i & yr1…yr
j
same as aligning xM-i+1…xM & yN-j+1…yN
Linear-space alignment
Lemma: (assume M is even)
F(M, N) = maxk=0…N( F(M/2, k) + Fr(M/2, N – k) )
x
y
M/2
k*
F(M/2, k) Fr(M/2, N – k)
Example:ACC-GGTGCCCAGGACTG--CATACCAGGTG----GGACTGGGCAG
k* = 8
Linear-space alignment
• Now, using 2 columns of space, we can compute
for k = 1…M, F(M/2, k), Fr(M/2, N – k)
PLUS the backpointers
x1 … xM/2
y1
xM
yN
x1 … xM/2+1 xM
…
y1
yN
…
Linear-space alignment
• Now, we can find k* maximizing F(M/2, k) + Fr(M/2, N-k)
• Also, we can trace the path exiting column M/2 from k*
k*
k*+1
0 1 …… M/2 M/2+1 …… M M+1
Linear-space alignment
• Iterate this procedure to the left and right!
N-k*
M/2M/2
k*
Linear-space alignment
Hirschberg’s Linear-space algorithm:
MEMALIGN(l, l’, r, r’): (aligns xl…xl’ with yr…yr’)
1. Let h = (l’-l)/22. Find (in Time O((l’ – l) (r’ – r)), Space O(r’ – r))
the optimal path, Lh, entering column h – 1, exiting column hLet k1 = pos’n at column h – 2 where Lh enters
k2 = pos’n at column h + 1 where Lh exits
3. MEMALIGN(l, h – 2, r, k1)
4. Output Lh
5. MEMALIGN(h + 1, l’, k2, r’)
Top level call: MEMALIGN(1, M, 1, N)
Linear-space alignment
Time, Space analysis of Hirschberg’s algorithm: To compute optimal path at middle column,
For box of size M N,Space: 2NTime: cMN, for some constant c
Then, left, right calls cost c( M/2 k* + M/2 (N – k*) ) = cMN/2
All recursive calls cost Total Time: cMN + cMN/2 + cMN/4 + ….. = 2cMN = O(MN)
Total Space: O(N) for computation, O(N + M) to store the optimal alignment
Heuristic Local Alignerers
1. The basic indexing & extension technique
2. Indexing: techniques to improve sensitivityPairs of Words, Patterns
3. Systems for local alignment
Indexing-based local alignment
Dictionary:
All words of length k (~10)
Alignment initiated between words of alignment score T
(typically T = k)
Alignment:
Ungapped extensions until score
below statistical threshold
Output:
All local alignments with score
> statistical threshold
……
……
query
DB
query
scan
Indexing-based local alignment—Extensions
A C G A A G T A A G G T C C A G T
C
T
G
A
T
C C
T
G
G
A
T
T
G C
G
A
Gapped extensions until threshold
• Extensions with gaps until score < C below best score so far
Output:
GTAAGGTCCAGTGTTAGGTC-AGT
Sensitivity-Speed Tradeoff
long words(k = 15)
short words(k = 7)
Sensitivity Speed
Kent WJ, Genome Research 2002
Sens.
Speed
X%
Sensitivity-Speed Tradeoff
Methods to improve sensitivity/speed
1. Using pairs of words
2. Using inexact words
3. Patterns—non consecutive positions
……ATAACGGACGACTGATTACACTGATTCTTAC……
……GGCACGGACCAGTGACTACTCTGATTCCCAG……
……ATAACGGACGACTGATTACACTGATTCTTAC……
……GGCGCCGACGAGTGATTACACAGATTGCCAG……
TTTGATTACACAGAT T G TT CAC G
Measured improvement
Kent WJ, Genome Research 2002
Non-consecutive words—Patterns
Patterns increase the likelihood of at least one match within a long conserved region
3 common
5 common
7 common
Consecutive Positions Non-Consecutive Positions
6 common
On a 100-long 70% conserved region: Consecutive Non-consecutive
Expected # hits: 1.07 0.97Prob[at least one hit]: 0.30 0.47
Advantage of Patterns
11 positions
11 positions
10 positions
Multiple patterns
• K patterns Takes K times longer to scan Patterns can complement one another
• Computational problem: Given: a model (prob distribution) for homology between two regions Find: best set of K patterns that maximizes Prob(at least one match)
TTTGATTACACAGAT T G TT CAC G T G T C CAG TTGATT A G
Buhler et al. RECOMB 2003Sun & Buhler RECOMB 2004
How long does it take to search the query?
Variants of BLAST
• NCBI BLAST: search the universe http://www.ncbi.nlm.nih.gov/BLAST/• MEGABLAST: http://genopole.toulouse.inra.fr/blast/megablast.html
Optimized to align very similar sequences• Works best when k = 4i 16• Linear gap penalty
• WU-BLAST: (Wash U BLAST) http://blast.wustl.edu/ Very good optimizations Good set of features & command line arguments
• BLAT http://genome.ucsc.edu/cgi-bin/hgBlat Faster, less sensitive than BLAST Good for aligning huge numbers of queries
• CHAOS http://www.cs.berkeley.edu/~brudno/chaos Uses inexact k-mers, sensitive
• PatternHunter http://www.bioinformaticssolutions.com/products/ph/index.php Uses patterns instead of k-mers
• BlastZ http://www.psc.edu/general/software/packages/blastz/ Uses patterns, good for finding genes
• Typhon http://typhon.stanford.edu Uses multiple alignments to improve sensitivity/speed tradeoff