Upload
marcos-castro
View
1.421
Download
0
Embed Size (px)
Citation preview
1
Algoritmo de Smith-Waterman
Alinhamento local
Marcos Castro
2
Introdução
O algoritmo de Smith-Waterman é um algoritmo para a realização de alinhamento local de sequências.
O algoritmo foi proposto em 1981 por Smith e Waterman e é uma variação do algoritmo Needleman-Wunsch, portanto, Smith-Waterman é um algoritmo de programação dinâmica.
O algoritmo garante encontrar o alinhamento local ótimo.
3
Algoritmo de Smith-Waterman
O algoritmo faz uso de uma matriz de pontuação (scores) para medir a similaridade entre os caracteres.
Temos os parâmetros: match (caracteres iguais), mismatch (caracteres diferentes) e gap penalty (penalidade por lacuna).
Exemplo: match = 1, mismatch = -1 e gap penalty = -1.
4
Supor uma sequência s1 e outra sequência s2, tam_s1 e tam_s2 serão os tamanhos dessas sequências.
“M” será o nome da nossa matriz. O primeiro passo é alocar uma matriz (tam_s2 + 1) linhas por (tam_s1 + 1) colunas.
Iremos indexar a partir do zero. M[0][0] corresponde ao elemento da primeira linha e primeira coluna, M[0][1] corresponde ao elemento da primeira linha e segunda coluna e assim por diante.
Algoritmo de Smith-Waterman
5
Algoritmo de Smith-Waterman
A primeira linha e primeira coluna serão inicializadas com 0.
Iremos alinhar as sequências:
Sequência 1: GGAT
Sequência 2: GAT
- G G A T
- 0 0 0 0 0
G 0
A 0
T 0
6
Para preencher o restante da matriz, precisamos calcular o valor que vem da diagonal superior esquerda, do topo e da esquerda de cada célula da matriz. Iremos calcular esses valores para M[1][1] que está representado pelo ponto de interrogação.
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 ?
A 0
T 0
7
O valor da diagonal é calculado:
diagonal = M[i - 1][j - 1] + score
“score” será igual a “match” se os caracteres forem iguais, caso contrário será igual a “mismatch”.
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 ?
A 0
T 0
8
diagonal = M[i - 1][j - 1] + score
Para M[1][1] (i = 1 e j = 1) ficará:
diagonal = M[0][0] + score
diagonal = 0 + (+1) (match) = 1
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 ?
A 0
T 0
9
O topo calcula-se da seguinte forma:
topo = M[i - 1][j] + gap_penalty
Para M[1][1] temos que (gap_penalty = -1):
topo = M[0][1] + (-1) = 0 + (-1) = -1
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 ?
A 0
T 0
10
A esquerda calcula-se da seguinte forma:
esquerda = M[i][j - 1] + gap_penalty
Para M[1][1] temos que (gap_penalty = -1):
esquerda = M[1][0] + (-1) = 0 + (-1) = -1
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 ?
A 0
T 0
11
Temos os valores da diagonal, do topo e da esquerda:
diagonal = 1, topo = -1, esquerda = -1
Para saber o M[1][1] basta calcular o máximo desses valores incluindo o 0:
M[1][1] = max(0, 1, -1, -1) = 0
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 ?
A 0
T 0
12
Agora iremos calcular o M[1][2]:
diagonal = 0 + (+1) (match) = 1
topo = 0 + (-1) = -1
esquerda = 1 + (-1) = 0
M[1][2] = max(0, 1, -1, 0) = 1
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 ?
A 0
T 0
13
Matriz preenchida:
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 1 0 0
A 0 0 0 2 1
T 0 0 0 1 3
14
O algoritmo permite reconhecer qual a célula que deu origem a cada entrada da matriz. Essa precedência é indicada pelas setas.
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 1 0 0
A 0 0 0 2 1
T 0 0 0 1 3
15
O processo de backtracking começa da célula da matriz de pontuação mais alta (no nosso caso é a M[3][4]) e continua até que uma célula com pontuação zero seja encontrada.
M[3][4] veio da diagonal, então as duas sequências recebem caracteres.
Sequência 1: T
Sequência 2: T
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 1 0 0
A 0 0 0 2 1
T 0 0 0 1 3
16
M[2][3] veio da diagonal, então as duas sequências recebem caracteres.
Sequência 1: AT
Sequência 2: AT
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 1 0 0
A 0 0 0 2 1
T 0 0 0 1 3
17
M[1][2] veio da diagonal, então as duas sequências recebem caracteres.
Sequência 1: GAT
Sequência 2: GAT
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 1 0 0
A 0 0 0 2 1
T 0 0 0 1 3
18
M[0][1] é 0, então o processo de alinhamento terminou.
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 1 0 0
A 0 0 0 2 1
T 0 0 0 1 3
19
Se tivesse uma seta apontando para o topo, colocaríamos uma lacuna na sequência 1 e o caractere na sequência 2.
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 1 0 0
A 0 0 0 2 1
T 0 0 0 1 3
20
Se tivesse uma seta apontando para a esquerda, colocaríamos o caractere na sequência 1 e a lacuna na sequência 2.
Algoritmo de Smith-Waterman
- G G A T
- 0 0 0 0 0
G 0 1 1 0 0
A 0 0 0 2 1
T 0 0 0 1 3
21
A implementação foi feita utilizando a linguagem de programação Python. O código encontra-se no endereço:
https://github.com/marcoscastro/msc_bioinfo/tree/master/smith_waterman
Para executar o nosso exemplo basta fazer:
python smith_waterman.py GGAT GAT 1 -1 -1
GGAT e GAT são as sequências. 1, -1 e -1 são os parâmetros match, mismatch e gap_penalty respectivamente.
Implementação
23
http://pt.slideshare.net/avrilcoghlan/the-smith-waterman-algorithm
http://en.wikipedia.org/wiki/Smith-Waterman_algorithm
http://web.ist.utl.pt/ist155746/relatorio_2_bc.pdf
Referências