Biopython - Alinhamentos de Sequência

Sequence alignment é o processo de organizar duas ou mais sequências (de DNA, RNA ou sequências de proteínas) em uma ordem específica para identificar a região de similaridade entre elas.

Identificar a região semelhante nos permite inferir muitas informações, como quais características são conservadas entre as espécies, quão próximas as espécies são geneticamente diferentes, como as espécies evoluem, etc. Biopython fornece amplo suporte para alinhamento de sequência.

Vamos aprender alguns dos recursos importantes fornecidos pelo Biopython neste capítulo -

Parsing Sequence Alignment

Biopython fornece um módulo, Bio.AlignIO, para ler e gravar alinhamentos de sequência. Em bioinformática, existem muitos formatos disponíveis para especificar os dados de alinhamento de sequência semelhantes aos dados de sequência aprendidos anteriormente. Bio.AlignIO fornece API semelhante ao Bio.SeqIO, exceto que o Bio.SeqIO funciona nos dados de sequência e Bio.AlignIO funciona nos dados de alinhamento de sequência.

Antes de começar a aprender, vamos baixar um arquivo de amostra de alinhamento de sequência da Internet.

Para baixar o arquivo de amostra, siga as etapas abaixo -

Step 1 - Abra seu navegador favorito e vá para http://pfam.xfam.org/family/browselocal na rede Internet. Ele mostrará todas as famílias Pfam em ordem alfabética.

Step 2- Escolha qualquer família com menos número de valor de semente. Ele contém dados mínimos e nos permite trabalhar facilmente com o alinhamento. Aqui, selecionamos / clicamos PF18225 e ele abre, vá parahttp://pfam.xfam.org/family/PF18225 e mostra detalhes completos sobre ele, incluindo alinhamentos de sequência.

Step 3 - Vá para a seção de alinhamento e baixe o arquivo de alinhamento de sequência no formato Estocolmo (PF18225_seed.txt).

Vamos tentar ler o arquivo de alinhamento de sequência baixado usando Bio.AlignIO como abaixo -

Módulo de importação Bio.AlignIO

>>> from Bio import AlignIO

Leia o alinhamento usando o método de leitura. O método read é usado para ler os dados de alinhamento único disponíveis no arquivo fornecido. Se o arquivo fornecido contém muitos alinhamentos, podemos usar o método de análise. O método parse retorna o objeto de alinhamento iterável semelhante ao método parse no módulo Bio.SeqIO.

>>> alignment = AlignIO.read(open("PF18225_seed.txt"), "stockholm")

Imprima o objeto de alinhamento.

>>> print(alignment)
SingleLetterAlphabet() alignment with 6 rows and 65 columns
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVA...EGP B7RZ31_9GAMM/59-123 
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADIT...KKP A0A0C3NPG9_9PROT/58-119 
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMA...KKP A0A143HL37_9GAMM/57-121 
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMA...NKP A0A0X3UC67_9GAMM/57-121 
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIM...NRK B3PFT7_CELJU/62-126 
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVA...NRT K4KEM7_SIMAS/61-125
>>>

Também podemos verificar as sequências (SeqRecord) disponíveis no alinhamento, bem como abaixo -

>>> for align in alignment: 
... print(align.seq) 
... 
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVATVANQLRGRKRRAFARHREGP 
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADITA---RLDRRREHGEHGVRKKP 
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMAPMLIALNYRNRESHAQVDKKP 
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMAPLFKVLSFRNREDQGLVNNKP 
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIMVLAPRLTAKHPYDKVQDRNRK 
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVADLMRKLDLDRPFKKLERKNRT 
>>>

Alinhamentos Múltiplos

Em geral, a maioria dos arquivos de alinhamento de sequência contém dados de alinhamento único e é o suficiente para usar readmétodo para analisá-lo. No conceito de alinhamento de sequência múltipla, duas ou mais sequências são comparadas para melhores correspondências de subsequência entre elas e resulta em alinhamento de sequência múltipla em um único arquivo.

Se o formato de alinhamento de sequência de entrada contiver mais de um alinhamento de sequência, então precisamos usar parse método em vez de read método conforme especificado abaixo -

>>> from Bio import AlignIO 
>>> alignments = AlignIO.parse(open("PF18225_seed.txt"), "stockholm") 
>>> print(alignments) 
<generator object parse at 0x000001CD1C7E0360> 
>>> for alignment in alignments: 
... print(alignment) 
... 
SingleLetterAlphabet() alignment with 6 rows and 65 columns 
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVA...EGP B7RZ31_9GAMM/59-123 
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADIT...KKP A0A0C3NPG9_9PROT/58-119 
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMA...KKP A0A143HL37_9GAMM/57-121 
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMA...NKP A0A0X3UC67_9GAMM/57-121 
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIM...NRK B3PFT7_CELJU/62-126 
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVA...NRT K4KEM7_SIMAS/61-125
>>>

Aqui, o método parse retorna o objeto de alinhamento iterável e pode ser iterado para obter os alinhamentos reais.

Alinhamento de sequência em pares

Pairwise sequence alignment compara apenas duas sequências por vez e fornece os melhores alinhamentos de sequência possíveis. Pairwise é fácil de entender e excepcional de inferir a partir do alinhamento de sequência resultante.

Biopython oferece um módulo especial, Bio.pairwise2para identificar a sequência de alinhamento usando o método de pares. Biopython aplica o melhor algoritmo para encontrar a sequência de alinhamento e é compatível com outro software.

Vamos escrever um exemplo para encontrar o alinhamento de sequência de duas sequências simples e hipotéticas usando o módulo de pares. Isso nos ajudará a entender o conceito de alinhamento de sequência e como programá-lo usando Biopython.

Passo 1

Importar o módulo pairwise2 com o comando dado abaixo -

>>> from Bio import pairwise2

Passo 2

Crie duas sequências, seq1 e seq2 -

>>> from Bio.Seq import Seq 
>>> seq1 = Seq("ACCGGT") 
>>> seq2 = Seq("ACGT")

etapa 3

Chame o método pairwise2.align.globalxx junto com seq1 e seq2 para encontrar os alinhamentos usando a linha de código abaixo -

>>> alignments = pairwise2.align.globalxx(seq1, seq2)

Aqui, globalxxO método executa o trabalho real e encontra todos os melhores alinhamentos possíveis nas sequências fornecidas. Na verdade, Bio.pairwise2 fornece um grande conjunto de métodos que seguem a convenção abaixo para encontrar alinhamentos em diferentes cenários.

<sequence alignment type>XY

Aqui, o tipo de alinhamento de sequência se refere ao tipo de alinhamento que pode ser global ou local. o tipo global é encontrar o alinhamento da sequência levando em consideração a sequência inteira. tipo local é encontrar o alinhamento da sequência examinando também o subconjunto das sequências fornecidas. Isso será tedioso, mas fornece uma ideia melhor sobre a semelhança entre as sequências fornecidas.

X refere-se à pontuação correspondente. Os valores possíveis são x (correspondência exata), m (pontuação baseada em caracteres idênticos), d (dicionário fornecido pelo usuário com caractere e pontuação de correspondência) e finalmente c (função definida pelo usuário para fornecer algoritmo de pontuação personalizado).
Y refere-se à penalidade de intervalo. Os valores possíveis são x (sem penalidades de gap), s (mesmas penalidades para ambas as sequências), d (penalidades diferentes para cada sequência) e finalmente c (função definida pelo usuário para fornecer penalidades de gap customizadas)

Portanto, localds também é um método válido, que encontra o alinhamento de sequência usando a técnica de alinhamento local, dicionário fornecido pelo usuário para correspondências e penalidade de intervalo fornecida pelo usuário para ambas as sequências.

>>> test_alignments = pairwise2.align.localds(seq1, seq2, blosum62, -10, -1)

Aqui, blosum62 se refere a um dicionário disponível no módulo pairwise2 para fornecer a pontuação de correspondência. -10 refere-se à penalidade de abertura de gap e -1 refere-se à penalidade de extensão de gap.

Passo 4

Faça um loop sobre o objeto de alinhamento iterável, obtenha cada objeto de alinhamento individual e imprima-o.

>>> for alignment in alignments: 
... print(alignment) 
... 
('ACCGGT', 'A-C-GT', 4.0, 0, 6) 
('ACCGGT', 'AC--GT', 4.0, 0, 6) 
('ACCGGT', 'A-CG-T', 4.0, 0, 6) 
('ACCGGT', 'AC-G-T', 4.0, 0, 6)

Etapa 5

O módulo Bio.pairwise2 fornece um método de formatação, format_alignment para melhor visualizar o resultado -

>>> from Bio.pairwise2 import format_alignment 
>>> alignments = pairwise2.align.globalxx(seq1, seq2) 
>>> for alignment in alignments: 
... print(format_alignment(*alignment)) 
...

ACCGGT 
| | || 
A-C-GT 
   Score=4 
   
ACCGGT 
|| || 
AC--GT 
   Score=4 

ACCGGT 
| || | 
A-CG-T 
   Score=4 

ACCGGT 
|| | | 
AC-G-T 
   Score=4

>>>

Biopython também fornece outro módulo para fazer o alinhamento de sequência, Alinhar. Este módulo fornece um conjunto diferente de API para simplesmente definir parâmetros como algoritmo, modo, pontuação de correspondência, penalidades de lacuna, etc. Uma olhada simples no objeto Align é a seguinte -

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> print(aligner)
Pairwise sequence aligner with parameters
   match score: 1.000000
   mismatch score: 0.000000
   target open gap score: 0.000000
   target extend gap score: 0.000000
   target left open gap score: 0.000000
   target left extend gap score: 0.000000
   target right open gap score: 0.000000
   target right extend gap score: 0.000000
   query open gap score: 0.000000
   query extend gap score: 0.000000
   query left open gap score: 0.000000
   query left extend gap score: 0.000000
   query right open gap score: 0.000000
   query right extend gap score: 0.000000
   mode: global
>>>

Suporte para ferramentas de alinhamento de sequência

Biopython fornece interface para várias ferramentas de alinhamento de sequência através do módulo Bio.Align.Applications. Algumas das ferramentas estão listadas abaixo -

ClustalW
MUSCLE
Agulha EMBOSS e água

Vamos escrever um exemplo simples no Biopython para criar o alinhamento de sequência por meio da ferramenta de alinhamento mais popular, ClustalW.

Step 1 - Baixe o programa Clustalw de http://www.clustal.org/download/current/e instale-o. Além disso, atualize o PATH do sistema com o caminho de instalação “clustal”.

Step 2 - importe ClustalwCommanLine do módulo Bio.Align.Applications.

>>> from Bio.Align.Applications import ClustalwCommandline

Step 3 - Defina o cmd chamando ClustalwCommanLine com o arquivo de entrada, opuntia.fasta disponível no pacote Biopython. https://raw.githubusercontent.com/biopython/biopython/master/Doc/examples/opuntia.fasta

>>> cmd = ClustalwCommandline("clustalw2",
infile="/path/to/biopython/sample/opuntia.fasta")
>>> print(cmd)
clustalw2 -infile=fasta/opuntia.fasta

Step 4 - Chamar cmd () executará o comando clustalw e fornecerá uma saída do arquivo de alinhamento resultante, opuntia.aln.

>>> stdout, stderr = cmd()

Step 5 - Leia e imprima o arquivo de alinhamento conforme abaixo -

>>> from Bio import AlignIO
>>> align = AlignIO.read("/path/to/biopython/sample/opuntia.aln", "clustal")
>>> print(align)
SingleLetterAlphabet() alignment with 7 rows and 906 columns
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273285|gb|AF191659.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273284|gb|AF191658.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273287|gb|AF191661.1|AF191
TATACATAAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273286|gb|AF191660.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273290|gb|AF191664.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273289|gb|AF191663.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273291|gb|AF191665.1|AF191
>>>