Métodos alternativos para gera¸cão da popula¸cão inicial

5.2 Alinhadores iterativos estoc´asticos

5.2.8 Métodos alternativos para gera¸cão da popula¸cão inicial

Ao final dos testes descritos na Se¸cão 5.2.6, tinha-se um alinhador múltiplo capaz de obter 80,81 para pontua¸cão SP e 56,80 para pontua¸cão TC. Essas pontua¸cões referem-se a média para todas as entradas do conjunto RV12. Nesta se¸cão são descritas e avaliadas altera¸cões no procedimento de gera¸cão da popula¸cão inicial, denominado Algoritmo 1 e detalhado na Se¸cão 5.2.1.

Como um primeiro teste, adicionou-se uma terceira abordagem para gera¸cão de indiv´ıduos. Gera-se mais um indiv´ıduo utilizando o método ABOT, que é descrito a seguir. Este faz uso de janela deslizante, grafo orientado e ordena¸cão topológica para construir alinhamentos de pares. Para produzir o alinhamento múltiplo utiliza uma varia¸cão do alinhamento estrela. Denominou-se essa varia¸cão, em rela¸cão ao método original para gera¸cão da popula¸cão inicial, de Algoritmo 2.

Um outro teste consistiu em adicionar ao Algoritmo 2 outros novos métodos para a gera¸cão de indiv´ıduos. Os métodos AB1, AB2, AB3, AB4 e AB5, que são baseados em blocos, assim como ABOT, foram utilizados. Juntamente a estes, aplicou-se um refinador. Foram adicionados mais 20 indiv´ıduos. Cada alinhador baseado em blocos gerou quatro alinhamentos, o original e mais três através de refinamentos. O refinador possui um parâmetro X que indica a porcentagem m´ınima de concordância de res´ıduos para que uma coluna seja mantida. Caso contrário, ela é refeita. Utilizou-se X = 40, X = 50 e X = 60. Chamou-se esse novo procedimento para gera¸cão da popula¸cão inicial de Algoritmo 3. Esses novos métodos e o refinador são descritos a seguir.

São também apresentados a seguir os resultados obtidos com a utiliza¸cão do Algoritmo 2 e do Algoritmo 3 para gera¸cão da popula¸cão inicial.

Primeira abordagem (ABOT)

Para cada par de sequências, busca-se, utilizando uma janela deslizante de tamanho fixo k, blocos cont´ınuos (sem gaps) e idênticos. Cria-se um grafo onde cada nó representa um bloco β encontrado. Denota-se por βi e βj as posi¸cões iniciais do bloco e por βi + k e

βj + k as posi¸c˜oes finais. Arestas (orientadas) conectam blocos consistentes. Por blocos

5.2. Alinhadores iterativos estoc´asticos 107 C_(β1_{, β}2_{) =}                      β1 i + k < βi2∧ βj1+ k < βj2 ∨ (β1 i < βi2∧ βi1+ k ≥ βi2)∧ (β1 j < βj2∧ βj1+ k ≥ βj2)∧ (β2 i − βi1 = βj2− βj1)

A primeira condi¸cão é satisfeita quando um bloco antecede o outro sem qualquer sobreposi¸cão. A segunda condi¸cão trata do caso de sobreposi¸cão, garantindo que esta seja coerente nas duas sequências, ou seja, β2

i − βi1 = βj2 − βj1 ≥ 1. Na Figura 5.3 n˜ao

apresentados dois exemplos de blocos consistentes, subfiguras (a) e (b), e dois exemplos de blocos não consistentes, (c) e (d). Em cada uma deles há um bloco delimitado por um retângulo com linha cont´ınua e um outro com linha tracejada. Por exemplo, em (a) há um bloco composto pelos res´ıduos KTT que inicia no terceiro res´ıduo da primeira sequência e no primeiro da segunda. Há outro bloco composto pelos res´ıduos ADK que inicia no sétimo res´ıduo da primeira sequência e no quarto res´ıduo da segunda.

Após esse passo são criados dois nós especiais representando o in´ıcio e o fim das sequências. São também criadas arestas conectando o nó que representa o in´ıcio a todos os outros nós, assim como são criadas arestas conectando todos os nós ao nó representando o final das sequências. Procura-se então o caminho máximo nesse grafo. Tal procedimento pode ser feito em tempo polinomial, utilizando-se ordena¸cão topológica, pelo fato do grafo ser orientado e ac´ıclico. Esse caminho representa o maior conjunto consistente de blocos conservados para o par de sequências. Para alinhar as regiões entre os blocos utiliza-se o algoritmo de alinhamento global de Needleman e Wunsch[174].

Um algoritmo progressivo constrói o alinhamento múltiplo. Este utiliza uma árvore gerada por UPGMA [228] a partir de distâncias inversamente proporcionais ao número de blocos conservados entre os pares de sequência. Em seguida, utiliza-se uma varia¸cão do alinhamento estrela [219]. Para unir uma sub-árvore A com uma sub-árvore B é utilizado o par de sequências de menor distância. Observe que o par deve ser composto por uma sequência de A e outra de B. Este algoritmo usa os alinhamentos de pares já constru´ıdos para o cálculo das distâncias e para a efetiva composi¸cão do alinhamento múltiplo em sua etapa final.

Para esse m´etodo, denominado ABOT, usou-se tamanho k = 5 para a janela deslizante. Segunda abordagem (ABx)

Inicia procurando todas as substrings, de um tamanho pré-definido k, que ocorrem nas sequências de entrada. Toma-se a substring que ocorre no maior n´umero de sequências

3 1 7 4 T T Y A D K T T A D K K T T A D K T T A K T T (a) Consistentes T T Y A D K T T A D K K T T A D K T T A K T T 2 5 3 6 (b) Consistentes T T Y A D K T T A D K K T T A D K T T A K T T 4 9 1 7 (c) N˜ao consistentes T T Y A D K T T A D K K T T A D K T T A K T T 2 5 3 10 (d) N˜ao consistentes

Figura 5.3: Exemplos de blocos consistentes e de blocos n˜ao consistentes para as sequˆencias ADKTTYADKTT e KTTADKTTAKTT.

como referência para a constru¸cão do bloco, que é gerado a partir da primeira ocorrência da substring em cada sequência. Faz-se chamadas recursivas para alinhar o restante das sequências, tanto do lado esquerdo como do lado direito.

Note que ao longo da execu¸cão desse algoritmo recursivo, sequências ou regiões de sequências são “ignoradas” por não possu´ırem a substring. Essas sequências ou regiões são inseridas no alinhamento através de alinhamentos de perfis, que as adiciona em ordem arbitrária.

Utiliza-se para esse algoritmo, denominado AB1 e detalhado em Algoritmo 6, k = 6. Na implementa¸cão deste, utiliza-se o alfabeto comprimido Dayhoff(6) [67]. Sendo assim, as sequências são analisadas como uma sequência de classes e não como uma sequência de res´ıduos de aminoácidos.

Nas linhas 2 e 3 do código apresentado em Algoritmo 6 é implementada a condi¸cão de parada. Isso ocorre quando resta menos de duas sequências a alinhar. Na linha 5 é computada a substring que ocorre em um maior n´umero de sequências. Na linha 7 é gerada uma lista com a primeira ocorrência da substring em cada uma das sequências.

5.2. Alinhadores iterativos estoc´asticos 109

Algoritmo 6: Algoritmo AB1. Input: sequences

Output: msa

1 //Condi¸c˜ao de parada

10 //Separa as sequˆencias que pertencem e as que n˜ao pertencem ao bloco 11 alignedSeqs ← getAlignedSeqs(block)

12 otherSeqs ← getOtherSeqs(sequences,alignedSeqs) 13 //Realiza as chamadas recursivas

14 leftSeqs ← extractLeftSide(sequences, block) 15 leftAlign ← AB1(leftSeqs)

16 rightSeqs ← extractRightSide(sequences, block) 17 rightAlign ← AB1(rightSeqs)

18 //Combina os resultados da recurs˜ao com o bloco 19 partialAlignment ← leftAlign + block + rightAlign 20 else

21 partialAlignment ← null 22 otherSeqs ← sequences

23 //Adiciona as sequˆencias “ignoradas” ao alinhamento

24 return addSeqsByProfileAlignment(partialAlignment,otherSeqs)

Caso a substring ocorra em mais que uma sequência, é executado o bloco entre as linhas 9 e 19. Nesse caso, inicia-se computando o bloco na linha 9 e gera-se uma lista com as sequências que não foram adicionadas ao bloco nas linhas 11 e 12. Em seguida realiza-se a recursão à esquerda nas linhas 14 e 15 e a recursão à direita nas linhas 16 e 17. Esse bloco do código é conclu´ıdo com a combina¸cão dos alinhamentos obtidos pelas recursões com o bloco computado. No caso em que não for poss´ıvel gerar um bloco com pelo menos duas sequências, simplesmente define alinhamento parcial como nulo e indica que nenhuma das sequências foi alinhada ainda. O algoritmo termina pela adi¸cão das sequências “ignoradas” ao alinhamento parcialmente gerado e então retorna-se o alinhamento produzido.

Numa varia¸cão de AB1, denominada AB2 e detalhada em Algoritmo 7, tenta-se agru- par as sequências ou regiões de sequência “ignoradas” utilizando-se o algoritmo recursivo.

Podem ser criados tantos grupos quanto necessário. Os subalinhamentos oriundos dos grupos formados são agrupados por alinhamentos de perfis e as sequências ou regiões que ainda não estejam alinhadas ao final desse processo são adicionadas em ordem arbitrária através de alinhamento de perfis.

Observe que o código foi alterado apenas no bloco do código onde são realizadas as recursões. Foram inseridas as linhas 20 a 24 no final do bloco. Nelas faz-se uma chamada recursiva com as sequências que foram inicialmente “ignoradas”. Dessa forma, recursivamente, gera quantos grupos forem poss´ıveis e finaliza inserindo as sequências que ainda assim foram “ignoradas”. É nesse trecho também que é feita a combina¸cão do grupo e o alinhamento gerado com as sequências inicialmente “ignoradas”.

Numa varia¸cão de AB2, denominada AB3, em vez de construir os blocos pela esco- lha arbitrária da primeira ocorrência da substring nas sequências, realiza-se uma busca pela melhor combina¸cão de ocorrências. Para isso é realizado um passo de expansão. Para cada combina¸cão das ocorrências, expande-se lateralmente, tanto quanto poss´ıvel, o bloco. Tanto à direita quanto à esquerda, avan¸ca-se adicionando ao bloco a classe de maior ocorrência naquela hipotética nova coluna do alinhamento. O procedimento é inter- rompido quando não há ao menos duas ocorrências de uma mesma classe. Observe que o bloco pode ser formado por subsequências de comprimentos distintos. A pontua¸cão para a combina¸cão das ocorrências é dada pela soma dos comprimentos das subsequências no bloco formado ao final da expansão.

Essa varia¸cão é detalhada em Algoritmo 8. Note que a linha 7 do código foi alterada para trocar a primeira ocorrência da substring pela melhor. Foi também inserida a linha 10, onde realiza-se a expansão lateral seguida de um ajuste pela inser¸cão de gaps para eventualmente completar o bloco.

Em AB4, que é uma varia¸cão de AB3, adiciona-se um passo de expansão vertical. Este adicionará sequências que seriam “ignoradas” na recursão desde que possua uma substring com apenas uma diferen¸ca em rela¸cão a substring que ocorre em um maior n´umero de sequências. O passo de expansão lateral é realizado em seguida.

Essa varia¸cão é detalhada em Algoritmo 9. Note que agora foi inserida, na linha 10, a expansão vertical antes da expansão lateral.

A varia¸cão AB5, inspirada em AB4, é detalhada em Algoritmo 10. Adiciona-se um segundo passo de expansão lateral. Este permitirá uma classe distinta do consenso a cada k classes na sequência. Esse passo, entretanto, não é capaz de expandir a largura do bloco. As altera¸cões realizadas em rela¸cão ao algoritmo anterior estão nas linhas 11 e 12. Na linha 11 é feita a expansão lateral e em seguida a nova expansão lateral, que é mais flex´ıvel. Na próxima linha é então feito o ajuste que eventualmente insere gaps para completar o bloco.

5.2. Alinhadores iterativos estoc´asticos 111

Refinador

Tal método baseia-se em refazer colunas mal alinhadas. Para isso, busca-se por colunas com menos de X% de concordância de classe de Dayhoff(6) no alinhamento. Colunas cont´ınuas mal alinhadas determinam blocos que são refeitos.

Para refazer o bloco é utilizado um alinhador progressivo. Este usa modelo das cate- gorias do PHYLIP para computar a matriz de distâncias, UPGMA para gerar a árvore guia e par mais próximo com alinhamento de perfis e fun¸cão afim para penaliza¸cão de

gaps para produzir o alinhamento m´ultiplo.

Na Tabela 5.13 são apresentados os resultados obtidos pelos alinhadores de blocos da segunda abordagem. São apresentados também os resultados ao aplicar o refinador descrito nesta se¸cão com X = 40, X = 50 e X = 60. Os valores correspondem a média da pontua¸cão SP para todas as entradas do conjunto RV12 do BAliBASE 3.0.

Pode-se observar que o uso do refinador eleva a qualidade dos alinhamentos, assim como, à medida que ele se torna mais restritivo, observa-se também um incremento na qualidade. Observa-se uma exce¸cão a esse comportamento para AB1, que inclusive obteve os melhores resultados. Isso pode ter ocorrido por efetivamente realizar um menor per- centual de alinhamento por blocos e assim faz um maior uso do alinhamento progressivo, um algoritmo mais robusto.

Resultados

Na Tabela 5.14 são apresentados os resultados dos testes com os novos algoritmos para gera¸cão da popula¸cão inicial. Seria esperado que, pela inclusão de novos indiv´ıduos e incremento na diversidade da popula¸cão, a pontua¸cão fosse elevada a medida que novas abordagens fossem adicionadas à gera¸cão da popula¸cão inicial. Os resultados não expuse- ram isso, assim como não foi observada uma rela¸cão direta entre as pontua¸cões SP e TC. Observa-se a melhor pontua¸cão SP com o Algoritmo 2 e a melhor pontua¸cão TC com o Algoritmo 1. A varia¸cão na pontua¸cão, entretanto, é pouco significativa.

Algoritmo 7: Algoritmo AB2. Input: sequences

Output: msa

1 //Condi¸c˜ao de parada

10 //Separa as sequˆencias que pertencem e as que n˜ao pertencem ao bloco 11 alignedSeqs ← getAlignedSeqs(block)

12 otherSeqs ← getOtherSeqs(sequences,alignedSeqs) 13 //Realiza as chamadas recursivas

14 leftSeqs ← extractLeftSide(sequences, block) 15 leftAlign ← AB2(leftSeqs)

16 rightSeqs ← extractRightSide(sequences, block) 17 rightAlign ← AB2(rightSeqs)

18 //Combina os resultados da recurs˜ao com o bloco 19 partialAlignment ← leftAlign + block + rightAlign 20 //Tenta formar outro grupo e o respectivo alinhamento 21 groupAlign ← AB2(otherSeqs) 22 alignedSeqs ← getAlignedSeqs(groupAlign) 23 otherSeqs ← getOtherSeqs(otherSeqs,alignedSeqs) 24 partialAlignment ← combineByProfileAlignment(partialAlignment,groupAlign) 25 else 26 partialAlignment ← null 27 otherSeqs ← sequences

28 //Adiciona as sequˆencias “ignoradas” ao alinhamento

5.2. Alinhadores iterativos estoc´asticos 113

Algoritmo 8: Algoritmo AB3. Input: sequences

Output: msa

1 //Condi¸c˜ao de parada

2 if not canContinueAligment(sequences) then 3 return computeFinalAlignment(sequences) 4 // Computa a substring 5 substring ← computeMaxOccurSubstring(sequences) 6 //Computa o bloco 7 occurrences ← getBestSubstringOccur(sequences) 8 if length(occurrences) > 1 then 9 block ← getBlock(sequences,occurrences) 10 block ← adjustAlignment(sideExpansion(block,sequences))

11 //Separa as sequˆencias que pertencem e as que n˜ao pertencem ao bloco 12 alignedSeqs ← getAlignedSeqs(block)

13 otherSeqs ← getOtherSeqs(sequences,alignedSeqs) 14 //Realiza as chamadas recursivas

15 leftSeqs ← extractLeftSide(sequences, block) 16 leftAlign ← AB3(leftSeqs)

17 rightSeqs ← extractRightSide(sequences, block) 18 rightAlign ← AB3(rightSeqs)

19 //Combina os resultados da recurs˜ao com o bloco 20 partialAlignment ← leftAlign + block + rightAlign 21 //Tenta formar outro grupo e o respectivo alinhamento 22 groupAlign ← AB3(otherSeqs) 23 alignedSeqs ← getAlignedSeqs(groupAlign) 24 otherSeqs ← getOtherSeqs(otherSeqs,alignedSeqs) 25 partialAlignment ← combineByProfileAlignment(partialAlignment,groupAlign) 26 else 27 partialAlignment ← null 28 otherSeqs ← sequences

29 //Adiciona as sequˆencias “ignoradas” ao alinhamento

Algoritmo 9: Algoritmo AB4. Input: sequences

Output: msa

1 //Condi¸c˜ao de parada

12 //Separa as sequˆencias que pertencem e as que n˜ao pertencem ao bloco 13 alignedSeqs ← getAlignedSeqs(block)

14 otherSeqs ← getOtherSeqs(sequences,alignedSeqs) 15 //Realiza as chamadas recursivas

16 leftSeqs ← extractLeftSide(sequences, block) 17 leftAlign ← AB4(leftSeqs)

18 rightSeqs ← extractRightSide(sequences, block) 19 rightAlign ← AB4(rightSeqs)

20 //Combina os resultados da recurs˜ao com o bloco 21 partialAlignment ← leftAlign + block + rightAlign 22 //Tenta formar outro grupo e o respectivo alinhamento 23 groupAlign ← AB4(otherSeqs) 24 alignedSeqs ← getAlignedSeqs(groupAlign) 25 otherSeqs ← getOtherSeqs(otherSeqs,alignedSeqs) 26 partialAlignment ← combineByProfileAlignment(partialAlignment,groupAlign) 27 else 28 partialAlignment ← null 29 otherSeqs ← sequences

30 //Adiciona as sequˆencias “ignoradas” ao alinhamento

5.2. Alinhadores iterativos estoc´asticos 115

Algoritmo 10: Algoritmo AB5. Input: sequences

Output: msa

1 //Condi¸c˜ao de parada

13 //Separa as sequˆencias que pertencem e as que n˜ao pertencem ao bloco 14 alignedSeqs ← getAlignedSeqs(block)

15 otherSeqs ← getOtherSeqs(sequences,alignedSeqs) 16 //Realiza as chamadas recursivas

17 leftSeqs ← extractLeftSide(sequences, block) 18 leftAlign ← AB5(leftSeqs)

19 rightSeqs ← extractRightSide(sequences, block) 20 rightAlign ← AB5(rightSeqs)

21 //Combina os resultados da recurs˜ao com o bloco 22 partialAlignment ← leftAlign + block + rightAlign 23 //Tenta formar outro grupo e o respectivo alinhamento 24 groupAlign ← AB5(otherSeqs) 25 alignedSeqs ← getAlignedSeqs(groupAlign) 26 otherSeqs ← getOtherSeqs(otherSeqs,alignedSeqs) 27 partialAlignment ← combineByProfileAlignment(partialAlignment,groupAlign) 28 else 29 partialAlignment ← null 30 otherSeqs ← sequences

31 //Adiciona as sequˆencias “ignoradas” ao alinhamento

Tabela 5.13: Resultados obtidos pelos alinhadores de blocos da segunda abordagem e do refinador usando X = 40, X = 50 e X = 60.

Alinhador Sem refinamento X = 40 X = 50 X = 60

AB1 50,82 50,73 50,64 50,75

AB2 42,28 42,35 42,68 43,92

AB3 39,70 39,73 40,03 41,63

AB4 36,39 37,08 37,70 39,89

AB5 36,65 37,31 37,94 40,16

Tabela 5.14: Resultados obtidos pelo ALGAe quando variou-se o procedimento para gera¸cão da popula¸cão inicial. Os valores correspondem a média para o conjunto RV12.

Popula¸c˜ao Inicial SP TC

Algoritmo 1 80,81 56,80

Algoritmo 2 81,36 55,20

5.2. Alinhadores iterativos estoc´asticos 117

No documento Novas abordagens para o problema do alinhamento múltiplo de sequências (páginas 136-147)