campus tehuantepec - universidad del istmocomputacion/tesis/012018.pdf · 2020. 7. 23. · ii de...
TRANSCRIPT
UNIVERSIDAD DEL ISTMO
CAMPUS TEHUANTEPEC
ALINEACIÓN INEXACTA DE ADN UTILIZANDO PARALELIZACIÓN A NIVEL
DE BIT Y LA ESTRATEGIA SIEMBRA Y EXTIENDE
TESIS
QUE PARA OBTENER EL TÍTULO DE
INGENIERO EN COMPUTACIÓN
PRESENTA
JOEL MARTÍNEZ OVIEDO
DIRECTOR DE TESIS
DR. DANIEL PACHECO BAUTISTA
SANTO DOMINGO TEHUANTEPEC, OAXACA, MARZO 2018.
RESUMEN
ALINEACIÓN INEXACTA DE ADN UTILIZANDO PARALELIZACIÓN A NIVEL DE BIT Y LA ESTRATEGIA SIEMBRA Y EXTIENDE
La secuenciación de ADN es un proceso que permite obtener el orden de cada uno de los
nucleótidos que conforman la molécula de ADN. Ésta tiene una larga lista de aplicaciones,
siendo una tecnología clave para la investigación de algunos tipos de cáncer, el VIH,
diagnóstico de pacientes, o predisposición de enfermedades.
Las máquinas de secuenciación de siguiente generación (NGS), son tecnologías capaces de
secuenciar millones de cadenas de ADN al día. Sin embargo, están limitadas a secuenciar
cadenas con un número muy pequeño de nucleótidos (entre 35 y 1100), por lo que el resultado
de la secuenciación no es un genoma completo sino pequeñas lecturas cortas que representan
fragmentos del mismo. Una manera de reconstruir el genoma a partir de los milllones de
lecturas cortas es mediante el proceso denominado alineación, el cual consiste en ubicar cada
lectura corta tomando como referencia otro genoma secuenciado previamente. El problema
de la alineación es la gran cantidad de datos con la que se debe trabajar, por ejemplo para el
caso del genoma humano se tienen aproximadamente 3000 millones de nucleótidos como
referencia. Debido a esto, numerosos programas de alineación han surgido para tratar el
problema, utilizando diferentes algoritmos de elevada complejidad temporal y espacial.
Algunos son basados en programación dinámica, siendo muy precisos pero requiriendo gran
cantidad de recursos computacionales, otros son basados en heurísticas, los cuales son menos
exactos pero más rápidos, utilizando principalmente Tablas Hash o índices de FM.
Recientemente se ha optado por combinar estas técnicas para acelerar la alineación de lecturas
realizando un balance entre velocidad y precisión. Una de las estrategias modernas de
alineación es la estrategia siembra y extiende, durante la siembra se alinea de manera exacta
una semilla (subcadena) de la lectura en la referencia y en la fase de extensión se alinea la
lectura completa de forma inexacta en la región donde la semilla se alineó.
En este trabajo se desarrolla un alineador genérico basado en la estrategia siembra y extiende,
empleando los índices de FM para la etapa de siembra y para la etapa de extensión el algoritmo
ii
de programación dinámica basada en paralelización a nivel de bit propuesta por Myers. El
primer algoritmo fue elegido por considerarse uno de los más eficientes actualmente y el
segundo debido a que aprovecha el paralelismo a nivel de bit del tamaño de palabra del
procesador de una computadora para realizar los cálculos de forma rápida, además de que no
ha sido utilizado en esta aplicación en específico y se desea explorar su factibilidad.
El alineador fue codificado en el lenguaje de programación C y probado en computadoras de
32 y 64 bits. Los índices de FM fueron obtenidos mediante el alineador BWA y las lecturas
cortas se generaron de manera artificial mediante el programa Wgsim. Para la fase de
extensión se realizó una modificación adicional al algoritmo de Myers para determinar las
rutas de alineación utilizando vectores de bits. Las alineaciones realizadas fueron respecto a
cromosomas humanos de más de cuarenta millones de nucleótidos y los resultados de la
alineación de cada lectura fueron almacenados en un archivo en formato SAM. Los resultados
del alineador confirman que es factible combinar los índices de FM y el algoritmo de Myers
para realizar alineaciones de lecturas cortas y dicho algoritmo de extensión puede ser
implementado en hardware para aprovechar longitudes de palabras mayores a 64 bits.
iii
ÍNDICE DE CONTENIDO
1 INTRODUCCIÓN .................................................................................................................................. 5
1.1 Planteamiento del problema ........................................................................................................... 4
1.2 Justificación ....................................................................................................................................... 4
1.3 Hipótesis ............................................................................................................................................ 5
1.4 Objetivos ........................................................................................................................................... 5
1.4.1 Objetivo General ......................................................................................................................... 5
1.4.2 Objetivos Específicos ................................................................................................................. 5
1.5 Alcances y limitaciones .................................................................................................................... 6
1.5.1 Alcances......................................................................................................................................... 6
1.5.2 Limitaciones .................................................................................................................................. 6
1.6 Metodología ...................................................................................................................................... 7
2 MARCO DE REFERENCIA ................................................................................................................ 9
2.1 El ADN ............................................................................................................................................. 9
2.2 Secuenciación de ADN ................................................................................................................. 10
2.3 Alineación de lecturas cortas ........................................................................................................ 11
2.3.1 La alineación exacta ................................................................................................................... 11
2.3.2 La alineación inexacta ............................................................................................................... 12
2.3.3 Desplazamientos, inserciones y eliminaciones. ..................................................................... 12
2.4 La estrategia Siembra y Extiende ................................................................................................. 13
2.4.1 Técnicas de siembra .................................................................................................................. 14
2.4.1.1 Tipos de semillas ............................................................................................................... 14
2.4.1.2 Algoritmos de Siembra .................................................................................................... 17
2.4.2 Técnicas de extensión ............................................................................................................... 26
2.4.2.1 Alineación global .............................................................................................................. 27
2.4.2.2 Alineación local ................................................................................................................. 28
2.4.2.3 BLAST-like extensión de semilla ................................................................................... 29
2.5 Trabajos relacionados .................................................................................................................... 30
3 EL ALGORTIMO DE MYERS .......................................................................................................... 33
3.1 La distancia de Levenshtein .......................................................................................................... 33
3.2 La paralelización a nivel bit ........................................................................................................... 35
3.2.1 La representación ....................................................................................................................... 35
iv
3.2.2 La estructura de las celdas ........................................................................................................ 37
3.2.3 Cálculo de las celdas lógicas ..................................................................................................... 39
3.2.4 Preprocesamiento del alfabeto ................................................................................................ 41
3.2.5 Cálculo de la distancia de edición ........................................................................................... 42
3.2.6 Obteniendo los vectores X ...................................................................................................... 43
3.2.7 El algoritmo completo .............................................................................................................. 44
3.2.8 El modelo basado en bloques .................................................................................................. 45
4 DISEÑO DEL ALINEADOR ............................................................................................................ 47
4.1 Requisitos de diseño ...................................................................................................................... 47
4.2 Descripción general del programa ............................................................................................... 48
4.3 Diseño del alineador ...................................................................................................................... 50
4.3.1 La etapa de siembra ................................................................................................................... 50
4.3.1.1 El tipo de semilla .............................................................................................................. 50
4.3.1.2 Búsqueda de semillas usando índices de FM ............................................................... 51
4.3.1.3 Cálculo de regiones de siembra ...................................................................................... 52
4.3.2 La etapa de extensión ................................................................................................................ 54
4.3.2.1 Modificaciones adicionales al algoritmo de Myers ...................................................... 54
4.3.2.2 Rutas a partir de la matriz de programación dinámica ............................................... 54
4.3.3 Definiendo los vectores de bits ............................................................................................... 56
4.3.3.1 El algoritmo de Myers por bloques ............................................................................... 58
4.3.3.2 La ruta de alineación ........................................................................................................ 60
4.3.4 Implementación ......................................................................................................................... 63
4.3.4.1 Los archivos de entrada ................................................................................................... 63
4.3.4.2 La fase de siembra ............................................................................................................ 64
4.3.4.3 La fase de extensión ......................................................................................................... 65
4.3.5 Integración .................................................................................................................................. 67
5 RESULTADOS ....................................................................................................................................... 71
5.1 Requerimientos en hardware y software .................................................................................... 71
5.2 Verificación funcional del programa ........................................................................................... 72
5.3 Caracterización del alineador ........................................................................................................ 76
5.4 Comparación con otros alineadores ............................................................................................ 79
6 CONCLUSIONES Y TRABAJOS A FUTURO .............................................................................. 81
Referencias ......................................................................................................................................................... 83
v
Capítulo 1
1 INTRODUCCIÓN
Las máquinas de secuenciación de siguiente generación (NGS, del inglés Next Generation
Secuencing) son tecnologías modernas de alto rendimiento y bajo costo que pueden
secuenciar millones de cadenas de ADN al día (Jiang & Wong, 2008). La secuenciación
de ADN permite obtener el orden de las cuatro bases nucleicas (Adenina, Citosina,
Guanina y Timina). Sin embargo, estas máquinas están limitadas a secuenciar pequeños
fragmentos de la cadena original por lo que el resultado de la secuenciación no es un
genoma completo sino pequeñas lecturas cortas que representan fragmentos del genoma
(Figura 1).
Figura 1. Secuenciación de ADN.
Una forma de reconstruir el genoma original a partir de las miles de lecturas cortas es
mediante el proceso denominado alineación de lecturas de ADN. Éste consiste en
2
encontrar la ubicación correspondiente de cada lectura corta en un genoma de referencia
(Pacheco, González, & Algredo, 2015). El problema de la alineación es la gran cantidad
de lecturas con la que se debe trabajar, además, algunas lecturas cortas deben alinearse de
forma inexacta a la cadena de referencia debido a varios factores como pequeños errores
en la secuenciación, diferencias biológicas como: los Polimorfismos de Nucleótido Simple
(NSP, del inglés Single Nucleotide Polymorphism) u otras variaciones biológicas como la
inserción o eliminación de uno o más nucleótidos (Mullaney, Mills, Pittard, & Devine,
2010).
Muchos programas se han desarrollado para resolver el problema, entre los cuales se
encuentran los basados en Programación Dinámica (PD), sin embargo, a pesar de ser muy
exactos requieren demasiado tiempo de procesamiento (complejidad temporal) y elevados
requisitos de almacenamiento (complejidad espacial) (Salavert, Tárraga, Medina, Dopazo,
& Blanquer, 2015). Para subsanar lo anterior, han surgido programas basados en
heurísticas, clasificados fundamentalmente en dos categorías. La primera implementa
algoritmos basados en tablas hash, sin embargo, solo resuelven la complejidad temporal
(Langmead, Trapnell, Pop, & Salzberg, 2009); la segunda son algoritmos basados en la
Transformada de Burrows-Wheeler (TBW) (Burrows & Wheeler, 1994), la cual junto con
otras estructuras de datos particulares forman los índices de FM (Ferragina & Manzini,
2000), que representan índices eficientes para la realización de búsquedas exactas con bajo
uso de memoria.
Recientemente, se ha optado por combinar estas técnicas para acelerar la alineación de
lecturas usando el menor espacio de memoria y en el menor tiempo posible. Una de las
estrategias modernas para la alineación es utilizar un acercamiento basado en dos pasos:
la siembra y la extensión. Durante la siembra, se encuentra una subcadena de la lectura
corta de ADN que se alinee exactamente en uno o más lugares respecto a la cadena de
referencia. Para la extensión, la lectura completa es alineada de forma inexacta a una región
alrededor de la siembra previamente localizada. Muchos alineadores modernos
implementan la técnica de siembra y extiende, tal es el caso de NovoAlign (Novocraft,
2014), BWA-MEM (Li H. , 2013), Bowtie2 (Langmead & Salzberg, 2012), and Cushaw2
(Liu, Schmidt, & Maskell, 2012). Para la construcción de la siembra, dichos alineadores
3
realizan un pre-cálculo para obtener los índices de búsqueda mediante los algoritmos
basados en Tablas Hash o la TBW. Posteriormente, para la extensión implementan
algoritmos basados en PD, tales como el Smith-Waterman (Smith & Waterman, 1981),
Needleman-Wunsch (Needleman & Wunsch, 1970) o el algoritmo de extensión usado en
BLAST-like (Kent, 2002).
En este trabajo se propone el uso de índices de FM en combinación con el algoritmo de
programación dinámica basada en paralelización a nivel de bit propuesta por Myers
(Myers, 1999), el primer algoritmo fue elegido por considerarse uno de los más eficientes
(Simpson & Durbin, 2010) y el segundo debido a que no ha sido utilizado para la
alineación de cadenas de ADN y se desea explorar su factibilidad. El algoritmo de Myers
está basado en la distancia de Levenshtein para calcular la similitud entre cadenas
(Levenshtein, 1966), dicho algoritmo toma las ventajas del paralelismo a nivel de bit del
tamaño de palabra del procesador de una computadora, esto es eficiente debido a que los
procesadores realizan cálculos con un tamaño entero de palabra en un ciclo de memoria.
Básicamente, los cálculos de las puntuaciones y las comparaciones de cadenas son
obtenidos mediante una serie de operaciones binarias comprendiendo AND, OR, XOR,
complementos, desplazamientos y sumas.
El objetivo fundamental es probar la funcionalidad de la combinación de los algoritmos
mencionados, esto permitirá en un futuro implementaciones en hardware de dicha
combinación de algoritmos, donde será posible comparar la velocidad de los resultados
en hardware respecto a otros programas de alineación existentes, tales como BWA,
BLAST (Altschul, Gish, Miller, Myers, & Lipman, 1990) y Bowtie (Langmead, Trapnell,
Pop, & Salzberg, 2009).
Este trabajo forma parte del proyecto de investigación financiado por PRODEP:
“IMPLEMENTACIÓN HARDWARE DE ALGORITMOS DE ALINEACIÓN
INEXACTA PARA ACELERAR LA RE-SECUENCIACIÓN DE GENOMAS”, con
folio: UNISTMO-EXB-003 y oficio: 511-6/17-7617.
4
1.1 Planteamiento del problema
Las máquinas de secuenciación de siguiente generación pueden secuenciar millones de
cadenas de ADN al día, sin embargo, están limitadas a secuenciar sólo pequeños
fragmentos de ADN, por lo que el resultado no es una secuencia completa del genoma
sino lecturas cortas que representan fragmentos de la cadena original que después se
deberán re-ensamblar. Una forma de realizarse es utilizando como referencia un genoma
ya secuenciado, en cuyo caso recibe el nombre de alineación o mapeo. El problema de
esto es la gran cantidad de lecturas con la que se debe trabajar, por ejemplo el genoma
humano tiene aproximadamente 200 millones de lecturas cortas entre 35 y 1100
nucleótidos y cada lectura debe alinearse a una secuencia que tiene aproximadamente 3000
millones de nucleótidos (Pelak, y otros, 2010). En consecuencia, los programas de
alineación actuales se ven incapaces de competir con la velocidad de las máquinas NGS,
aun cuando utilizan múltiples hilos o ejecución en múltiples computadoras,
convirtiéndose en el cuello de botella del proceso global de análisis de genomas. Lo
anterior exige la búsqueda de nuevas estrategias y/o algoritmos que aceleren el proceso.
1.2 Justificación
La secuenciación del ADN es uno de los temas de gran interés en la investigación a nivel
mundial, esto se debe al desarrollo de diversas aplicaciones en la bioinformática, la cual
se ha convertido en una ciencia esencial para la genómica básica y la investigación en
biología molecular (Frese, Katus, & Meder, 2013), lo que ha hecho posible incrementar el
conocimiento y estudio de los organismos, además de su gran impacto en diferentes áreas,
como la medicina biológica, la agricultura y la investigación forense. Dentro de la medicina
genómica los avances de la secuenciación de ADN son una tecnología clave para la
detección de algunos tipos de cáncer, así como el VIH, además de ayudar a la
predisposición de algunas enfermedades genéticas tales como la diabetes, enfermedades
cardiovasculares, así como la prevención de trastornos (Gonzaga-Jauregui, Lupski, &
Gibbs, 2012).
Con el desarrollo de las máquinas de secuenciación de siguiente generación, la cantidad
de datos generados en cada secuenciación crecerá exponencialmente, lo que hace
5
necesario el desarrollo de programas de procesamiento y análisis más sofisticados e
incluso mecanismos alternos de aceleración, tales como la aceleración en hardware.
Ante este panorama, el proyecto PRODEP al que este trabajo pertenece requiere el
desarrollo de un alineador genérico basado en la estrategia siembra y extiende, con un
mínimo de heurísticas, para poder probar a nivel software los algoritmos que
posteriormente se implementarán en hardware para su aceleración, así como para
comparar los resultados de alineación obtenidos en hardware.
1.3 Hipótesis
Es posible combinar mediante la estrategia siembra y extiende, el algoritmo de búsqueda
de FM con el algoritmo de paralelización de Myers, para realizar la alineación de lecturas
cortas de ADN.
1.4 Objetivos
1.4.1 Objetivo General
Desarrollar un programa de alineación con el mínimo uso de heurísticas, que permita
probar la funcionalidad de la combinación de los algoritmos índices de FM y el algoritmo
de paralelización a nivel de bit propuesto por Myers, mediante la estrategia siembra y
extiende, para una futura implementación hardware.
1.4.2 Objetivos Específicos
Modificar el algoritmo de Myers para calcular, además de la distancia de edición,
la trayectoria de la alineación.
Diseñar los módulos de la fase de siembra utilizando los índices de FM y la fase
de extensión usando el algoritmo de Myers modificado.
Implementar e integrar los módulos de siembra y extensión.
Validar la funcionalidad del programa realizando múltiples pruebas.
Documentar el sistema completo una vez terminado.
6
1.5 Alcances y limitaciones
1.5.1 Alcances
Se desarrollará un alineador genérico, capaz de procesar lecturas cortas de
entre 70 y 100 nucleótidos, respecto a un genoma de referencia.
El alineador tendrá la capacidad de alinear lecturas cortas respecto a cadenas
de referencia de hasta 1 millón de nucleótidos.
El alineador reportará la alineación de la lectura no solo considerando las
mutaciones, sino también las inserciones y eliminaciones de nucleótidos
encontradas.
Además de la ubicación, el alineador reportará la trayectoria de alineación de
la lectura.
El alineador entregará los resultados en formato .SAM.
Se documentará el sistema para poder usarse en las pruebas del acelerador
hardware desarrollado en otra sección del proyecto al que este trabajo
pertenece.
1.5.2 Limitaciones
La aplicación a desarrollar persigue fines de investigación, y comprende
únicamente el primer paso de un proceso de análisis de genomas, por lo que
se limita a una interfaz sencilla de consola.
El alineador únicamente considera lecturas cortas de ADN, sin extenderse a
otros tipos de material genómico como RNA, así su alfabeto está limitado a
∑= {A, C, G y T}.
Las pruebas considerarán únicamente lecturas cortas generadas artificialmente
mediante el programa Wgsim y en archivos con formato FASTQ.
El desarrollo de la aplicación puede utilizar módulos de otros programas de
alineación con licencia de código libre.
7
Existen diversos algoritmos que realizan la etapa de sembrado, sin embargo,
esta investigación está enfocada al uso de índices de FM.
Existen diversos algoritmos que realizan la etapa de extensión, sin embargo,
esta investigación está enfocada al uso del algoritmo de paralelización a nivel
bit de Myers.
El alineador correrá únicamente bajo el sistema operativo Linux.
1.6 Metodología
La secuencia metodológica que se utiliza en esta tesis es la siguiente (Figura 2): el proceso
inicia con el planteamiento del problema, después, el estudio de los fundamentos y estado
del arte. A continuación el desarrollo del sistema, el cual estará basado en el modelo
secuencial del ciclo de vida de desarrollo de software, elegida debido a que el programa a
construir se divide en fases que se deberán completar para avanzar. En la primera fase se
llevará a cabo el análisis, con el propósito de obtener conocimiento de la estrategia
siembra y extiende, familiarizarse con los algoritmos TBW e índices de FM y profundizar
las bases del método de programación dinámica, particularmente el algoritmo propuesto
por Myers. En la fase de diseño se bosquejará el módulo que realiza la siembra utilizando
los índices de FM y el módulo de extensión donde se aplicará la programación dinámica
usando el algoritmo de Myers. En la fase de implementación, se codifica el programa
previamente diseñado, usando el lenguaje de programación C y el compilador gcc.
Finalmente se realizarán las pruebas para detección y corrección de errores del sistema
completo y se documentará el sistema realizado para su uso en las pruebas del acelerador
hardware desarrollado en otra sección a la cual este trabajo pertenece.
8
Estudio de
fundamentos y estado
del arte
¿El sistema
es funcional?
Implementación
Documentación de
resultados
Pruebas
Análisis de los
algoritmos
Diseño de las etapas de
siembra y extensión
No
Si
Modelo secuencial de
ingeniería de software
Figura 2. Metodología de desarrollo del proyecto
9
Capítulo 2
2 MARCO DE REFERENCIA
En este capítulo se presentan los fundamentos teóricos necesarios para la comprensión
del tema de investigación. En esencia, se describen los componentes básicos que
conforma el ácido desoxirribonucleico, el proceso que se lleva a cabo para realizar la
secuenciación de ADN, los problemas que se presentan en la alineación de lecturas cortas
y finalmente se describe la estrategia siembra y extiende definiendo los algoritmos más
utilizados en cada etapa.
2.1 El ADN
El ácido desoxirribonucleico (ADN), es la molécula responsable de transmitir la
información genética de todo ser vivo (Ramos, 2016). Está compuesto sólo de cuatro
moléculas básicas, llamadas nucleótidos, idénticas entre sí, excepto por contener una base
nitrogenada diferente. Cada nucleótido contiene fosfato, azúcar (del tipo llamado
desoxirribosa) y una de las 4 bases (Figura 3). Los cuatro tipos de bases nitrogenadas
encontradas en los nucleótidos son: adenina (A), timina (T), guanina (G) y citosina (C)
(Griffiths, 2002).
10
Figura 3. Estructura del ácido desoxirribonucleico (ADN). Fuente: https://www.cancer.gov/espanol/publicaciones/diccionario?cdrid=45671
2.2 Secuenciación de ADN
La secuenciación del ADN es una técnica de laboratorio utilizada para determinar la
secuencia exacta de las bases nitrogenadas en una molécula de ADN. La estrategia más
utilizada para secuenciar una cadena de ADN se conoce como secuenciación de Shotgun
(Pop, 2009). Este método consiste principalmente en tres pasos (Figura 4), el primero es
clonar la cadena de ADN, luego se divide aleatoriamente en pequeños fragmentos que
pueden ser secuenciados individualmente por las tecnologías NGS y el último paso es el
ensamble de fragmentos, el cual consiste en unir mediante software altamente sofisticado
las millones de lecturas obtenidas a partir de las tecnologías NGS formando así la cadena
que representa la cadena original, este proceso de reconstrucción se puede llevar a cabo
utilizando como referencia un genoma secuenciado previamente, dicho mecanismo recibe
el nombre de alineación o mapeo.
11
Figura 4. Proceso simplificado de la estrategia de secuenciación de Shotgun. Fuente: http://www.micronautomata.com/bioinformatics
2.3 Alineación de lecturas cortas
El problema de la alineación de lecturas cortas respecto a una cadena de referencia se
traduce en la alineación de cadenas en computación, y se divide en: alineación exacta e
inexacta.
2.3.1 La alineación exacta
Considere la secuencia de referencia R = “ATCAGTAA” y la lectura corta sin mutaciones
L1 = “AGT”. La alineación exacta de la lectura corta se da en la posición de 3 a 5, donde
se encuentra totalmente alineada con respecto a la cadena de referencia (Figura 5).
Posición : 0 1 2 3 4 5 6 7
Referencia : A T C A G T A A
Lectura corta : A G T
Figura 5. Alineación exacta de una lectura corta a la cadena de referencia
12
2.3.2 La alineación inexacta
Es posible que las lecturas cortas de ADN contengan pequeñas variaciones con respecto
a la cadena de referencia. Esto sucede cuando un nucleótido se cambia por otro, en
genética esto es conocido como Polimorfismo de Nucleótido Simple (SNP).
Considere la misma cadena de referencia R = “ATCAGTAA” y la lectura corta L2 =
“ACT”, donde el nucleótido ‘G’ de L1 se ha cambiado por ‘C’. Un algoritmo de alineación
de lecturas cortas podría reportar que la mejor alineación se encuentra todavía entre la
posición 3 a 5 (Figura 6). En esta alineación existe un desapareo. Si se permite que ocurra
un desapareo en la alineación, se puede decir que existe un éxito en la alineación de la
lectura corta respecto a la referencia. A este proceso de alineación, donde es permitido
los desapareos se le conoce como alineación inexacta.
Posición : 0 1 2 3 4 5 6 7
Referencia : A T C A G T A A
Lectura corta : A C T
Desapareo : ↑
Figura 6. Alineación inexacta, una diferencia de la lectura corta respecto a la cadena de referencia.
2.3.3 Desplazamientos, inserciones y eliminaciones.
Considere una tercera lectura corta L3 = “ACGT”. Durante la alineación de lecturas
cortas, si sólo se permite una diferencia, es posible que no se tenga éxito al alinear L3,
debido a que tiene un nucleótido extra que fue agregado durante la secuenciación de la
molécula de ADN. El nucleótido extra ‘C’ es considerado una inserción en la lectura corta
respecto a la cadena de referencia o una eliminación en la referencia en relación a la lectura
corta (Figura 7). Los términos inserción y eliminación son llamados indels y en
consecuencia provocan desplazamientos o huecos en la alineación.
13
Posición : 0 1 2 3 4 5 6 7
Referencia : A T C A G T A A
Lectura corta : A C G T
Inserción : ↑
Figura 7. Una lectura corta con una inserción, alineada a la cadena de referencia
2.4 La estrategia Siembra y Extiende
La alineación de lecturas cortas no es una tarea sencilla, considerando que la mayoría de
las lecturas se alinean de forma inexacta, es por esta razón que muchos alineadores de
ADN modernos han adoptado una técnica que consiste en dos pasos: la siembra y la
extensión (Figura 8). Durante la fase de siembra, se intenta primero encontrar una
subcadena de la lectura corta (semilla) que se alinee exactamente en uno o más lugares a
la cadena de referencia. Esta aproximación se basa en la premisa de que si existe un alto
grado de similitud de una subcadena de la lectura en una región de la referencia, entonces
es más probable que exista un buen alineamiento de toda la lectura corta en estas zona.
Durante la fase de extensión se intenta extender la semilla en ambas direcciones (izquierda
y derecha). En esta fase, toda la lectura corta es alineada respecto a la cadena de referencia
en las zonas encontradas previamente durante la etapa de siembra. La fase de extensión
permite determinar de forma precisa la existencia de mutaciones o indels de la lectura
respecto a la referencia.
Figura 8. Proceso de alineación de lecturas cortas mediante la estrategia siembra y extiende. Fuente: adaptado de (Li H. , 2013)
14
Para la etapa de siembra generalmente se usan algoritmos heurísticos que permitan realizar
búsquedas exactas de cadenas para ubicar las siembras, como los basados en Tablas Hash
o la TBW, entre otros. En la etapa de extensión se utiliza algoritmos basados en
programación dinámica tales como Smith-Waterman (Smith & Waterman, 1981) o
Needleman-Wunsch (Needleman & Wunsch, 1970), con la finalidad de determinar
alineación inexacta de la cadena.
2.4.1 Técnicas de siembra
Una lectura corta puede generar varias semillas, y cada semilla se puede alinear a múltiples
regiones de la cadena de referencia. El proceso de ubicar una semilla en la cadena de
referencia se le conoce como siembra. Durante la etapa de siembra, generalmente se
alinean semillas exactas, sin embargo, es posible alinear semillas con un número de
desapareos permitidos, esto depende del tipo de semilla elegida.
2.4.1.1 Tipos de semillas
El tipo de semilla determina el número de siembras generadas. Este factor es importante
debido que por cada siembra hay que alinearlo en la fase de extensión, y en consecuencia
incrementa el tiempo de computación. Modernos alineadores de ADN usan dos tipos de
semillas: semillas de longitud fija y semillas de máxima coincidencia exacta. La principal
diferencia entre ellas es la longitud de las semillas, y a continuación se describe cada una
de ellas.
Semillas de longitud fija
Este tipo de semillas tienen la misma longitud, además, pueden estar o no traslapadas.
Para su construcción es necesario tomar en cuenta dos valores importantes: la longitud y
el intervalo de la semilla. El intervalo de semilla es el número de símbolos del punto de
inicio de la semilla actual hasta el inicio de la semilla siguiente. La Figura 9 muestra la
relación que existe entre la longitud y el intervalo de las semillas.
15
G G T A C A G A G T C G G G T A C A G A G T C G G G T A C A G A G T C G
G G T A G T C T G G T A G G T A G T C T
C A G A T A C A
C A G A
G A G T
G T C T
a) longitud = intervalo b) longitud > intervalo longitud < intervalo
Figura 9. Relación entre la longitud e intervalo de semillas de tamaño fijo
Al reducir la longitud de la semilla o aumentar el tamaño del intervalo aumenta la
sensibilidad del método así como el número de siembras. Es posible permitir desapareos
en las semillas, tal método es conocido como semillas espaciadas (Li & Homer, 2010) y
consiste en ingresar posiciones “no importa” en las cuales el algoritmo no identifica el
tipo de nucleótido presente. Por ejemplo indicando a ‘x’ como un carácter no importa, la
semilla CGATxGT es capaz de alinearse a CGATAGT, CGATCGT, etc.
Máxima Coincidencia Exacta
La Máxima Coincidencia Exacta (MEM, del inglés Maximal Exact Match) es la coincidencia
exacta más larga que no puede ampliarse más en cualquier dirección (Khan, Bloom,
Kruglyak, & Singh, 2009). Dado P y T que corresponden a la lectura de ADN y la cadena
de referencia respectivamente, donde P [q, r] es una subcadena de P y T[m, n] una
subcadena de T, entonces un MEM entre P y T puede ser definido como una tupla
(P[q,r],T[m,n]) la cual cumple con las reglas de la ecuación 1:
𝑃[𝑝] = 𝑇[𝑡] ∀𝑝 𝑞 ≤ 𝑝 ≤ 𝑟 ∀𝑡 𝑚 ≤ 𝑡 ≤ 𝑛
𝑃[𝑞 − 1] ≠ 𝑇[𝑚 − 1]
𝑃[𝑟 + 1] ≠ 𝑇[𝑛 + 1]
(1)
Sea R=”GGTTACAGAGTACCACAGAGTCGAGAGTC” la cadena de referencia y
L=”GGTACAGAGTCG” la lectura corta, entonces, todas las posibles semillas MEM
generadas a partir de la lectura corta se muestran en la Figura 10, donde cada semilla se
16
alinea exactamente en alguna región de la referencia y ninguna puede crecer más a alguna
dirección.
G G T A C A G A G T C G
G G T
A C A G A G T C G
G T A C
T A C A G A G
Figura 10. Todas las posibles semillas MEM de L respecto a R.
El uso de semillas MEM ha permitido el desarrollo de alineadores como E-MEM (Khiste
& Llie, 2015), así como CUSHAW2 (Liu, Schmidt, & Maskell, 2012) que utilizan semillas
MEM para iniciar el alineamiento de lecturas tomando como parámetro un valor k que
indica el tamaño mínimo de la semilla, el cual varía de acuerdo al tamaño de la lectura
corta.
Súper Máxima Coincidencia Exacta
La Súper Máxima Coincidencia Exacta (SMEM, del inglés Super Maximal Exact Match) es
definido como un MEM que no está contenido en otros MEMs de la lectura (Li H. ,
2012). Es decir, dado un número k de MEMs de la lectura corta :MEM1=(P[q1,r1],
T[m1,n1]), MEM2=(P[q2,r2],T[m2,n2]), ..., MEMk=( P[qk,rk],T[mk,nk]). Entonces el MEMi
para i = 1…k es un SMEM si y solamente se cumple la ecuación 2:
(𝑞𝑖 < 𝑞𝑗 𝑂𝑅 𝑟𝑖 < 𝑟𝑗) 𝐴𝑁𝐷 (𝑚𝑖 < 𝑚𝑗 𝑂𝑅 𝑛𝑖 < 𝑛𝑗)
∀𝑗 𝑗 = 1,2, … , 𝑖 − 1, 𝑖 + 1, 𝑘 − 1, 𝑘 (2)
Los SMEM pueden estar traslapados o no, suponiendo que se tiene la misma cadena de
referencia R y la misma lectura corta L del ejemplo anterior. Entonces, los SMEM
traslapados de la lectura se muestran en la Figura 11a y los no traslapados en la Figura
11b. Un algoritmo SMEM con traslape es más sensible a encontrar un número mayor de
semillas, sin embargo, los no traslapados son mucho más rápidos de calcular.
17
G G T A C A G A G T C G G G T A C A G A G T C G
G G T G G T
A C A G A G T C G A C A G A G T C G
G T A C
T A C A G A G
a) b)
Figura 11. Semillas SMEM a) semillas traslapadas de la lectura b) semillas no traslapadas de la lectura
Alineadores como BWA-MEM (Li H. , 2013) utiliza semillas SMEM durante la etapa de
siembra, lo cual le permite generar todas las semillas de máxima longitud posibles a partir
de la lectura. Cabe destacar que mientras la longitud de la semilla se aproxime más a la
longitud de la lectura corta, más exacta es la siembra, además, se obtienen menos regiones
donde aparece la semilla y por lo tanto no se ejecutan muchas extensiones de la misma.
2.4.1.2 Algoritmos de Siembra
Los algoritmos de siembra se basan en semillas de longitud fija o de máxima coincidencia
exacta (Ahmed, Bertels, & Al-Ars, 2016). La primera divide la lectura corta en semillas de
igual longitud y posteriormente realiza la búsqueda de cada semilla en la cadena de
referencia. La segunda va obteniendo las semillas conforme intenta alinear la lectura corta
respecto a la cadena de referencia, lo cual le permite encontrar semillas de longitud
variable.
En ambos casos, es necesario realizar una comparación de cadenas, sin embargo, realizar
la búsqueda de una lectura corta o una subcadena de la misma respecto a una cadena de
referencia tan grande como lo es el genoma humano requiere gran cantidad de tiempo de
procesamiento. Para solucionar este problema se han diseñado algoritmos que realizan
primero un pre-procesamiento de la cadena de referencia para la construcción de índices,
y así acelerar el proceso de búsqueda. Existen diferentes algoritmos que permiten la
construcción de índices, sin embargo, en este trabajo sólo se hace referencia a las Tablas
Hash (Wu T. D., 2016) y a los índices de FM (Ferragina & Manzini, 2000), los cuales han
sido utilizados en varios alineadores.
18
2.4.1.2.1 Tablas Hash
Las tablas hash (Wu T. D., 2016) pretenden construir una lista de subcadenas
denominadas k-mers y determinar inmediatamente sus posiciones en la cadena de
referencia. Al elegir una longitud k mucho menor al tamaño original de la referencia se
puede generar a lo mucho l – k + 1 subcadenas traslapadas, donde l es la longitud de la
referencia. Las tablas almacenan dos estructuras de datos: una lista de k-mers traslapados
y un arreglo de todas las posiciones de inicio donde el k-mer aparece en la referencia. La
Figura 12a muestra la tabla hash para una cadena de referencia R = “GATCAGATCA” y
un valor de k = 3. Se puede notar que algunos k-mers se repiten por lo tanto el tamaño
de cada arreglo puede variar.
Para realizar la alineación de lecturas cortas es necesario dividir cada lectura en subcadenas
de longitud k, cada subcadena es usada como clave y mediante un algoritmo de “hasheo”
se determina su ubicación en la tabla (Figura 12b), retornando las posiciones donde ésta
aparece en la referencia. Ahora, para determinar la alineación exacta de la lectura se
comparan las posiciones de las subcadenas unas con otras (Figura 12c), si se obtienen
posiciones adjuntas y en el orden correcto entonces se ha tenido éxito en la alineación
(Figura 11d).
0 1 2 3 4 5 6 7 8 9
G A T C A G A T C A
a)
Índice Posición
GAT 0 5
ATC 1 6
TCA 2 7
CAG 3
AGA 4
- 0 No apareo
c) 2 5 Apareo
7 - No apareo
d)
T C A G A T
b)
. Figura 12. Algoritmo de hasheo. a) El genoma se divide en 3-mers traslapados b) La lectura se divide en subcadenas de longitud 3 y se busca en la tabla hash. c) Las posiciones por cada subcadena se comparan
unas con otras. d) Las posiciones adjuntas y en orden correcto forman la alineación exacta.
El algoritmo anterior puede modificarse para alinear lecturas que incluyan errores
(desapareos o indels). Suponiendo un número n de errores, en tal caso, la lectura será
19
dividida en n+1 subcadenas, de esta manera a lo mucho n k-mers contendrán los errores
y uno de ellos se alineará exactamente. A éste método se le conoce como el principio de
las cajas del palomar (Ahmadi, y otros, 2012), donde se van descartando las subcadenas
con errores. Utilizando la estrategia siembra y extiende se pueden tomar los k-mers que
se alinean perfectamente a la referencia y usarlas como semillas (Figura 13a),
posteriormente con algún algoritmo más preciso como los de programación dinámica se
puede alinear la lectura que contiene errores en la vecindad de esta semilla (Figura 13b).
Sin embargo, existe un problema respecto a este método, ya que al incrementar el número
de errores es necesario dividir la lectura corta en semillas cada vez más pequeñas. Estas
semillas suelen producir errores en la fase de siembra, puesto que tienen mayor
probabilidad de alinearse en múltiples regiones de la cadena de referencia.
Siembra Extiende
G A T C A G A Alineación de la semilla 1
G A T C A G A
A T G A 1 Error
A T G A
Alineación de la semilla 2
G A T C A G A
A T G A A T G A 2 Errores
a) b)
Figura 13. La técnica de siembra y extiende. a) Etapa de siembra: se obtienen 2 semillas al permitir 1 error, las cuales se alinean en la referencia. b) Etapa de extensión: se alinea la lectura entera y revela el número
de errores.
Las tablas hash son una buena alternativa para acelerar el proceso de búsqueda exacta de
semillas, sin embargo, tiene una desventaja por la gran cantidad de memoria requerida
para su almacenamiento (Lindner & Friedel, 2012). Para reducir un poco el espacio usado
por la tabla, se codifican los caracteres A, C, G y T en forma binaria, de esta manera, cada
carácter puede ser representado únicamente por 2 bits, usando esta codificación cada k-
mer tiene un tamaño de 2k bits, logrando así compactar el tamaño de la tabla, la cual
puede almacenar a lo máximo 4k posibles k-mers de la cadena de referencia.
20
Existen varios programas alineadores que utilizan las tablas hash para alinear semillas de
la lecturas cortas a la cadena de referencia: BLAST (Altschul, Gish, Miller, Myers, &
Lipman, 1990), SHRIMP (Rumble, y otros, 2009), BLAT (Kent, 2002), NEXTGENMAP
(Sedlazeck, Rescheneder, & von Haeseler, 2013) y GMAP (Wu & Watanabe, 2005).
Dichos alineadores manejan un valor de k mayor a 10 y algunos utilizan semillas
espaciadas para alinear lecturas que incluyan errores. Sin embargo, el tamaño de las tablas
de índice puede crecer enormemente, por ejemplo, para el genoma humano utilizando un
valor 40 de k el tamaño de la tabla es aproximado a 150 GB.
2.4.1.2.2 Los Índices de FM
Los índices de FM (Ferragina & Manzini, 2000) son una estructura de datos conformado
por la TBW de la cadena de referencia, el Arreglo de sufijos que contiene todas las
posiciones de inicio de los sufijos de la referencia, una matriz de ocurrencia de los cuatro
caracteres (A,C,G,T) en la TBW y un vector contador de caracteres. Dichos índices son
eficientes en espacio para realizar búsquedas de cadenas.
La Transformada de Burrows-Wheeler
La Transformada de Burrows-Wheeler (Burrows & Wheeler, 1994), es un algoritmo que
transforma una cadena a otra más fácil de comprimir. El reordenamiento se realiza de tal
manera que se agrupan los caracteres similares de la cadena original y produce una
transformada que es reversible. La transformación se realiza produciendo todas las
posibles rotaciones de la cadena y el ordenamiento lexicográfico de la misma. Considere
los siguientes símbolos y valores para el ejemplo:
∑ = {‘A’,’C’,’G’,’T’}: el alfabeto del que se forman las cadenas.
$ = un carácter especial que es lexicográficamente más pequeño que todos los
caracteres de ∑.
R’ = “GATCAGATCA”: la cadena de entrada.
El primer paso del algoritmo es agregar el carácter especial $ en la cadena de entrada R’.
Esto se define como R = “GATCAGATCA$”, este carácter es necesario para realizar
posteriormente la inversa de la transformada. El segundo paso es encontrar todas las
21
rotaciones de R (Figura 14), donde la matriz generada representa todos los casos de los
posibles sufijos de la cadena R. El tercer paso es ordenar lexicográficamente la matriz de
rotaciones (Figura 15), como resultado se obtiene la TBW en la última columna de la
matriz y el arreglo de sufijos que contiene todas las posiciones iniciales de todos los sufijos
de la cadena de referencia, en este caso el arreglo B=”ACCGGTTA$AA” es la
transformada de la cadena original R y el vector SA el arreglo de sufijos generado, el cual
es mostrado sólo por claridad.
i
0 G A T C A G A T C A $
1 A T C A G A T C A $ G
2 T C A G A T C A $ G A
3 C A G A T C A $ G A T
4 A G A T C A $ G A T C
5 G A T C A $ G A T C A
6 A T C A $ G A T C A G
7 T C A $ G A T C A G A
8 C A $ G A T C A G A T
9 A $ G A T C A G A T C
10 $ G A T C A G A T C A
i SA[i] B[i]
0 10 $ G A T C A G A T C A
1 9 A $ G A T C A G A T C
2 4 A G A T C A $ G A T C
3 6 A T C A $ G A T C A G
4 1 A T C A G A T C A $ G
5 8 C A $ G A T C A G A T
6 3 C A G A T C A $ G A T
7 5 G A T C A $ G A T C A
8 0 G A T C A G A T C A $
9 7 T C A $ G A T C A G A
10 2 T C A G A T C A $ G A
a) b)
Figura 14. La TBW. a) Matriz de todas las rotaciones de R = “GATCAGATCA$”. b) Ordenamiento lexicográfico de la matriz de rotaciones.
Índices de FM
Originalmente la TBW fue creada para la compresión de datos, sin embargo Ferragina y
Manzini desarrollaron un algoritmo que permite realizar búsquedas de patrones utilizando
la TBW (Ferragina & Manzini, 2000) basándose en un principio llamada mapeo LF
(Último-Primero). Tomando en cuenta la primera y última columna de la matriz de
rotaciones ordenada (Figura 15a), la j-ésima ocurrencia de un carácter en la última
columna (L), es la j-ésima ocurrencia del mismo carácter en la primera columna (F). El
mapeo LF es la clave para revertir la TBW y también puede ser usado como índice para
búsqueda exacta de cadenas.
22
i F L
0 $ . . . A1
1 A1 . . . C1
2 A2 . . . C2
3 A3 . . . G1
4 A4 . . . G2
5 C1 . . . T1
6 C2 . . . T2
7 G1 . . . A2
8 G2 . . . $
9 T1 . . . A3
10 T2 . . . A4
i F L R
0 $ . . . A 1
1 A . . . C 1
2 A . . . C 2
3 A . . . G 1
4 A . . . G 2
5 C . . . T 1
6 C . . . T 2
7 G . . . A 2
8 G . . . $ 1
9 T . . . A 3
10 T . . . A 4
a) b)
Figura 15. Primera y última columna de la TBW. a) Representación del mapeo Último-Primero. b) Los índices L y F, junto con el vector de rangos R.
Supongamos que se desea encontrar el patrón P=“TCA” en la cadena de referencia del
ejemplo anterior. El proceso de búsqueda se basa en los índices L y F y un vector de
rango R que contiene en cada posición i el número de veces que ha aparecido el carácter
L[i] desde el inicio hasta la fila actual (Figura 15b).
i F L R
0 $ G A T C A G A T C A 1
1 A $ G A T C A G A T C 1
2 A G A T C A $ G A T C 2
3 A T C A $ G A T C A G 1
4 A T C A G A T C A $ G 2
5 C A $ G A T C A G A T 1
6 C A G A T C A $ G A T 2
7 G A T C A $ G A T C A 2
8 G A T C A G A T C A $ 1
9 T C A $ G A T C A G A 3
10 T C A G A T C A $ G A 4
i F L R
0 $ G A T C A G A T C A 1
1 A $ G A T C A G A T C 1
2 A G A T C A $ G A T C 2
3 A T C A $ G A T C A G 1
4 A T C A G A T C A $ G 2
5 C A $ G A T C A G A T 1
6 C A G A T C A $ G A T 2
7 G A T C A $ G A T C A 2
8 G A T C A G A T C A $ 1
9 T C A $ G A T C A G A 3
10 T C A G A T C A $ G A 4
i F L R
0 $ G A T C A G A T C A 1
1 A $ G A T C A G A T C 1
2 A G A T C A $ G A T C 2
3 A T C A $ G A T C A G 1
4 A T C A G A T C A $ G 2
5 C A $ G A T C A G A T 1
6 C A G A T C A $ G A T 2
7 G A T C A $ G A T C A 2
8 G A T C A G A T C A $ 1
9 T C A $ G A T C A G A 3
10 T C A G A T C A $ G A 4
a) b) c)
Figura 16. Búsqueda del patrón P=”TCA” en la referencia R=” GATCAGATCA”. a) Intervalo de búsqueda usando el sufijo más corto: A. b) Nuevo intervalo al extender el sufijo a CA. c) Intervalo final al
extender el sufijo a TCA.
La búsqueda comienza con el último carácter del patrón: 'A', el cual se ubica en la columna
F en el intervalo [1,4] (Figura 16a). A continuación se agrega el siguiente carácter 'C' para
23
formar el sufijo más corto del patrón: “CA”. Ya que el espacio de búsqueda se ha limitado
al intervalo [1,4] de acuerdo al paso anterior, observando la columna L en este intervalo
puede notarse que existen dos filas en donde ‘C’ precede a ‘A’ (fila 1 y 2) y de acuerdo al
vector de rango R estas corresponden a la primera y segunda aparición de ‘C’ en L.
Finalmente por mapeo LF puede determinarse que esos mismos caracteres se encuentran
en F en la 5 y 6 (primera y segunda aparición de ‘C’). Con esto se ha obtenido un nuevo
intervalo de búsqueda: [5,6] (Figura 16b). A continuación, se agrega el último carácter del
patrón buscado que es ‘T’, formando así el sufijo “TAC”. El intervalo actual de búsqueda
es [5,6].Nuevamente revisando L en este intervalo se puede notar la existencia de dos filas
donde ‘T’ precede del prefijo “AC” (fila 5 y 6) y de acuerdo al vector de rango R, estas
corresponden a la primera y segunda aparición de ‘T’, al realizar el mapeo LF se puede
constatar que esos mismos caracteres aparecen en las filas 9 y 10 de F (primera y segunda
aparición de ‘T’), donde efectivamente en ese intervalo aparece el prefijo ‘TAC’ buscado
(Figura 16c).
La complejidad temporal del algoritmo anterior puede mejorar si en vez de almacenar un
vector de rangos se almacena una matriz de ocurrencias de los 4 caracteres (A, C, G y T)
que aparecen en la cadena transformada. Ahora, en lugar de escanear la última columna,
simplemente se busca el carácter apropiado en los extremos izquierdo y derecho del rango
actual, si no hay diferencias entre las dos búsquedas, el carácter no ocurre. Si hay una o
más ocurrencias del carácter, la búsqueda dará los rangos de esas ocurrencias.
Los índices de FM de la cadena R = “GATCAGATCA” (Figura 17), consisten de los
siguientes componentes:
SA: el arreglo de sufijos ordenado.
B: la Transformada de Burrows-Wheeler de la cadena R.
Occ: la matriz de ocurrencias, donde O[‘c’,i] es obtenido del cálculo de las
ocurrencias del carácter ‘c’ del alfabeto ∑ en la i-ésima posición del arreglo B.
C: es el arreglo contador de caracteres, donde C[‘c’] es el número de caracteres en
R que son lexicográficamente más pequeño que ‘c’, sin considerar el carácter
especial $.
24
i SA[i] B[i] Occ[‘c’,i]
A C G T
0 10 A 1 0 0 0
1 9 C 1 1 0 0
2 4 C 1 2 0 0
3 6 G 1 2 1 0
4 1 G 1 2 2 0
5 8 T 1 2 2 1
6 3 T 1 2 2 2
7 5 A 2 2 2 2
8 0 $ 2 2 2 2
9 7 A 3 2 2 2
10 2 A 4 2 2 2
C[‘c’] 0 4 6 8
Figura 17. Todos los componentes de los índices de FM
Usando los índices FM, es posible realizar búsquedas exactas de cadenas. El Algoritmo 1
implementa dicha función, donde intervienen: la cadena de referencia R, el vector de
caracteres y la matriz de ocurrencias Occ. Las variables k y l representan los intervalos
actuales inferior y superior respectivamente, P el patrón buscado, i un apuntador y σ
una variable que contiene el carácter del patrón procesado actualmente. Las líneas 2 a 4
inicializan el proceso colocando el índice i apuntando al carácter más a la derecha del
patrón y los índices k y l indican el intervalo más grande posible de búsqueda (0 y |R|-1,
respectivamente).
Algoritmo 1. Búsqueda exacta utilizando los índices de FM
1 function EXACTMATCH (R, C, Occ)
2 i ←|P|-1
3 k ←0
4 l ←|R|- 1
5 while k ≤ l ∩ i ≥ 0 do
6 ← P [i]
7 k← C[] + Occ[,k-1 ] + 1
8 l ← C[] + Occ[,l ]
9 i ← i- 1
10 end while
11 if k ≤ l then
12 return {k,l}
13 else
14 return {Ф}
15 end if
25
16 end function
Las líneas 5 a la 10 forman el núcleo del proceso, toma cada uno de los caracteres del
patrón de derecha a izquierda, aplicando el mapeo último-primero en las líneas 7 y 8 para
definir el nuevo intervalo de búsqueda, tal como se explicó previamente. Se observa cómo
el término C[σ] + 1 en realidad señala la primera posición de aparición del carácter σ en
la primera fila y se suma al término Occ[σ,k-1], que representa el número de ocurrencias
del mismo carácter hasta la fila k-1, para obtener el mapeo deseado. Finalmente el
algoritmo retorna el intervalo [k, l] si k ≤ l o un intervalo vacío en caso contrario (líneas
10 a 15).
En la Tabla 1 se muestran los resultados en cada paso del algoritmo al buscar el patrón
P=“TCA” en la cadena de referencia R=”GATCAGATCA” presentada en ejemplos
anteriores. Dicho algoritmo es conocido como búsqueda hacia atrás y como resultado
retorna los índices donde el patrón aparece en la matriz de trasformación, sin embargo
esta no es la posición real en R. Para obtener la posición verdadera se hace uso del arreglo
de sufijos.
Tabla 1. Resultados de la búsqueda del patrón P=”TCA” en la referencia R=” GATCAGATCA”
Iteración i K L
Inicio 2 0 8
1 2 A k = C[A] + Occ[A,-1 ] + 1=1 l ← C[A] + Occ[A,9 ] =4
2 1 C k = C[C] + Occ[C,-1 ] + 1=5 l ← C[C] + Occ[C,9 ] =6
3 0 T k = C[T] + Occ[T,-1 ] + 1=9 l ← C[T] + Occ[T,9 ] =10
Retorno 9 10
Los índices de FM son usados por varios alineadores como: BWA (Li & Durbin, Fast and
accurate short read alignment with Burrows-Wheeler transform, 2009), Bowtie
(Langmead, Trapnell, Pop, & Salzberg, 2009) y SOAP2 (Li, y otros, 2009) debido al
eficiente uso de memoria. Por ejemplo, para almacenar la TBW se codifican los 4
nucleótidos(A, C, G y T) en forma binaria, utilizando únicamente 2 bits por cada
nucleótido, de esta manera el genoma de referencia que ocupaba 3.2Gb de
almacenamiento se reduce a sólo 750Mb en una RAM de computadora estándar. Sin
26
embargo, el problema es con el arreglo de ocurrencia, donde la memoria necesaria para
almacenarla es de |Σ||𝑅|, para el genoma humano, usando un entero de 32bits la cantidad
necesaria para almacenarla serían de 40Gb. Este problema se soluciona almacenando
únicamente ciertas filas de la matriz de ocurrencia (Figura 18), las cuales son denominadas
marcas, posteriormente, se recupera el resto de los valores en el momento en el que el
algoritmo de búsqueda lo requiera, lo cual se logra contando los caracteres en la TBW a
partir de la marca inferior más cercana. Utilizando éste método el genoma humano
requiere únicamente 375 MB en RAM para almacenar la matriz de ocurrencia.
i B[i] Occ[‘c’,i]
A C G T
0 A 1 0 0 0
1 C 1 1 0 0
2 C 1 2 0 0
3 G 1 2 1 0
4 G 1 2 2 0
5 T 1 2 2 1
6 T 1 2 2 2
7 A 2 2 2 2
8 $ 2 2 2 2
9 A 3 2 2 2
10 A 4 2 2 2
i B[i] Occ[‘c’,i]
A C G T
0 A 1 0 0 0
1 C
2 C
3 G
4 G 1 2 2 0
5 T
6 T
7 A
8 $ 2 2 2 2
9 A
10 A
a) b)
Figura 18. La Matriz de ocurrencia. a) Completa. b) Reducida.
2.4.2 Técnicas de extensión
La fase de extensión permite alinear toda la lectura corta en la región previamente
localizada durante la fase de siembra. Generalmente esta fase es conocida también como
la alineación inexacta de la lectura debido a que permite localizar de forma precisa los
SNPs, inserciones o eliminaciones presentes. Existen 3 tipos de extensión de semillas
usadas en alineadores modernos: Alineación global, alineación local y el BLAST-like
siembra extensión, todas ellas son implementadas usando programación dinámica, la cual
permite resolver el problema de la alineación de lecturas de ADN calculando el recurso
necesario de todas las posibles soluciones y seleccionando el que tenga mejor puntaje.
Como consecuencia, esto conduce siempre a la mejor solución posible.
27
2.4.2.1 Alineación global
La alineación global es usada para secuencias que son muy similares y que tienen
aproximadamente la misma longitud, este tipo de alineación intenta alinear cada
nucleótido de cada secuencia y, como resultado puede incluir en la alineación huecos o
desapareos de inicio a fin en las secuencias.
El algoritmo de Needleman-Wunsch (Needleman & Wunsch, 1970), es un algoritmo
basado en alineación global y fue una de las primeras aplicaciones de programación
dinámica para la comparación de secuencias biológicas. Éste utiliza la representación de
cadenas de ADN y construye una matriz de similitud de tamaño (𝑚 + 1)(𝑛 + 1) donde
𝑚 y 𝑛 son la longitud de la lectura y la referencia respectivamente. La matriz se rellena
utilizando la fórmula recursiva de la ecuación 3. Donde 𝐹(𝑖, 𝑗) representa el máximo
puntaje al evaluar el carácter 𝑋𝑖 con 𝑌𝑗, la función 𝑆(𝑋𝑖 , 𝑌𝑗) devuelve un valor cuando los
caracteres son iguales y otra en caso contrario, y d es una constante que representa el
costo por una inserción o eliminación de carácter.
𝐹(𝑖, 𝑗) = 𝑚𝑎𝑥 {
𝐹(𝑖 − 1, 𝑗 − 1) + 𝑠(𝑋𝑖 , 𝑌𝑗)
𝐹(𝑖 − 1, 𝑗) + 𝑑
𝐹(𝑖, 𝑗 − 1) + 𝑑
( 3 )
Considere las cadenas X = “CAGCGTTG” y Y = “AGGTAC” y el esquema de
ponderación: coincidencia = 2, no coincidencia = -1 y d = -2. Primero se igualan las celdas
𝐶[0, 𝑗] = 𝑖 ∗ 𝑑 y 𝐶[𝑖, 0] = 𝑗 ∗ 𝑑, después se rellena la matriz de similitud de acuerdo a las
fórmulas de la ecuación 3, el resultado de la matriz resultante se muestra en la Figura 19.
C A G C G T T G
0 -2 -4 -6 -8 -10 -12 -14 -16
A -2 -1 0 -2 -4 -6 -8 -10 -12
G -4 -3 -2 2 0 -2 -4 -6 -8
G -6 -5 -4 0 1 2 0 -2 -4
T -8 -7 -6 -2 -1 0 4 2 0
A -10 -9 -5 -4 -3 -2 2 3 1
C -12 -8 -7 -6 -2 -4 0 1 2
Figura 19. Matriz de alineación para Needleman-Wunsch.
28
El puntaje de la alineación aparece en la última celda de la matriz, en este caso es 2. Ahora,
para obtener la ruta de alineación se parte de ésta última celda y se regresa tomando la
celda vecina predecesora. Cada desplazamiento en las celdas indica un tipo de operación
en la lectura en la alineación: un desplazamiento a la izquierda indica inserción, un
desplazamiento hacia arriba indica eliminación y un desplazamiento en diagonal una
coincidencia o desapareo. En la matriz de alineación, las celdas en color gris indica una
de las rutas de alineación para las cadenas del ejemplo y el resultado de la alineación
tomando dicha ruta se muestra en la Figura 20.
Referencia : C A G C G T T G
Alineación : | | | | | |
Lectura corta : - A G - G T A C
Figura 20. Resultado de la alineación de cadenas utilizando Needleman-Wunsch.
2.4.2.2 Alineación local
A diferencia de la alineación global, la alineación local es usada para alinear únicamente
regiones donde los segmentos locales tienen mayor similitud entre ambas secuencias. Uno
de los algoritmos de programación dinámica más conocidos para la alineación local es el
Smith-Waterman (Smith & Waterman, 1981). Este algoritmo es una variación de
Needleman-Wunsch, donde la principal diferencia es que el puntaje negativo en las celdas
de la matriz no están permitidas, los valores negativos se resetean a ceros aplicando las
reglas de la ecuación 4, lo que hace visible las alineaciones locales.
𝐹(𝑖, 𝑗) = 𝑚𝑎𝑥
{
0
𝐹(𝑖 − 1, 𝑗 − 1) + 𝑠(𝑋𝑖, 𝑌𝑗)
𝐹(𝑖 − 1, 𝑗) + 𝑑
𝐹(𝑖, 𝑗 − 1) + 𝑑
( 4 )
Considerando las mismas cadenas y los mismos puntajes de ejemplo anterior, primero se
inicializan las celdas 𝐶[0, 𝑗] = 𝐶[𝑖, 0] = 0, después la matriz se expande utilizando las
29
fórmulas de la ecuación 4, el resultado de la matriz de similitud se observa en la Figura
21.
C A G C G T T G
0 0 0 0 0 0 0 0 0
A 0 0 2 0 0 0 0 0 0
G 0 0 0 4 2 2 0 0 2
G 0 0 0 1 3 4 2 0 2
T 0 0 0 0 1 2 6 4 2
A 0 0 2 0 0 0 4 5 3
C 0 2 0 1 2 0 2 3 4
Figura 21. Matriz de alineación para Smith-Waterman.
Para obtener la ruta de alineación se busca la máxima puntuación en toda la matriz, en
este caso es 6. A partir de esta celda se realiza el mismo algoritmo de retroceso como en
Needleman-Wunsch hasta llegar a un valor de casilla cero. A la hora de realizar el
recorrido hacia atrás es probable obtener diferentes rutas de alineación. Las celdas en gris
de la matriz indican en este caso una de las rutas de alineación de las cadenas y el resultado
de dicha alineación se muestra en la Figura 22.
Referencia : C A G C G T T G
Alineación : | | | |
Lectura corta : A G - G T
Figura 22. Resultado de la alineación de cadenas utilizando Smith Waterman.
2.4.2.3 BLAST-like extensión de semilla
BLAST-like extensión de semilla (Kent, 2002), es una técnica de extensión rápida, donde
divide la lectura corta y la cadena de referencia en dos partes para alinearlos mediante dos
pasos. En el primer paso se alinean la mitad del lado izquierdo de ambas secuencias
obteniendo un puntaje de dicha alineación que no supere un margen de error
preestablecido. En el segundo paso consiste en alinear la mitad derecha y el puntaje
resultante se le suma la puntuación del paso 1. Este algoritmo es similar a la alineación
local con las siguientes diferencias:
30
1. El puntaje de inicio no inicia con cero
2. Un algoritmo de alineación local estándar calcula todas alineaciones locales entre
dos secuencias y BLAST-like calcula ciertas partes de la matriz.
2.5 Trabajos relacionados
Existen varios trabajos relacionados al estudio de los algoritmos de alineación, mismos
que se revisan a continuación.
Una de las primeras aplicaciones de programación dinámica para la comparación de
secuencias biológicas fue el algoritmo de Needleman & Wunsch (Needleman & Wunsch,
1970), este es un algoritmo desarrollado para la alineación global de secuencias, con costos
arbitrarios de sustituciones, eliminaciones e inserciones. Posteriormente, basándose del
algoritmo de Needleman-Wunsch, se desarrolló un método, comúnmente conocido como
algoritmo de Smith-Waterman para encontrar regiones de similitud local (Smith &
Waterman, 1981), donde la principal diferencia es el uso de puntajes no negativos. Dichos
algoritmos encuentran la máxima similitud ente ambas cadenas a partir de los valores de
puntaje obtenidos, sin embargo, el cálculo del puntaje de cada celda de la matriz se realiza
de forma secuencial, por esta razón tanto su complejidad temporal como espacial es de
𝛰(𝑚𝑛), donde m es la longitud del patrón y n la longitud del texto. Por otro lado se
desarrollan algoritmos que calculan la similitud a partir de las diferencias de las cadenas,
éstos son conocidos como algoritmos de distancia de edición ya que calculan el número
mínimo de operaciones necesarias para transformar de una cadena a otra. Uno de los
autores que incorpora la distancia de edición en la programación dinámica por primera
vez es (Seller,1980), con un algoritmo que requiere un 𝛰(𝑚𝑛) en tiempo y espacio, más
tarde dicho algoritmo fue refinado por (Ukkonen, 1985) al reducir el tiempo a 𝛰(𝑘𝑛)
donde k es el número de transformaciones permitidas, luego el espacio se mejoró a 𝛰(𝑛)
por (Landau & Vishkin, 1988) y más tarde a 𝛰(𝑚2) por (Galil & Park, 1990). Finalmente
Myers anuncia un algoritmo que utiliza vectores de bits y operaciones binarias para realizar
el cálculo de la distancia de edición en (Myers, 1999). Myers utiliza vectores de bits para
codificar cada columna de la matriz de distancia y hace uso del paralelismo del hardware
para las operaciones binarias, de esta manera logra calcular la distancia de manera más
31
rápida. La complejidad temporal del algoritmo es de 𝛰(𝑛) y un espacio de 𝛰(1) cuando
la longitud del patrón es menor a w, donde w es el tamaño de palabra del procesador, y
𝛰([𝑚𝑛/𝑤]) en tiempo y 𝛰([𝑚/𝑤]) para longitudes de patrón mayores a w.
Debido a la complejidad espacial y temporal que presentan los algoritmos de
programación dinámica, surgieron gran cantidad de algoritmos heurísticos, los cuales son
menos exactos pero más rápidos, basados principalmente en la Transformada de
Burrows-Wheeler y las tablas Hash. Originalmente la Transformada de Burrows-Wheeler
fue diseñada como un algoritmo para la compresión de datos (Burrows & Wheeler, 1994).
Años después en (Ferragina & Manzini, 2000) se publicó la evidencia de que la TBW junto
con algunas estructuras de datos auxiliarles, al que denominaron índices de FM, pueden
ser utilizados para realizar búsquedas de cadenas. Los índices de FM no sólo son usados
para el apareo de cadenas (exacto o aproximado), también, tiene la ventaja de ser
extremadamente eficientes en disminuir el espacio utilizado para su almacenamiento.
Actualmente, los índices de FM tienen gran importancia en el área de la bioinformática,
ya que ha sido muy utilizado en numerosos programas de alineación. Bowtie (Langmead,
Trapnell, Pop, & Salzberg, 2009) fue uno de los primeros alineadores en utilizar los índices
de FM para realizar la búsqueda exacta de cadenas mediante el algoritmo de Ferragina y
Manzini, dicho alineador utiliza un índice de 2.4 GB para el genoma humano. Sin
embargo, BWA y SOAP2 son los alineadores más populares de esta categoría que en gran
medida superan las implementaciones. Tales algoritmos difieren sustancialmente en su
forma de manejar los desapareos e indels. Por otra parte las tablas hash se basan en la
construcción de índices a partir de subcadenas denominadas k-mers, almacenando la
posición donde éstas aparecen en la cadena de referencia para después obtenerlo
rápidamente al alinear la lectura. Este método es utilizado por alineadores como BLAST
(Altschul, Gish, Miller, Myers, & Lipman, 1990), BLAT (Kent, 2002), GMAP (Wu &
Watanabe, 2005), SHRIMP (Rumble, y otros, 2009) y NEXTGENMAP (Sedlazeck,
Rescheneder, & von Haeseler, 2013), sin embargo, a pesar de ser muy rápidos requieren
gran cantidad de memoria para almacenar los índices.
Recientemente han surgido nuevas estrategias que intentan encontrar un balance entre
velocidad y precisión. Una de estas es la estrategia siembra y extiende, donde primero se
32
determinan las ubicaciones de semillas en el genoma de referencia y luego se realiza la
extensión de la semilla en ambas direcciones usando un algoritmo de alineación inexacta,
eligiendo la alineación de mejor puntuación de todas las alineaciones resultantes. Dicha
estrategia fue implementada por primera vez en la herramienta BLAST (Altschul, Gish,
Miller, Myers, & Lipman, 1990). Actualmente, muchos modernos alineadores de lecturas
cortas como Bowtie2 (Langmead & Salzberg, 2012), Cushaw2 (Liu, Schmidt, & Maskell,
2012), BWA-MEM (Li H. , 2013) y (Novocraft, 2014) adoptaron esta idea para acelerar
el proceso de búsqueda de semillas y obtener buena precisión al momento de realizar las
alineaciones inexactas en la fase de extensión. En (Ahmed, Bertels, & Al-Ars, 2016) se
realiza un estudio de varias técnicas de siembra en combinación con varias técnicas de
extensión, en la etapa de siembra se comparan diversos tipos de semillas como: de
longitud fija, espaciadas y MEM, mismas que son obtenidas a partir de algoritmos
heurísticos que utilizan los índices de FM o Tablas Hash. En la fase de extensión compara
algoritmos de programación dinámica para alineación local y global. Los resultados
definen que las semillas SMEM son más precisas en comparación a las de longitud fija y
en relación a la fase de extensión la alineación local es más precisa que las alineaciones
globales.
A pesar de lo anterior, aún persiste el interés en la búsqueda de nuevos algoritmos o
estrategias que aceleren aún más el proceso. En particular el algoritmo de Myers (Myers,
1999) es un algoritmo que aprovecha las ventajas del ciclo de procesamiento del
procesador y permite realizar los cálculos de manera eficiente. Además, existen pocos
trabajos donde se ha utilizado, por ejemplo en (Šoši´c, 2015) realizan una librería para el
cálculo de la distancia de edición utilizando el algoritmo de Myers, sin embargo, la librería
realiza el cálculo de forma general para cualquier alfabeto, lo cual lleva un tiempo de
preprocesamiento extra. En otro trabajo (Hoffmann, Zeckzer, & Bogdan, 2016), realizan
una búsqueda de aceleración del algoritmo mediantes tarjetas especializadas en FPGAs ,
obteniendo velocidades 8 veces más rápida que en CPU, sin embargo no realizan la
obtención de las rutas de alineación.
33
Capítulo 3
3 EL ALGORTIMO DE MYERS
La estrategia siembra y extiende regularmente utiliza algoritmos basados en programación
dinámica para realizar la etapa de extensión, siendo los más populares: el Smith-
Waterman y el Needleman-Wunch, los cuales realizan los cálculos de manera secuencial
en tiempo 𝛰(𝑚𝑛). No obstante, existe un algoritmo propuesto por Myers (Myers, 1999)
que utiliza el paralelismo a nivel de bit para comparar cadenas, el cual permite realizar los
cálculos en tiempo 𝛰(𝑛) al utilizar vectores de bits y operaciones binarias. Este algoritmo
no se ha aplicado en forma extensiva en el alineamiento de secuencias de ADN, por lo
que fue elegido para implementar la fase de extensión y explorar sus ventajas en relación
a los algoritmos convencionales. Dicho algoritmo se describe en forma detallada en el
presente capítulo.
3.1 La distancia de Levenshtein
La distancia de edición es una medida usada para calcular la diferencia entre dos cadenas,
la cual se define como el número mínimo de operaciones necesarias para cambiar una
cadena a otra. Una de ellas es la distancia de Levenshtein (Levenshtein, 1966) que utiliza
un costo unitario por cada transformación realizada. Dada dos cadenas 𝐴 = 𝑎1… 𝑎𝑚 y
𝐵 = 𝑏1… 𝑏𝑛, la distancia de Levenshtein entre las cadenas A y B denotado como 𝑑(𝐴, 𝐵)
es el número mínimo de las siguientes trasformaciones:
1. Eliminación de un símbolo de la posición i para obtener 𝑎1… 𝑎𝑖−1𝑎𝑖+1… 𝑎𝑚
34
2. Inserción de un símbolo b en la posición i para obtener 𝑎1… 𝑎𝑖 𝑏 𝑎𝑖+1… 𝑎𝑚
3. Sustitución de un símbolo en la posición i para obtener 𝑎1… 𝑎𝑖−1 𝑏 𝑎𝑖+1… 𝑎𝑚
A partir de los conceptos anteriores, la distancia de Levenshtein puede ser calculado
utilizando un algoritmo basado en programación dinámica. Dicho algoritmo construye
una matriz de edición del tamaño (𝑚 + 1)(𝑛 + 1) donde 𝑚 y 𝑛 son la longitud de la
cadena del patrón y el texto respectivamente. Antes de rellenar la matriz, primero se
igualan las celdas 𝐶[0, 𝑗] = 0 y 𝐶[𝑖, 0] = 0, luego la matriz se expande de acuerdo a las
fórmulas recursivas de la ecuación 5.
𝐶[𝑖. 𝑗] = 𝑚𝑖𝑛 {
𝐶[𝑖 − 1, 𝑗 − 1] + 𝛿𝑖,𝑗𝐶[𝑖 − 1, 𝑗] + 1
𝐶[𝑖, 𝑗 − 1] + 1
Dónde
( 5 )
𝛿𝑖,𝑗 = {0, 𝑠𝑖 𝑝𝑖 = 𝑡𝑗
1, 𝑒𝑛 𝑜𝑡𝑟𝑜 𝑐𝑎𝑠𝑜
La comparación entre cadenas se puede determinar utilizando un valor k, que controle el
número de transformaciones básicas permitidas. Dada dos cadenas similares T =
“ATCATCAATC” y P = “TCAA”. Entonces, la matriz de distancia de edición que
representa el cálculo de la similitud entre las dos cadenas se muestra en la Figura 23, donde
la última fila de la matriz indica el número de diferencias entre las dos cadenas en esa
posición. El cero de la última fila es la solución al problema de ejemplo. Un valor de cero
en esta fila indica una coincidencia exacta; un valor de uno indica que hay al menos una
transformación necesaria para cambiar las cadenas entre sí y así sucesivamente.
A T C A T C A A T G
0 0 0 0 0 0 0 0 0 0 0
T 1 1 0 1 1 0 1 1 1 0 1
C 2 2 1 0 1 1 0 1 2 1 1
A 3 2 2 1 0 1 1 0 1 2 2
A 4 3 3 2 1 1 2 1 0 1 2
Figura 23. Matriz de edición de la distancia de Levenshtein
La complejidad temporal y espacial del algoritmo es 𝛰(𝑚𝑛), sin embargo, una simple
observación muestra que no es necesario almacenar toda la matriz en memoria, ya que
para calcular la siguiente columna basta conocer únicamente la columna anterior (Figura
35
24). Por lo tanto, manteniendo en memoria una sola columna la complejidad espacial se
reduce a 𝛰(𝑚).
A T C A T C A A T G
0 0
T 1
C 0
A 1
A 2
A T C A T C A A T G
0
T 1
C 0 1
A 1 0
A 2
A T C A T C A A T G
0
T 1
C 1
A 1 0
A 2 1
Caso inicial Caso recursivo En memoria Activo
Figura 24. Cálculo de la distancia de Levenshtein en espacio O(m).
3.2 La paralelización a nivel bit
La técnica de paralelización a nivel bit no es común en los algoritmos de alineación de
cadenas. La idea es aprovechar el hecho de que las computadoras realizan operaciones en
longitudes de palabras con ciertos números de bits. Usualmente estas longitudes son de
32 o 64 en las computadoras modernas, es decir, 32 o 64 bits pueden ser operados de
forma simultánea en el hardware de una computadora. Por lo tanto, paralelizando de esta
forma los algoritmos, se puede conseguir una velocidad mayor a la hora de realizar la
alineación de cadenas.
Uno de los algoritmos de alineación de cadenas que realiza paralelización a nivel de bits
es presentado por Gene Myers (Myers, 1999). Myers recodifica la matriz de programación
dinámica de la distancia de Levenshtein realizando el cálculo de las columnas de la matriz
pero en un tiempo 𝛰(𝑛) y 𝛰(1) en espacio, asumiendo que la longitud del patrón no
excede la longitud de la palabra de la computadora, la cual se denotará como w de aquí en
adelante.
3.2.1 La representación
Suponiendo que el tamaño del patrón es menor a w, considere la matriz de programación
dinámica de la Figura 25. Se puede notar que cada celda de la matriz difiere únicamente
por 1 de sus celdas vecinas. Estas diferencias pueden ser denotadas como deltas vertical
y horizontal como se describen en la ecuación 7 y el resultado de éstas se muestra en la
Figura 26.
36
A T C A T C A A T G
0 0 0 0 0 0 0 0 0 0 0
T 1 1 0 1 1 0 1 1 1 0 1
C 2 2 1 0 1 1 0 1 2 1 1
A 3 2 2 1 0 1 1 0 1 2 2
A 4 3 3 2 1 1 2 1 0 1 2
Figura 25. Matriz de programación dinámica
∆𝑣[𝑖, 𝑗] = 𝐶[𝑖, 𝑗] − 𝐶[𝑖 − 1, 𝑗]
∆ℎ[𝑖, 𝑗] = 𝐶[𝑖, 𝑗] − 𝐶[𝑖, 𝑗 − 1] (7)
A T C A T C A A T G
0 0 0 0 0 0 0 0 0 0 0
T 1 1 0 1 1 0 1 1 1 0 1
C 1 1 1 -1 0 1 -1 0 1 1 0
A 1 0 1 1 -1 0 1 -1 -1 1 1
A 1 1 1 1 1 0 1 1 -1 -1 0
A T C A T C A A T G
0 0 0 0 0 0 0 0 0 0 0
T 1 0 -1 1 0 -1 1 0 0 -1 1
C 2 0 -1 -1 1 0 -1 1 1 -1 0
A 3 1 0 -1 -1 1 0 -1 1 1 0
A 4 1 0 -1 -1 0 1 -1 -1 1 1
a) b)
Figura 26. Representación de la matriz de programación dinámica en deltas. a) Delta vertical ∆v. b) Delta horizontal ∆h
El objetivo principal es representar la matriz entera en un formato de vectores de bits, es
decir, vectores que almacenen dos valores, sin embargo, las deltas horizontal y vertical
pueden tener 3 posibles valores (-1, 0 y 1). Para solucionar el problema, cada valor positivo
y negativo se almacena en un vector aparte, formando así un total de 4 vectores de bits,
dos por cada delta: VP, VN, HP y HN (Figura 27). Dichos vectores almacenan un 1
cuando se cumplen sus igualdades de acuerdo a la ecuación 8, en otro caso almacenan un
0, donde la notación 𝑊𝑗(𝑖) indica el bit de la i-ésima posición en el entero W de la j-ésima
columna. De esta manera, la matriz original se ha representado en 4 vectores de bits, las
cuales reducen el espacio utilizado para calcular la distancia de edición.
A T C A T C A A T G A T C A T C A A T G
37
0 0 0 0 0 0 0 0 0 0 0
T 1 1 0 1 1 0 1 1 1 0 1
C 1 1 1 0 0 1 0 0 1 1 0
A 1 0 1 1 0 0 1 0 0 1 1
A 1 1 1 1 1 0 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0
T 0 0 0 0 0 0 0 0 0 0 0
C 0 0 0 1 0 0 1 0 0 0 0
A 0 0 0 0 1 0 0 1 1 0 0
A 0 0 0 0 0 0 0 0 1 1 0
a) b)
A T C A T C A A T G
0 0 0 0 0 0 0 0 0 0 0
T 1 0 0 1 0 0 1 0 0 0 1
C 2 0 0 0 1 0 0 1 1 0 0
A 3 1 0 0 0 1 0 0 1 1 0
A 4 1 0 0 0 0 1 0 0 1 1
A T C A T C A A T G
0 0 0 0 0 0 0 0 0 0 0
T 1 0 1 0 0 1 0 0 0 1 0
C 2 0 1 1 0 0 1 0 0 1 0
A 3 0 0 1 1 0 0 1 0 0 0
A 4 0 0 1 1 0 0 1 1 0 0
c) d)
Figura 27. Representación de la matriz de programación dinámica en vectores de bits. a) VP, los vectores positivos de ∆v. b) VN, los vectores negativos de ∆v. c) HP, los vectores positivos de ∆h. d) HN, los
vectores negativos de ∆h.
𝑉𝑃𝑗(𝑖) = 1 ↔ ∆𝑣[𝑖, 𝑗] = +1
𝑉𝑁𝑗(𝑖) = 1 ↔ ∆𝑣[𝑖, 𝑗] = −1
𝐻𝑃𝑗(𝑖) = 1 ↔ ∆ℎ[𝑖, 𝑗] = +1
𝐻𝑁𝑗(𝑖) = 1 ↔ ∆ℎ[𝑖, 𝑗] = −1
(8)
3.2.2 La estructura de las celdas
El problema ahora es cómo calcular los valores de cada vector a partir de los vectores de
la columna anterior. Para explicar esto se toma como base una estructura cuadrada de 4
celdas adyacentes de la matriz: 𝐶[𝑖 − 1, 𝑗 − 1], 𝐶[𝑖 − 1, 𝑗], 𝐶[𝑖, 𝑗 − 1] y 𝐶[𝑖, 𝑗]. En este
grupo de celdas existen dos deltas horizontales y dos verticales asociadas a las esquinas
del cuadrado como se ve en la Figura 28. Éstas mismas se pueden definir como entradas
y salidas de la siguiente manera: ∆vin = ∆v[i,j-1], ∆vout = ∆v[i,j], ∆hin = ∆h[i-1,j] y ∆vout =
∆v[i,j], además, se define Eq = Eq[i,j] que tendrá un valor de 1 cuando el carácter pi = tj y
0 en otro caso.
38
Figura 28. Representación de las celdas como entradas y salidas
Ahora se deben obtener las fórmulas que nos permitan encontrar el valor de
∆𝑣𝑜𝑢𝑡 y ∆ℎ𝑜𝑢𝑡, para esto se usan la definición de deltas y la recurrencia básica para
obtener los valores de cada casilla 𝐶[𝑖, 𝑗], de esta manera, se llega a las ecuaciones (9a)
para obtener ∆𝑣[𝑖, 𝑗] en términos de 𝐸𝑞[𝑖, 𝑗], ∆𝑣[𝑖, 𝑗 − 1] y ∆ℎ[𝑖 − 1, 𝑗]:
∆𝑣[𝑖, 𝑗] = 𝐶[𝑖, 𝑗] − 𝐶[𝑖 − 1, 𝑗]
(9a)
∆𝑣[𝑖, 𝑗] = 𝑚𝑖𝑛{
𝐶[𝑖 − 1, 𝑗 − 1] + (0 𝑠𝑖 𝑝𝑖 = 𝑡𝑗 𝑠𝑖𝑛𝑜 1)
𝐶[𝑖 − 1, 𝑗] + 1
𝐶[𝑖, 𝑗 − 1] + 1
} − 𝐶[𝑖 − 1, 𝑗]
∆𝑣[𝑖, 𝑗] = 𝑚𝑖𝑛{
𝐶[𝑖 − 1, 𝑗 − 1] + (1 − 𝐸𝑞[𝑖, 𝑗])
𝐶[𝑖 − 1, 𝑗 − 1] + ∆𝑣[𝑖, 𝑗 − 1] + 1
𝐶[𝑖 − 1, 𝑗 − 1] + ∆ℎ[𝑖 − 1, 𝑗] + 1
} − (𝐶[𝑖 − 1, 𝑗]
+ ∆𝑣[𝑖 − 1, 𝑗])
∆𝑣[𝑖, 𝑗] = 𝑚𝑖𝑛{
−𝐸𝑞[𝑖, 𝑗]
∆𝑣[𝑖, 𝑗 − 1]
∆ℎ[𝑖 − 1, 𝑗]} + (1 − ∆ℎ[𝑖 − 1, 𝑗])
∆𝑣𝑜𝑢𝑡 = 𝑚𝑖𝑛 {
−𝐸𝑞
∆𝑣𝑖𝑛∆ℎ𝑖𝑛
} + (1 − ∆ℎ𝑖𝑛)
De manera similar se determina la fórmula para ∆ℎ[𝑖, 𝑗], obteniendo las ecuaciones (9b):
39
∆ℎ[𝑖, 𝑗] = 𝑚𝑖𝑛{
−𝐸𝑞[𝑖, 𝑗]
∆𝑣[𝑖, 𝑗 − 1]
∆ℎ[𝑖 − 1, 𝑗]} + (1
− ∆𝑣[𝑖, 𝑗 − 1]) (9b)
∆ℎ𝑜𝑢𝑡 = 𝑚𝑖𝑛 {
−𝐸𝑞
∆𝑣𝑖𝑛∆ℎ𝑖𝑛
} + (1 − ∆𝑣𝑖𝑛)
3.2.3 Cálculo de las celdas lógicas
Conociendo a ∆𝑣𝑖𝑛 , ∆ℎ𝑖𝑛 y 𝐸𝑞 es suficiente para determinar ∆𝑣𝑜𝑢𝑡 y ∆ℎ𝑜𝑢𝑡 para cada
celda. Además, observando que existen 3 posibles valores para ∆𝑣𝑖𝑛 y ∆ℎ𝑖𝑛 , y dos para
𝐸𝑞, da una combinación de 18 posibles valores de salida para cada celda, tal como se
muestra en la Tabla 2. De aquí surge la idea clave de que es posible calcular los valores de
una columna usando lógica booleana.
40
Tabla 2. Todas las combinaciones de ∆vin, ∆hin y Eq para obtener ∆vout y, ∆hout
Basados en la tabla anterior, se puede notar que existe una relación directa entre los
valores de ∆ℎ𝑖𝑛 y ∆𝑣𝑜𝑢𝑡 , donde nos resulta conceptualmente más fácil ver a ∆𝑣𝑜𝑢𝑡
como una función de ∆ℎ𝑖𝑛 ya que sus valores parecen tener un patrón. Se observa que
∆𝑣𝑜𝑢𝑡 = −1 siempre que ∆ℎ𝑖𝑛 = 1, sin embargo esto ocurre únicamente en las filas del
1 a 12, en el resto, los valores de ∆𝑣𝑜𝑢𝑡 cambian cuando ∆ℎ𝑖𝑛 sigue siendo 1. Otra
observación es que ∆𝑣𝑜𝑢𝑡 = 1 siempre que ∆ℎ𝑖𝑛 = −1, sin embargo en algunas filas del
13 al 18 ∆𝑣𝑜𝑢𝑡 aparece con valores de 1 pero en esas filas ∆ℎ𝑖𝑛 no tiene valor de -1.
Basándose en estas observaciones, se puede notar que los efectos en ambos casos suceden
antes y después de la fila 12. De acuerdo a esto, se podrían usar las filas donde aparece
∆𝑣𝑖𝑛 = −1 y 𝐸𝑞 = 1 y así lograr abarcar el rango de filas mencionado.
Ahora se pueden determinar las expresiones booleanas que permitan calcular los valores
de cada vector de bits. Primero se buscan las expresiones para obtener los valores de
𝑉𝑃𝑜𝑢𝑡 y 𝑉𝑁𝑜𝑢𝑡 que juntas representan a ∆𝑣𝑜𝑢𝑡. Para ello se define un vector booleano
N° ∆hin ∆vin Eq ∆hout ∆vout
1 -1 -1 1 1 1
2 0 -1 1 1 0
3 1 -1 1 1 -1
4 -1 0 1 0 1
5 0 0 1 0 0
6 1 0 1 0 -1
7 -1 1 1 -1 1
8 0 1 1 -1 0
9 1 1 1 -1 -1
10 -1 -1 0 1 1
11 0 -1 0 1 0
12 1 -1 0 1 -1
13 -1 0 0 0 1
14 0 0 0 1 1
15 1 0 0 1 0
16 -1 1 0 -1 1
17 0 1 0 0 1
18 1 1 0 0 0
41
𝑋𝑣 auxiliar permita capturar los efectos de los valores en ∆𝑣𝑜𝑢𝑡 utilizando 𝑉𝑁𝑖𝑛 y 𝐸𝑞.
Entonces, de la tabla, se pueden verificar las fórmulas lógicas de la ecuación (10a).
𝑋𝑣 = 𝐸𝑞 𝑜𝑟 𝑉𝑁𝑖𝑛𝑉𝑃𝑜𝑢𝑡 = 𝐻𝑁𝑖𝑛 𝑜𝑟 𝑛𝑜𝑡(𝑋𝑣 𝑜𝑟 𝐻𝑃𝑖𝑛)
𝑉𝑁𝑜𝑢𝑡 = 𝐻𝑃𝑖𝑛 𝑎𝑛𝑑 𝑋𝑣 (10a)
Estudiando la relación entre ∆ℎ𝑜𝑢𝑡 y ∆𝑣𝑖𝑛 modulado por el vector auxiliar 𝑋ℎ, da como
resultado las fórmulas simétricas de la ecuación (10b) para calcular los valores de los
vectores de bits 𝐻𝑃𝑜𝑢𝑡 y 𝐻𝑁𝑜𝑢𝑡
𝑋ℎ = 𝐸𝑞 𝑜𝑟 𝐻𝑁𝑖𝑛𝐻𝑃𝑜𝑢𝑡 = 𝑉𝑁𝑖𝑛 𝑜𝑟 𝑛𝑜𝑡(𝑋ℎ 𝑜𝑟 𝑉𝑃𝑖𝑛)
𝐻𝑁𝑜𝑢𝑡 = 𝑉𝑃𝑖𝑛 𝑎𝑛𝑑 𝑋ℎ (10b)
3.2.4 Preprocesamiento del alfabeto
Es necesario codificar los caracteres del patrón en vectores de bits para usarlos en las
fórmulas obtenidas anteriormente. En términos de vectores de bits se requiere de un
entero 𝐸𝑞𝑗 donde 𝐸𝑞𝑗(𝑖) ≡ (𝑝𝑖 = 𝑡𝑗). Para el cálculo de estos enteros se requiere un
tiempo 𝛰(𝑚), sin embargo, este cálculo no entra en el algoritmo principal sino como
parte del preprocesamiento. Para obtener estos vectores de bits se construye un arreglo
𝑃𝑒𝑞[𝑐] del tamaño ∣∑∣ donde se toma cada símbolo c del alfabeto como un vector, el
cual puede ser precalculado utilizando la ecuación 11. Entonces cualquier carácter del
texto en la j-ésima posición se puede encontrar usando 𝑃𝑒𝑞[𝑡𝑗]. La Figura 29 muestra el
resultado del preprocesamiento del patrón que se ha usado en la explicación.
𝑃𝑒𝑞[𝑐](𝑖) = 1 ↔ 𝑝𝑖 = 𝑐 (11)
42
A C G T
T 0 0 0 1
C 0 1 0 0
A 1 0 0 0
A 1 0 0 0
Figura 29. Preprocesamiento del patrón P=”TCAA”
3.2.5 Cálculo de la distancia de edición
El objetivo del algoritmo es el cálculo de la distancia de edición a partir de los vectores de
bits, donde cada vector de bits es actualizado a partir de los valores viejos, similar a usar
solamente una columna de la matriz para calcular C. Por esta razón, en esta parte los
vectores de bits serán vistos como vectores de cada columna j para un mejor
entendimiento.
El par de vectores de bits (𝑉𝑃𝑗 y 𝑉𝑁𝑗) que son la codificación de ∆𝑣𝑗, dan alguna
información de la columna 𝑗 − 1. Por inducción se puede observar que ∆𝑣0 tiene los
siguientes valores, donde 𝑉𝑃0 = 1′𝑠 y 𝑉𝑁0 = 0’s (Figura 27 a y b), el cual representa el
caso base del algoritmo. Entonces, para calcular el resto de los vectores se requiere de dos
etapas:
1. Primero, los vectores de bits 𝑉𝑃𝑗−1 y 𝑉𝑁𝑗−1, son usados para calcular los vectores
𝐻𝑃𝑗 y 𝐻𝑁𝑗 mediante las ecuaciones 9b
2. Después, los vectores 𝐻𝑃𝑗 y 𝐻𝑁𝑗 son usados como entrada para obtener los
vectores 𝑉𝑃𝑗 y 𝑉𝑁𝑗 utilizando las ecuaciones 9a.
Se sabe que las distancias de edición se obtienen de la última columna de la matriz y
además, el último valor de la primera columna de la matriz original es la longitud del
patrón buscado, entonces, se puede utilizar un contador de la distancia recorrida
inicializada con el valor de m, después utilizando únicamente el m-ésimo bit de los
vectores 𝐻𝑃𝑗 y 𝐻𝑁𝑗 es suficiente para actualizar el conteo de la distancia, donde un valor
de 1 en 𝐻𝑃𝑗 indica un incremento en el contador y un 1 en 𝐻𝑁𝑗 un decremento.
43
3.2.6 Obteniendo los vectores X
Lo mencionado anteriormente es válido, sin embargo no se ha considerado el cálculo de
los vectores auxiliares 𝑋𝑣 y 𝑋ℎ. En las fórmulas lógicas de la ecuación 12 se tiene las
siguientes definiciones para cada vector auxiliar:
𝑋𝑣𝑗(𝑖) = 𝑃𝑒𝑞[𝑡𝑗](𝑖) 𝑜𝑟 𝑉𝑁𝑗−1(𝑖)
𝑋ℎ𝑗(𝑖) = 𝑃𝑒𝑞[𝑡𝑗](𝑖) 𝑜𝑟 𝐻𝑁𝑗(𝑖 − 1) (12)
Calcular 𝑋𝑣𝑗 no tiene ningún problema ya que el vector 𝑉𝑁𝑗−1 es una de las entradas para
obtener los siguientes vectores, por otra parte, calcular el vector 𝑋ℎ𝑗 requiere el valor
𝑉𝑁𝑗−1 que en secuencia requiere un valor anterior. Entonces, se tiene un problema de
dependencia cíclica mostrada en la ecuación 13 que se debe desenvolver
𝑋ℎ𝑗(𝑖) = 𝑃𝑒𝑞[𝑡𝑗](𝑖) 𝑜𝑟 𝐻𝑁𝑗(𝑖 − 1)
= 𝑃𝑒𝑞[𝑡𝑗](𝑖) 𝑜𝑟 (𝑉𝑃𝑗−1(𝑖 − 1) 𝑎𝑛𝑑 𝑃𝑒𝑞[𝑡𝑗](𝑖 − 1))
𝑜𝑟 (𝑉𝑃𝑗−1(𝑖 − 1) 𝑎𝑛𝑑 𝐻𝑁𝑗(𝑖 − 2))
= 𝑃𝑒𝑞[𝑡𝑗](𝑖) 𝑜𝑟 (𝑉𝑃𝑗−1(𝑖 − 1) 𝑎𝑛𝑑 𝑃𝑒𝑞[𝑡𝑗](𝑖 − 1))
𝑜𝑟 (𝑉𝑃𝑗−1(𝑖 − 1) 𝑎𝑛𝑑 𝑉𝑃𝑗−1(𝑖 − 2) 𝑎𝑛𝑑 𝑃𝑒𝑞[𝑡𝑗](𝑖 − 2))
𝑜𝑟 (𝑉𝑃𝑗−1(𝑖 − 1) 𝑎𝑛𝑑 𝑉𝑃𝑗−1(𝑖 − 2) 𝑎𝑛𝑑 𝐻𝑁𝑗(𝑖 − 3))= ⋯
= ∃𝑘 ≤ 𝑖, 𝑃𝑒𝑞[𝑡𝑗](𝑘) 𝑎𝑛𝑑 ∀𝑥 ∈ [𝑘, 𝑖 − 1], 𝑉𝑃𝑗−1(𝑥) 𝑑𝑜𝑛𝑑𝑒 𝐻𝑁0(0) = 0
(13)
Para calcular 𝑋ℎ𝑗(𝑖) en una única operación de bits, podría usarse algún tipo de
propagación de bits, similar a la propagación por acarreo en las operaciones de sumas de
números binarios, obteniendo la ecuación 14.
𝑋ℎ𝑗(𝑖) = (((𝑃𝑒𝑞[𝑡𝑗] & 𝑉𝑃𝑗−1) + 𝑉𝑃𝑗−1) ∧ 𝑉𝑃𝑗−1| 𝑃𝑒𝑞[𝑡𝑗] ) (14)
Donde las operaciones lógicas son realizadas en todos los elementos de los vectores de
bits de forma simultánea. El procedimiento detallado de este resultado se describe en el
artículo original (Myers, 1999).
44
3.2.7 El algoritmo completo
El Algoritmo 2 representa el algoritmo de Myers al estilo de programación en C adaptado
del artículo original. Dicho algoritmo resuelve el problema de alineación de cadenas en
tiempo 𝛰(𝑚 + 𝑛) y 𝛰(|𝛴|) en espacio, asumiendo que la longitud del patrón no es mayor
al tamaño de palabra de una computadora.
Algoritmo 2. Algoritmo de Myers utilizando paralelización a nivel de bit.
1 Precomputo de Peq[c] 2 VP = 1m
3 VN = 0m 4 Score = m 5 for j=1,2,…,n do 6 { 7 Eq = Peq[tj] 8 Xv = Eq | VN 9 Xh = (((Eq & VP) + VP) ^ VP) | Eq 10 HP = VN | ~(Xh | VP) 11 HN = VP & Xh 12 if HP & 10m-1 then 13 Score += 1 14 else if HN & 10m-1 then 15 Score -=1 16 HP <<= 1 17 HN <<= 1 18 VP = HN | ~(Xv | HP) 19 VN = HP & Xv 20 If Score ≤ k then 21 printf “Coincidencia en ” . j 22 }
La línea 1 es el precómputo de Peq, el cual requiere un tiempo de 𝛰(𝑚) para calcularlo.
La inicialización de los valores de los vectores bases VP, VN y la variable Score aparecen
en las líneas del 2 al 4. El núcleo del programa aparece entre las líneas 5 al 22 y requiere
únicamente un tiempo de 𝛰(𝑛). Primero se obtiene el vector correspondiente de Peq
utilizando el carácter tj del texto de referencia (línea 5), el valor de Peq[tj] es usado para
obtener los vectores auxiliares Xv y Xh (líneas 8 y 9). Hasta aquí se tiene los 5 vectores
intermediarios Eq, Xv, Xh, VP y VN los cuales serán usados para calcular los nuevos
vectores correspondiente a la columna j. Entonces, se calculan los vectores horizontales
HP y HN (líneas 10 y 11) los cuales representan a HPin y HNin, la variable Score es
actualizado al valor de Scorej utilizando el m-ésimo bit de HP o HN (líneas 12 al 15).
Después HP y HN son actualizados para obtener HPout HNout, lo cual se logra haciendo
un desplazamiento de bits a la izquierda (líneas 16 y 17). Teniendo los nuevos valores de
45
HP y HN se actualizan los valores de VP y VN (líneas 18 y 19) las cuales servirán de
entrada en la siguiente iteración del algoritmo. Finalmente para ver si se tiene éxito en la
alineación se compara la distancia actual con k que representa el número máximo de
transformaciones permitidas en la alineación.
3.2.8 El modelo basado en bloques
Con el fin de extender el algoritmo básico para un caso general, donde no exista
restricción de la longitud del patrón, se realizan los cálculos de las columnas mediante
bloques de vectores de tamaño 𝑤 (Figura 30a). Para esto el preprocesamiento de la cadena
patrón es dividido también en bloques del tamaño w de la palabra. El cálculo de un bloque
para la distancia de edición se realiza al igual que el de una celda de la matriz de
programación dinámica, ya que un bloque depende únicamente de los valores de bloques
anteriores, por lo tanto se calculan b bloques de una columna en un solo barrido,
suponiendo que 𝑏 = 𝑚/𝑤 y que 𝑚 ≥ 𝑤 . Ahora, la complejidad temporal del algoritmo
basado bloques es de 𝛰(𝑚 + [𝑚𝑛/𝑤]), mientras que la complejidad espacial es
𝛰([𝑚/𝑤]).
Texto
P b1
a
t
r b2
ó
n
b3 bitmax
Texto
P b1
a
t
r b2
ó
n
b3
a) b) Figura 30. Cálculo de la distancia de edición basado en bloques.
Para realiza el cálculo de la distancia de edición basado en bloques se consideran los
siguientes puntos importantes:
1. El cálculo de los vectores se realiza mediante columnas como en el algoritmo base,
para que se almacenen únicamente una columna de bloques de la matriz.
46
2. Los bloques en los límites superiores de la matriz tienen deltas de 0 en el bit menos
significativo, sin embargo, los bloques inferiores tienen deltas 0 o 1 debido al
desplazamiento de bits de los bloques superiores.
3. Los bloques en el último nivel pueden extenderse más allá del bit que corresponde
a la longitud m de la cadena patrón, es decir bitmax = w - m (mod w).
Existen unos algoritmos que calculan cierta parte de la matriz de programación dinámica,
como en (Ukkonen, 1985), el cual se basa en el número k de transformaciones permitidas.
Esta idea puede aprovecharse para calcular únicamente los bloques necesarios tal como
lo muestra Figura 30b, donde se muestra la zona hipotética calculada por este algoritmo,
dicho operación se le conoce como cálculo de bloques por bandas.
47
Capítulo 4
4 DISEÑO DEL ALINEADOR
En este capítulo se presenta el diseño e implementación del programa de alineación. El
capítulo comienza con la obtención de los requisitos del diseño, a continuación se describe
brevemente la funcionalidad general del sistema mencionando los módulos principales
para realizar todo el proceso de alineación. Después se realiza el diseño para cada una de
las fases de siembra y extensión. Finalmente se presentan los puntos clave de la
implementación del alineador, donde se presentan los diagramas de módulos realizados
para cada una de las fases y la integración de las mismas. El proceso de desarrollo del
alineador está basado en el modelo de ciclo de vida secuencial, mostrado previamente en
la Figura 2.
4.1 Requisitos de diseño
En base al análisis del problema de alineación, así como del estado de arte de los
programas de alineación revisada en capítulos previos, se determinaron los siguientes
requerimientos del sistema, en general se desea:
48
Un alineador genérico basado en la técnica siembra y extiende, utilizando el
algoritmo de FM para la fase de siembra y el algoritmo de Myers para la fase de
extensión.
El alineador debe permitir la alineación de lecturas cortas entre 70 y 100
nucleótidos a genomas de referencia de hasta 1 millón de nucleótidos.
El alineador recibirá como entrada los índices de FM de la referencia, las lecturas
cortas en formato FASTQ y opcionalmente, el valor de errores permitidos elegido
por el usuario entre 0 y 3.
Los índices de FM de la referencia serán obtenidos anticipadamente mediante la
función index del programa BWA.
Las lecturas cortas de entrada serán generadas artificialmente por el programa
Wgsim.
El diseño debe reportar una de las mejores alineaciones, e incluir las mutaciones,
inserciones y eliminaciones.
Todos los resultados deben ser compatibles con el formato SAM.
Para verificar la alineación correcta de las lecturas, el programa debe incluir una
función que imprima la alineación de la lectura en la región correspondiente de la
referencia.
4.2 Descripción general del programa
Después de conocer los requisitos del alineador se establece en la Figura 35 su esquema
general, el cual consiste fundamentalmente de los módulos: siembra y extensión. Los
datos de entrada del alineador son: los archivos con los índices de FM, el archivo con las
lecturas cortas en formato FASTQ, la cadena de referencia comprimida y un valor de
error opcional que limita el número de operaciones permitidas para la alineación de las
lecturas, en caso de que este último no sea proporcionado se utiliza un valor por defecto.
El proceso de alineación inicia en la fase de siembra, el primer paso consiste en leer una
lectura corta y encontrar semillas a partir de ella (Figura 31a), para éste proceso se define
primeramente la longitud mínima de la semilla a partir del valor de error, luego para
49
determinar las semillas, se intenta alinear la lectura entera respecto a la cadena de
referencia, este proceso se realiza mediante el algoritmo de búsqueda hacia atrás utilizando
los índices de FM. Si la lectura se alinea exactamente entonces se excluye todo el proceso
de extensión y se pasa directamente a generar los resultados de alineación de la lectura en
formato SAM (Li, Handsaker, A, & al., 2009). En caso contrario, se van obteniendo las
subcadenas de la lectura que se alineen exactamente y éstas serán consideradas semillas
candidatas si tienen una longitud no menor a la longitud mínima precalculada. Una vez
obtenida una semilla de longitud deseable el segundo paso es calcular la región donde ésta
se ha alineado en la cadena de referencia (Figura 31b), en este paso se ubica primero la
posición donde la semilla comienza a alinearse, después se calcula la posición de inicio y
fin de dicha región, la cual tendrá el tamaño de la lectura corta más un margen de error
en cada extremo. El resultado de este paso es una subcadena de la referencia que será
usado como entrada en la fase de extensión y con esto finaliza la etapa de siembra.
Figura 31. Esquema general del alineador.
.FQ Índices
de FM
.SAM
ALINEADOR DE LECTURAS
Error
Ref.
Generar formato
SAM Alineación
exacta
e
Obtener semilla
Calcular región
b
Semilla
Calcular distancia de
edición
Ruta de alineación
c
d
Vectores de
dirección
a
SIEMBRA
EXTENSIÓ
N
Alineación
inexacta
Lectura y
Texto ref.
50
Una vez finalizada la etapa de siembra se inicia la etapa de extensión, la cual tiene como
objetivo alinear de forma inexacta la lectura corta y el segmento de la referencia
encontrada en la etapa de siembra. Él proceso inicia con el cálculo de la distancia de
edición entre ambas cadenas utilizando el algoritmo de Myers (Figura 31c), dicho proceso
genera como resultado la distancia mínima entre las cadenas, la columna de la distancia
mínima y los vectores de bits que almacenan las direcciones de todas las rutas posibles.
Posteriormente se procede a calcular la ruta de alineación (Figura 31d), donde se utilizan
los vectores de bits para realizar el recorrido hacia atrás, formando y almacenando las
operaciones que se realizan para transformar la lectura a la cadena de referencia.
Finalmente a partir de los resultados de la alineación se construye el archivo en formato
SAM (Figura 31e), que representa la salida del alineador y contiene toda la información
de la alineación de la lectura corta.
4.3 Diseño del alineador
En esta sección se procede a diseñar cada uno de los módulos del alineador, el primer
módulo consiste en la etapa de siembra, donde se define el tipo de semilla a utilizar y la
forma de búsqueda de cada una de las semillas que pueden formarse a partir de la lectura
corta y el método usado para obtener la subcadena de la referencia en la región donde la
semilla se alineó. Posteriormente se diseña la etapa de extensión, donde se describe el
cálculo de la máscara de bits por bloques, al igual que el algoritmo de Myers y la forma de
obtener la ruta de alineación a partir de los vectores de bits.
4.3.1 La etapa de siembra
4.3.1.1 El tipo de semilla
El tipo de semilla utilizada es la SMEM, debido a que tienen una gran ventaja respecto a
las semillas de longitud fija, tal como se describe en (Ahmed, Bertels, & Al-Ars, 2016),
además, la longitud de una semilla SMEM puede ser tan grande como la lectura corta, de
tal manera que se puede determinar inmediatamente cuándo una lectura corta se alinea
exactamente a la cadena de referencia sin necesidad de realizar la etapa de extensión. El
tipo SMEM elegido es sin traslape, ya que son más fáciles de calcular en comparación con
las SMEM traslapadas.
51
Para determinar el tamaño mínimo de una semilla SMEM, se utiliza la técnica de las cajas
del palomar descrita en la sección 2.4.1.2.1, con la finalidad de encontrar por lo menos
alguna semilla que se pueda alinear a la referencia. De esta manera, la longitud mínima de
una semilla se determina mediante la ecuación 17:
𝑙𝑜𝑛𝑔𝑖𝑡𝑢𝑑 𝑠𝑒𝑚𝑖𝑙𝑙𝑎 = 𝑙𝑜𝑛𝑔𝑖𝑡𝑢𝑑 𝑑𝑒 𝑙𝑒𝑐𝑡𝑢𝑟𝑎 𝑐𝑜𝑟𝑡𝑎
(𝑒𝑟𝑟𝑜𝑟 + 1) (17)
Ahora, teniendo en cuenta que mientras que el valor del error aumenta, el tamaño de la
semilla disminuye y en consecuencia esto provoca alineaciones en múltiples regiones de
la referencia, se limita a un número máximo de 3 errores, así, considerando lecturas cortas
de 100 nucleótidos, el tamaño mínimo de semilla será de 25.
4.3.1.2 Búsqueda de semillas usando índices de FM
Para obtener las semillas se utilizó el algoritmo de búsqueda exacta presentado en la
sección 2.4.1.2.2. Mediante la búsqueda hacia atrás se puede determinar una semilla,
tomando cada carácter de la lectura corta de derecha a izquierda hasta encontrar un
intervalo no válido, lo cual indica que con el último carácter procesado, el prefijo formado
no aparece en la cadena de referencia, por lo tanto se toma como semilla la subcadena
formada sin considerar el carácter que provoca el error (Figura 32). Una vez encontrada
la primera semilla, la siguiente es calculada a partir del carácter donde se encontró el error,
sin embargo, si el error fue ocasionado por un carácter ‘N’, el cual puede interpretarse
como un nucleótido ambiguo, entonces, la siguiente semilla es calculada después de la
posición de este carácter.
52
Figura 32. Búsqueda de semillas SMEM no traslapadas.
Realizando la búsqueda hacia atrás se van formado subcadenas de longitud variable, de
las cuales surgen 3 posibles tipos de semillas. El primer tipo comprende las semillas no
candidatas (Figura 32a), las cuales no llegan a tener la longitud mínima requerida y por lo
tanto son desechadas. El segundo son las semillas candidatas que tienen una longitud
mayor o igual a la mínima requerida (Figura 32b), éstas son el tipo de semillas buscadas
para la fase de extensión. El tercero es la semilla sin procesar, la cual no requiere ser
buscada ya que la longitud restante de la lectura corta no es suficiente para considerarla
como semilla candidata (Figura 32c).
Una vez encontrada una semilla candidata, se almacena 3 datos importantes para la fase
de extensión: la posición de inicio en la lectura corta y los valores del intervalo (k y l). La
posición de inicio permite saber con exactitud cuánto hay que extender la semilla en
ambos lados (izquierda y derecha), mientras que el intervalo permite saber el número de
regiones donde la semilla se ha alineado. Existen casos especiales durante la fase de
siembra, el primero es cuando una semilla llega a alcanzar la longitud de la lectura corta,
lo cual indica una alineación exacta de dicha lectura respecto a la cadena de referencia y
por tanto no es necesario realizar la fase de extensión. El segundo caso es cuando la lectura
corta no obtiene alguna semilla candidata, esto sucede cuando el número de errores
permitidos es menor a los que se encuentran en la alineación de la lectura, al igual que el
caso anterior no es necesario la fase de extensión y dicha lectura es considerada como
lectura no alineada.
4.3.1.3 Cálculo de regiones de siembra
Una vez alineada la semilla a la cadena de referencia, es necesario determinar la región
donde dicha semilla se alinea y expandirla a una longitud mayor a la lectura corta, esto es
53
con el propósito de obtener la subcadena de la referencia que se alineará de forma inexacta
con la lectura corta en la fase de extensión. Para determinar las regiones de siembra se
utiliza el intervalo que devuelve el algoritmo de búsqueda exacta (valores k y l), los cuales
permiten calcular los (𝑙 − 𝑘 + 1) regiones. Los valores de k y l son usados como índice
del arreglo de sufijos para obtener la posición de inicio donde la semilla comienza a
alinearse en la cadena de referencia. Teniendo el valor del arreglo de sufijo, se procede a
calcular la posición de inicio y fin de la región del texto de referencia tal como se muestra
en la Figura 33.
Figura 33. Cálculo de la expansión de la alineación de la semilla a la longitud de la lectura corta.
Se considera la posibilidad de que durante la alineación se realizan operaciones de
eliminación de nucleótidos en la lectura corta, lo cual significa que hay inserciones de
caracteres en la cadena de referencia y por esta razón la región requiere un espacio mayor
al tamaño de la lectura corta. Para solucionarlo se agregan márgenes en cada extremo de
la región previamente ampliada, donde el valor del margen es igual al número de errores
permitidos para la alineación (Figura 34).
Figura 34. Márgenes en ambos extremos de la extensión de la semilla.
54
La expansión de la semilla a lo largo de la cadena de referencia debe quedar dentro de un
intervalo válido, sin embargo, se pueden dar casos donde, a la hora de ampliar la región
de alineación de la semilla a la longitud de la lectura corta se tenga un inicio o fin fuera de
la longitud en la referencia. En tal caso, si el inicio o final queda justo donde abarca el
margen de error (Figura 35a) la semilla sigue siendo válida para la etapa de extensión, en
caso contrario, si la extensión toma un intervalo que ni el margen puede cubrir, entonces
la semilla queda descartada (Figura 35b).
Figura 35. Extensión válida de la semilla en los límites de la cadena de referencia.
4.3.2 La etapa de extensión
4.3.2.1 Modificaciones adicionales al algoritmo de Myers
El algoritmo original de Myers sólo realiza el cálculo de la distancia de edición, sin
embargo, para reportar los resultados del alineador en formato SAM es necesario obtener
la ruta de alineación. Partiendo del mejor puntaje de alineación entre dos secuencias de
ADN, se puede determinar la ruta de alineación al igual que los algoritmos de Smith
Waterman y Needleman-Wunsch. Este proceso no ha sido implementado para el
algoritmo de Myers, por tal razón, esta sección está dedicada a la explicación de la
propuesta realizada.
4.3.2.2 Rutas a partir de la matriz de programación dinámica
Suponiendo que se tiene el patrón P=”GCGCAATG”, el texto de referencia
t=”GCCATAGCG” y el número de errores k=3. Entonces, de acuerdo al algoritmo de
programación dinámica descrito en la sección 3.1, la matriz resultante es la que se muestra
en la Figura 36, donde las flechas de dirección indican la celda de la cual precede la celda
C[i,j]. Apoyándose de las flechas de dirección se puede realizar el recorrido hacia atrás
55
partiendo de la distancia de edición mínima. Al encontrar una distancia de edición, es
posible que ésta internamente se divida en dos o más rutas. Si existe más de una distancia
de edición mínima las posibilidades de encontrar un número mayor de rutas aumenta. No
obstante, ya que la distancia de edición determina únicamente la menor cantidad de
operaciones entre ambas cadenas, en este trabajo nos limitamos a tomar una de ellas. En
el ejemplo, la mejor distancia de edición es 3, entonces, a partir de las casillas con este
valor se realiza un recorrido hacia atrás para determinar la ruta de alineación, tal proceso
se realiza de derecha a izquierda y se apoya de las flechas de dirección vertical, horizontal
y diagonal para moverse en toda la matriz de alineación, finalizando cuando se llega a una
de las casillas con valor 0 de la primera fina de la matriz (Figura 37).
G C C A T A G C G
0 0 0 0 0 0 0 0 0 0
G 1 0 1 1 1 1 1 0 1 0
C 2 1 0 1 2 2 2 1 0 1
G 3 2 1 1 2 3 3 2 1 0
C 4 3 2 1 2 3 4 3 2 1
A 5 4 3 2 1 2 3 4 3 2
A 6 5 4 3 2 2 2 3 4 3
T 7 6 5 4 3 2 3 3 4 4
G 8 7 6 5 4 3 3 3 4 4
Figura 36. Matriz de programación dinámica con todas las direcciones.
G C C A T A G C G
0 0 0 0 0 0 0 0 0 0
G 1 0 1 1 1 1 1 0 1 0
C 2 1 0 1 2 2 2 1 0 1
G 3 2 1 1 2 3 3 2 1 0
C 4 3 2 1 2 3 4 3 2 1
A 5 4 3 2 1 2 3 4 3 2
A 6 5 4 3 2 2 2 3 4 3
T 7 6 5 4 3 2 3 3 4 4
G 8 7 6 5 4 3 3 3 4 4
Figura 37. Rutas de alineación para P=” GCGCAATG” y t=” GCCATAGCG” con k=3.
Las flechas de dirección se pueden obtener a partir de los valores de la matriz de distancia,
por ejemplo, las flechas verticales siempre aparecen cada vez que la celda C[i,j] es mayor
que C[i-1,j] (Figura 38a), lo mismo sucede con las flechas horizontales, las cuales aparecen
cuando el valor de C[i,j] es mayor que C[i,j-1] (Figura 38b). Estas direcciones se dan por
las fórmulas 2 y 3 de la ecuación 6, donde la siguiente casilla es calculada a partir del valor
de la casilla superior o izquierda, respectivamente en cada caso. Para el caso de las flechas
de dirección en diagonal existen dos casos para determinarlas, la primera es por la
coincidencia entre caracteres 𝑝𝑖 = 𝑡𝑗 y la segunda es cuando la celda C[i,j] es mayor que
C[i-1,j-1] (Figura 38c).
56
G C C A T A G C G
0 0 0 0 0 0 0 0 0 0
G 1 0 1 1 1 1 1 0 1 0
C 2 1 0 1 2 2 2 1 0 1
G 3 2 1 1 2 3 3 2 1 0
C 4 3 2 1 2 3 4 3 2 1
A 5 4 3 2 1 2 3 4 3 2
A 6 5 4 3 2 2 2 3 4 3
T 7 6 5 4 3 2 3 3 4 4
G 8 7 6 5 4 3 3 3 4 4
G C C A T A G C G
0 0 0 0 0 0 0 0 0 0
G 1 0 1 1 1 1 1 0 1 0
C 2 1 0 1 2 2 2 1 0 1
G 3 2 1 1 2 3 3 2 1 0
C 4 3 2 1 2 3 4 3 2 1
A 5 4 3 2 1 2 3 4 3 2
A 6 5 4 3 2 2 2 3 4 3
T 7 6 5 4 3 2 3 3 4 4
G 8 7 6 5 4 3 3 3 4 4
G C C A T A G C G
0 0 0 0 0 0 0 0 0 0
G 1 0 1 1 1 1 1 0 1 0
C 2 1 0 1 2 2 2 1 0 1
G 3 2 1 1 2 3 3 2 1 0
C 4 3 2 1 2 3 4 3 2 1
A 5 4 3 2 1 2 3 4 3 2
A 6 5 4 3 2 2 2 3 4 3
T 7 6 5 4 3 2 3 3 4 4
G 8 7 6 5 4 3 3 3 4 4
a) b) c)
Figura 38. Direcciones de alineación. a) Direcciones verticales. b) Direcciones horizontales. c) Direcciones diagonales por coincidencia pi = tj (celdas amarillas) y direcciones por diferencia (celdas azules)
4.3.3 Definiendo los vectores de bits
En el capítulo 3 se explica cómo representar la matriz de programación dinámica en
vectores de bits para el cálculo de la distancia de edición de Leveishten. Ahora, la idea
para obtener la ruta de alineación es aprovechar estos mismos vectores de bits y realizar
el recorrido hacia atrás haciendo comparaciones a nivel de bit. De acuerdo a las
observaciones realizadas para hallar las direcciones de alineación, se puede notar que las
direcciones verticales y horizontales pueden obtenerse directamente utilizando los
vectores VP y HP (Figura 34 a y b) que aparecen en el algoritmo de Myers, ya que son los
únicos que almacenan los valores positivos de acuerdo a las fórmulas de la ecuación 8.
G C C A T A G C G
0 0 0 0 0 0 0 0 0 0
G 1 0 1 1 1 1 1 0 1 0
C 1 1 0 0 1 1 1 1 0 1
G 1 1 1 0 0 1 1 1 1 0
C 1 1 1 0 0 0 1 1 1 1
A 1 1 1 1 0 0 0 1 1 1
A 1 1 1 1 1 0 0 0 1 1
T 1 1 1 1 1 0 1 0 0 1
G 1 1 1 1 1 1 0 0 0 0
G C C A T A G C G
0 0 0 0 0 0 0 0 0 0
G 1 0 1 0 0 0 0 0 1 0
C 2 0 0 1 1 0 0 0 0 1
G 3 0 0 0 1 1 0 0 0 0
C 4 0 0 0 1 1 1 0 0 0
A 5 0 0 0 0 1 1 1 0 0
A 6 0 0 0 0 0 0 1 1 0
T 7 0 0 0 0 0 1 0 1 0
G 8 0 0 0 0 0 0 0 1 0
G C C A T A G C G
0 0 0 0 0 0 0 0 0
G 1 1 1 1 1 1 1 1 1 0
C 2 0 1 1 1 1 1 0 1 1
G 3 1 0 1 1 1 1 1 0 0
C 4 0 1 1 1 1 1 0 1 1
A 5 0 0 0 1 0 1 0 0 0
A 6 0 0 0 1 1 1 0 0 0
T 7 0 0 0 0 1 1 1 1 0
G 8 1 0 0 0 0 1 1 1 0
a) b) c)
Figura 39. Direcciones de alineación representadas en vectores de bits. a) Direcciones verticales usando VP. b) Direcciones horizontales usando HP. c) Direcciones en diagonal usando D1.
Para el caso de las direcciones en diagonal, se puede usar la máscara de bits Eq para las
coincidencias entre caracteres 𝑝𝑖 = 𝑡𝑗, sin embargo, el caso de las diferencias entre
valores en diagonal no existe un vector como tal que las pueda obtener. Por tal motivo se
57
realizó una modificación al algoritmo original para calcular el nuevo vector durante el
cálculo de la distancia de edición.
Tabla 3. Tabla de combinaciones de entrada para obtener el vector D
La Tabla 3 es la extensión de las combinaciones de las entradas del algoritmo mostrado
en el capítulo 3, a la cual se le anexa valores de ejemplo de las 4 casillas de la matriz de
programación dinámica correspondiente a cada combinación de entrada, para una mejor
comprensión. Tomando en cuenta estas 4 casillas se puede ver fácilmente las diferencias
entre los valores en diagonal, para ello se define un nuevo vector D que almacena un 1
cuando la celda C[i,j] es mayor a C[i-1,j-1] y un 0 en caso contrario. Ahora, para calcular
D se utilizan los valores de entrada Eq=0 con los valores de ∆𝑣𝑖𝑛 = −1 y ∆ℎ𝑖𝑛 = −1,
que en vectores de bits son representados como VN y HN, obteniendo así la ecuación
15. Finalmente se combina el vector D con el vector Eq que representa las coincidencias
exactas entre caracteres, obteniendo así un único vector de diagonal al cual se denominó
vector D1 mediante la ecuación 16 simplificada. El resultado del almacenamiento del
nuevo vector es mostrado en la Figura 39c.
N° ∆hin ∆vin Eq D ∆hout ∆vout Vista de las 4 casillas
1 -1 -1 1 0 1 1 1 0 1 1 1 2
2 0 -1 1 0 1 0 0 1 0 1 0 1
3 1 -1 1 0 1 -1
4 -1 0 1 0 0 1 1 0 0 0 0 1
5 0 0 1 0 0 0 1 1 0 0 0 0
6 1 0 1 0 0 -1
7 -1 1 1 0 -1 1 1 0 0 0 0 1
8 0 1 1 0 -1 0 2 1 1 0 1 0
9 1 1 1 0 -1 -1
10 -1 -1 0 0 1 1 1 0 1 1 1 2
11 0 -1 0 0 1 0 0 1 0 1 0 1
12 1 -1 0 0 1 -1
13 -1 0 0 0 0 1 1 0 0 0 0 1
14 0 0 0 0 1 1 1 1 0 1 0 1
15 1 0 0 1 1 0
16 -1 1 0 1 -1 1 1 0 0 0 0 1
17 0 1 0 0 0 1 2 1 1 1 1 1
18 1 1 0 1 0 0
58
𝐷 = 𝑛𝑜𝑡 (𝐸𝑞 𝑜𝑟 𝑉𝑁𝑖𝑛 𝑜𝑟 𝐻𝑁𝑖𝑛) (15)
𝐷1 = 𝐸𝑞 𝑜𝑟 (𝑉𝑁𝑖𝑛 𝑜𝑟 𝐻𝑁𝑖𝑛) (16)
4.3.3.1 El algoritmo de Myers por bloques
Una vez encontrado el texto donde la semilla se alinea a la cadena de referencia, se procede
a realizar la alineación inexacta de ambas cadenas, para ésta operación se utiliza el
algoritmo de Myers explicado en el capítulo 3. Tomando en cuenta que la longitud de las
lecturas cortas es de 70 a 100 nucleótidos y el tamaño de palabra de los procesadores
actuales es de 32 ó 64 bits, es necesario realizar los cálculos de cada vector mediante
bloques. El desarrollo del proyecto se realizó en un procesador de 64 bits, lo cual significa
que usando dos bloques es suficiente para cubrir la longitud de la lectura corta a procesar,
por tal razón, no es necesario ampliar el algoritmo de bloques al algoritmo de bloques de
bandas presentado por (Ukkonen, 1985) debido a que ésta solo tiene ventaja cuando el
número de bloques es mayor. De esta manera se evitan realizar cálculos internos que
puedan tomar más tiempo a la hora de realizar el cálculo de los vectores.
Preprocesamiento
Antes de calcular la distancia de edición primero se realiza el preprocesamiento de la
cadena patrón, el cual consiste en crear la máscara de bits de la cadena, la máscara
almacena los 4 caracteres del alfabeto, pero suponiendo que en la lectura corta aparece un
carácter N (nucleótido ambiguo) se agrega un vector extra de comodín que capture ese
valor y que no lo cuente en la alineación de la lectura. En la Figura 40a se muestra el
resultado de la máscara de bits para los 4 caracteres y el carácter comodín para la cadena
patrón P=“GCGCNATG”, donde el tamaño de la palabra es w=5. Note que el resto de
los bits después del tamaño m del patrón son rellenados con valor 0.
59
A C G T *
G 0 0 1 0 0
C 0 1 0 0 0
G b1 0 0 1 0 0
C 0 1 0 0 0
N 0 0 0 0 0
A 1 0 0 0 0
T 0 0 0 1 0
G b2 0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
VP VN
1 0
1 0
b1 1 0
1 0
1 0
1 0
1 0
b2 1 0
1 0
1 0
a) b)
Figura 40. Preprocesamiento por bloques. a) Máscara de bits. b) Vectores de VP y VN.
Antes de iniciar el cálculo de la distancia de edición se debe inicializar también los 2
vectores de bits que sirven de base VP y VN (Figura 40b), estos vectores son almacenados
por cada bloque y se irán actualizando conforme se vaya realizando el cálculo de la
distancia de edición. Los vectores VP son inicializados con el valor entero -1 para llenar
todos sus bits con 1s y los vectores VN con 0.
Cálculo de la distancia de edición.
El cálculo de la distancia de edición es realizado columna por columna como en el
algoritmo original, donde por cada columna se calculan los bloques (superior e inferior),
los bloques son calculados de arriba hacia abajo, ya que durante el cálculo del bloque
superior es posible que exista una propagación de bits en el vector que se debe continuar
en el bloque inferior. En el algoritmo básico, para obtener los vectores HP y HN de salida
basta con hacer un desplazamiento de bits, donde por el efecto del desplazamiento se
ingresa un 0 en el bit menos significativo. Esto siempre fue válido por que se usaba
únicamente un bloque en la alineación y éstos se encontraban en el límite superior de la
matriz. En cambio, en el algoritmo basado en múltiples bloques, no todos los bloques
comienzan en el límite superior de la matriz y tales bloques tendrán como bloque inicial
el bloque de arriba, por tanto, cuando ocurra una propagación de bits el bloque superior,
60
el bit de acarreo del bloque superior debe quedar en el bit menos significativo del bloque
inferior, de esta manera se logra la propagación de los bits a lo largo de todos los bloques
inferiores para un caso general
Texto
P a t r ó n
b1
b2
Figura 41. Cálculo del bit que corresponde a la posición máxima en cada bloque
Para calcular el valor de distancia de alineación de la matriz, se inicializa primero la
distancia con la longitud m del patrón, luego para obtener el bit que determina si la
distancia se incrementa o decrementa, se utiliza un vector que sirva como máscara para
saber qué bit del bloque hay que tomar, dicha variable toma el valor de 1 en el bit más
significativo del vector cuando se calculan los bloques superiores y para el último bloque
de la columna se calcula el valor de acuerdo a la longitud m de la cadena patrón (Figura
41). Conforme se van calculando los bloques de cada columna, se van almacenando los 3
vectores de dirección (VP, HP y D1) que permitirán realizar el recorrido hacia atrás.
4.3.3.2 La ruta de alineación
El recorrido hacia atrás se realiza utilizando los 3 vectores de bits (VP, HP y D1)
obtenidos durante el cálculo de la distancia de edición. A partir de estos vectores, para
obtener solamente una ruta de alineación se toman en cuenta las siguientes prioridades
respecto a la distancia de edición y los valores de cada vector:
1. Si existen varias distancias de edición mínima se tomará el último de ellos.
2. Las direcciones en diagonal tienen mayor prioridad ya que contienen las
coincidencias exactas.
3. Las direcciones en vertical quedan en segunda preferencia.
4. Las direcciones en horizontal quedan como última opción ya que no es muy
común su aparición en la alineación de lecturas.
BIT_MAX = W
BIT_MAX = W – m%W
61
Al igual que el recorrido con la matriz de programación dinámica, se inicia partiendo de
la columna de la distancia de edición mínima y en el caso de la fila se parte del m-ésimo
bit que corresponde al último bloque, después se realiza el recorrido hacia atrás
moviéndose por las filas de bits y columnas de los vectores. El desplazamiento en filas
requiere el uso de un vector auxiliar de tamaño w que sirva de máscara para indicar en
qué bit del bloque se encuentra el recorrido, en cambio, en las columnas basta con utilizar
un contador que vaya decrementandose.
Bit actual
D1 VP HP
G C C A T A G C G G C C A T A G C G G C C A T A G C G
0 G 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 0 0 0 0 0 1 0
0 C 0 1 1 1 1 1 0 1 0 1 0 0 1 1 1 1 0 1 0 0 1 1 0 0 0 0 1
0 G b1 1 0 1 1 1 1 1 0 1 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 0 0 0
0 C 0 1 1 1 1 1 0 1 0 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 0 0 0
0 A 0 0 0 1 0 1 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0
0 A 0 0 0 1 1 1 0 0 0 1 1 1 1 0 0 0 1 1 0 0 0 0 0 0 1 1 0
0 T 0 0 0 0 1 1 1 1 0 1 1 1 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0
1 G b2 1 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Figura 42. Ruta de alineación usando vectores de bits.
La Figura 42 muestra la ruta de alineación obtenida al realiza el recorrido hacia atrás
utilizando los vectores de bits VP, HP y D1 en bloques. Los desplazamientos de bits o
decremento en la columna se realizan de acuerdo al vector que tenga prioridad. HP
únicamente realiza el decremento en la columna, VP sólo el desplazamiento de bit en la
máscara del vector auxiliar y D1 realiza ambas operaciones, luego, los nuevos valores son
utilizados para la siguiente iteración. El recorrido termina cuando el contador de columna
llega a cero o cuando se procesa el último bit de la máscara.
La ruta de alineación permite determinar la serie de operaciones que transforman la
cadena patrón al texto de referencia, aprovechando el recorrido hacia atrás, es posible
determinar el CIGAR de la alineación (del inglés Compact Idiosyncratic Gapped Alignment Report),
éste es un formato de alineación comprimido por pares (número de operaciones de una
operación y el operador) utilizado para representar los resultados de las alineaciones de
62
secuencias genómicas (Li, Handsaker, A, & al., 2009). El CIGAR consiste en 3
operaciones básicas, las cuales son representadas mediante un carácter de acuerdo a la
operación realizada:
1. M: indica la coincidencia o desapareo (Match o Mismatch) de un carácter del
Patrón respecto al Texto de referencia
2. I: indica la inserción de un carácter en el Patrón lo cual significa la eliminación de
un carácter en el Texto de referencia.
3. D: indica la eliminación de un carácter en el Patrón lo cual significa que existe una
inserción de carácter en el Texto de referencia.
Usando los vectores de bits que permiten obtener la ruta de alineación se puede calcular
fácilmente el CIGAR, las operaciones son obtenidas conforme se van realizando los
desplazamientos en columna o en filas de bits tal como lo muestra la Figura 41. Donde
un desplazamiento en diagonal indica una Match o Mismatch (M), un desplazamiento en
vertical una inserción (I) y un desplazamiento en horizontal una eliminación (D). El
resultado de la ruta de alineación es el formato CIGAR completo en su forma inversa,
para compactarlo primero se revierte la cadena y luego se cuentan los caracteres de cada
operación, donde por cada operación se arma pares del número total más el operador
(Figura 43).
Bit actual
VP HP D1
G C C A T A G C G G C C A T A G C G G C C A T A G C G
0 G 0 1 1 1 1 1 0 1 0 0 1 0 0 0 0 0 1 0 1 1 1 1 1 1 1 1 1
0 C 1 0 0 1 1 1 1 0 1 0 0 1 1 0 0 0 0 1 0 1 1 1 1 1 0 1 0
0 G 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 0 0 0 1 0 1 1 1 1 1 0 1
0 C 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 0 0 0 0 1 1 1 1 1 0 1 0
0 A 1 1 1 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 1 0 1 0 0 0
0 A 1 1 1 1 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 0
0 T 1 1 1 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 1 1 1 0
1 G 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 1 1 1
CIGAR 1 M 1 I 4 M
Figura 43. Obtención del CIGAR a partir de la ruta de alineación.
63
El recorrido hacia atrás termina si ya no se puede desplazar más el bit de la máscara auxiliar
o cuando el contador de columna decrementa hasta llegar a cero. La construcción del
CIGAR para el primer caso termina justo cuando finaliza el recorrido hacia atrás, ya que
la alineación de la lectura queda en el intervalo del texto de referencia y no quedan más
operaciones por realizar (Figura 44a), sin embargo, para el segundo caso la lectura
comienza a alinearse un poco más a la izquierda de la referencia (Figura 44b), lo que
significa que un grupo de caracteres que quedan fuera del intervalo de referencia, por tal
motivo es necesario agregar operaciones de inserción en el CIGAR una vez terminado el
recorrido hacia atrás.
a) b) Figura 44. Codificación del CIGAR de acuerdo a la alineación. a) Alineación en el intervalo de la
referencia. b) Alineación fuera de la referencia.
4.3.4 Implementación
El desarrollo de cada módulo fue programado en el lenguaje de programación C bajo el
sistema operativo Linux. En lo que sigue no se pretende una descripción detallada de la
programación, únicamente se describirá de manera general la funcionalidad de cada uno
de los módulos que conforma el alineador.
4.3.4.1 Los archivos de entrada
Los archivos que almacenan los índices de FM y la cadena de referencia compactada en 2
bits fueron generados por el alineador de lecturas BWA, por tal razón se tomaron las
funciones de apertura de estos archivos para utilizarlos en el desarrollo del alineador
64
realizando ligeras modificaciones de acuerdo a los datos que se requerían para la
funcionalidad del programa. Para la apertura del archivo de las lecturas cortas se utilizó la
librería kseq, éste es un archivo de cabecera que permite analizar el formato
FASTA/FASTQ, el cual es compatible para cualquier versión de FASTQ, dicha librería
devuelve como resultado la información almacenada de cada lectura en una estructura de
datos, la cual se adaptó a una estructura compatible al analizador desarrollado.
4.3.4.2 La fase de siembra
La fase de siembra se encarga de obtener las semillas a partir de la lectura corta y después
la subcadena de la referencia en la región de siembra donde la semilla se ha alineado, el
desarrollo de la etapa de siembra se muestra en la Figura 45, la cual es desarrollada
mediante 6 módulos principales.
Figura 45. Módulos que conforma la etapa de siembra
Etapa de
siembra
Obtener
semilla
Calcular valor
de Arreglo de
Sufijos
Calcular
región de
siembra
Calcular
Occ
Calcular la
TBW inversa
Obtener texto
de referencia
Calcular
Occ
65
Los pasos que sigue el programa son los siguientes:
Obtener semilla: realiza la búsqueda hacia atrás utilizando los índices de FM,
recorriendo cada carácter de la lectura corta hasta encontrar un error de intervalo
o un carácter N (nucleótido ambiguo), retorna la información de inicio, longitud
y los valores del intervalo k y l de la semilla.
Calcular Occ: obtiene el valor de la matriz de ocurrencia del carácter y el intervalo
k y l que solicita la función que realiza la búsqueda hacia atrás.
Calcular valor de AS: encuentra el valor del arreglo de sufijos utilizando los
valores del intervalo k y l como índice. Este valor es la posición real donde la
semilla comienza a alinearse en la cadena de referencia.
Calcular la TBW inversa: encuentra el carácter anterior de la transformada a
partir del índice del carácter actual, retorna el índice del nuevo carácter
encontrado. Éste nuevo índice permite encontrar el nuevo valor del arreglo de
sufijos.
Calcular región de referencia: obtiene todas las (k - l + 1) regiones de referencia
para después pasar cada texto de referencia a la etapa de extensión.
Obtener texto de referencia: realiza los cálculos de inicio y fin de la subcadena
de la referencia a partir del valor del Arreglo de sufijos encontrado previamente,
la posición de inicio de la semilla en la lectura corta, el tamaño de la lectura corta
y el error de entrada utilizado como margen. Retorna el texto de referencia que
será usado para la fase de extensión.
4.3.4.3 La fase de extensión
La fase de extensión se encarga de realizar la alineación inexacta entre la lectura corta y el
texto de referencia previamente calculada en la etapa de siembra, la alineación se realiza a
partir del cálculo de la distancia de edición para determinar la similitud entre ambas, dicho
cálculo es realizado utilizando el algoritmo de Myers. Posteriormente se realiza el
recorrido hacia atrás de los vectores de bits para determinar la ruta de alineación. El
66
desarrollo de éste módulo consiste en 1 función para el preprocesamiento, 2 para el
cálculo de la distancia de edición y 2 para calcular la ruta de alineación (Figura 46).
Preprocesamiento: se encargar de reservar la memoria necesaria e inicializar: la
máscara de bits por bloques a partir de la lectura corta, los bloques de base (VP=-
1 y VN=0) y los vectores de dirección (VP, HP y D1).
Cálculo de la distancia de edición: realiza el cálculo de edición entra la lectura
corta y el texto de referencia utilizando los bloques de bits de cada columna.
Retorna la distancia mínima encontrada, la matriz de rutas rellenada y la columna
de la distancia donde se encontró la distancia de edición.
Calcular bloque: recibe como entrada los vectores VP, VN, Eq y el bit de acarreo
del bloque anterior. Realiza el cálculo del siguiente bloque al mismo tiempo que
calcula y almacena los vectores de direcciones. Retorna los vectores de direcciones
(VP, HP D1), VP y VN de salida y el bit de acarreo de éste nuevo bloque.
Ruta de alineación: Realiza el recorrido hacia atrás para obtener la ruta de
alineación almacenando el CIGAR invertido. Retorna la posición inicio de la
alineación respecto al texto de referencia, el CIGAR y el número de operaciones
total de la alineación.
Figura 46. Módulos de la etapa de extensión.
Etapa de
extensión
Preprocesamiento Cálculo de la distancia
de edición (Myers)
Obtener ruta de
alineación
Calcular bloque Revertir
CIGAR
67
Revertir CIGAR: recibe como entrada el CIGAR invertido y lo revierte.
4.3.5 Integración
Una vez desarrollada la fase de siembra y extensión, se pueden integrar ambas partes en
una sola para realizar la alineación de las lecturas cortas. La Figura 47 muestra todas las
funciones que engloban el alineador de lecturas desarrollado, en la cual se realiza la
integración de las dos fases de la alineación, además de las funciones de apertura y
generación de la salida en formato SAM.
El alineador inicia con la apertura de los archivos de lecturas cortas, los índices de FM y
la cadena de referencia. Las lecturas se leen una por una y se realiza la alineación mediante
las dos etapas: siembra y extensión. La etapa de siembra inicia con la obtención de la
semilla, donde se utilizan los índices de FM para realizar la búsqueda hacia atrás, en tal
proceso es necesario obtener el valor de la matriz de ocurrencia que corresponde al
intervalo buscado, los índices de FM incluyen la matriz de ocurrencia reducida, por tal
razón se requiere un módulo que recupere el valor de la ocurrencia a partir de la TBW. El
resultado de la búsqueda de semilla es el intervalo k y l que representan los índices para el
arreglo de sufijos, para calcularlos se toma cada valor desde k hasta l para encontrar todas
las posiciones de inicio donde la semilla se ha alineado, el cálculo del valor del arreglo de
sufijos requiere realizar la inversa de la TBW que obtiene el carácter anterior al índice k+i,
mismo que hace uso nuevamente del módulo que calcula el valor de la matriz de
ocurrencia. Teniendo la posición de inicio se pasa al cálculo de la región de siembra, donde
por cada región de referencia se obtiene una subcadena de la referencia donde la semilla
se alineó, realizando cálculos para obtener los intervalos de inicio y fin. Justo en el cálculo
de la región, una vez obtenida la subcadena de referencia comienza la fase de extensión.
Por cada región encontrada donde la semilla se alineó, los resultados devueltos por la
extensión de la semilla son comparados hasta obtener la alineación con el menor número
de errores encontrados.
68
Figura 47. Integración de todos los módulos de siembra y extensión del alineador.
Alineador
Lectura de
archivos
Etapa de
siembra
Obtener semilla Calcular valor de
Arreglo de Sufijos
Calcular región
de siembra
Calcular
Occ
Calcular la TBW
inversa Obtener texto de
referencia
Calcular
Occ Etapa de
extensión
Preprocesamiento Cálculo de la
distancia de
edición (Myers)
Obtener ruta de
alineación
Calcular bloque Revertir
CIGAR
Generar formato
SAM
69
La fase de extensión recibe como parámetro la lectura corta y el texto de referencia con
sus respectivas longitudes, primeramente se realiza el preprocesamiento que consiste en
el cálculo de la máscara de bits de la lectura corta para los 4 nucleótidos más un carácter
comodín, de igual manera se inicializa los valores de VP=-1 y VN=0 para los bloques de
base y también se realiza la reserva de memoria para los vectores de dirección. Luego se
realiza el cálculo de la distancia de edición mediante bloques, cada bloque es calculado de
manera independiente a partir de los vectores Eq, VP y VN, al mismo tiempo se van
calculando y almacenando los vectores de dirección. El cálculo de la distancia de edición
devuelve la distancia menor, la columna de ésta distancia y los vectores de dirección,
mismos que son utilizados para obtener la ruta de alineación, donde realiza el recorrido
de los vectores de bits partiendo la columna de la distancia mínima, almacenando las
operaciones realizadas en formato CIGAR. La ruta de alineación devuelve el CIGAR
revertida, la posición de inicio de alineación en el texto de referencia y el número de
operaciones realizadas en la alineación. Finalmente, una vez que termina la alineación de
las lecturas, se construye el archivo de salida SAM (Li, Handsaker, A, & al., 2009), éste
almacena la información de la alineación de las lecturas cortas.
70
71
Capítulo 5
5 RESULTADOS
En este capítulo se presentan los principales resultados del programa desarrollado. La
primera sección describe los requerimientos de hardware y software necesarios para la
ejecución del programa. La segunda sección corresponde a la verificación funcional del
alineador, para ello se muestra detalladamente la ejecución del programa alineando dos
lecturas cortas, mostrando la salida paso a paso de la manera en que se realizan las
operaciones de siembra y extensión. La tercera sección corresponde a la caracterización
del programa, realizando múltiples pruebas, en las cuales diferentes conjuntos de lecturas
generadas artificialmente mediante el programa Wgsim se alinean a diferentes
cromosomas humanos, verificando el número de alineaciones correctas e incorrectas.
Finalmente se comparan los resultados obtenidos con otros alineadores en la literatura.
5.1 Requerimientos en hardware y software
Los requisitos mínimos para la ejecución apropiada del programa de alineación son los
siguientes:
Hardware
Procesador Pentium o más reciente.
4 GB de memoria RAM.
72
82.1 KB de espacio libre en disco para el programa fuente.
3 GB de espacio libre en disco para los archivos de pruebas.
Software
Sistema operativo Linux de 32 o 64 bits
Compilador gcc 6.3.120161221
Las pruebas realizadas al alineador para presentar los resultados se ejecutaron en una
computadora de escritorio con un procesador Intel Core i5 4460 de cuarta generación,
con 3.2 GHz, 8GB de memoria RAM y el sistema operativo Ubuntu 14.04 de 64 bits. Y
sólo para verificar que el programa también es funcional en procesadores de 32 bits, se
realizó una prueba en otra computadora de escritorio con un procesador Intel Core 2
Quan inside, con 2.4 GHz, 3 GB de memoria RAM y el sistema operativo Fedora 25 de
32 bits.
5.2 Verificación funcional del programa
Para validar y mostrar la correcta funcionalidad del alineador se realizaron diferentes
pruebas, inicialmente el programa fue ejecutado de una manera básica, en la cual se alinean
dos lecturas cortas de 70 nucleótidos a una referencia de 1000 nucleótidos. En la Figura
48 se muestra el contenido del archivo en formato FASTA que almacena la cadena de
referencia usada en este ejemplo. Las lecturas cortas son generadas artificialmente
mediante el programa Wgsim a partir del archivo de la cadena de referencia, en el nombre
de cada lectura aparece la posición donde fue tomada en la referencia, en la Figura 49 se
muestra el contenido del archivo en formato FASTQ que contiene la información de las
dos lecturas cortas.
73
>1000b
TAAATAGCATTGAGTTATCAGTACTTTCATGTCTTGATACATTTCTTCTTGAAAATGTTCATGCTTGCTGATTTGTCTGTTTGTTGAGAGGAGAA
TGTTCAGAATTTTATATCTTCAACATCTTTTTCTTCATTAATAAGATACTGAGATTTTATAACTCTTGTCATTTTGGTCACTTATATTTTCATAT
GGAAATATCGTATAATCCAGGGTTTCCAATATATTTGTGTAAAATTAAGAAAATTATCTTATCTAATAACTTGATCAATATCTGTGATTATATTT
TCATTGCCTTCCAATTTTAATATTTGTTCTCTATTCCTTCTTAATCTGGATTGAAGTTCTGATTAATTATTTTAATGTTGCAAATTGTTTTCACT
TTTTCCATAAAATGAGTTCTAGAGTTTATTTCTTTACTGCATCATTCTATTTTCAAGTCATGAACTTCTGCTTCAACTAAAAAAAAAAAACTCAC
CGTTTGTATGAAATTGTTGTGTTCatattttattttttatttactgtataattcagtattgaatatataatattataaaatatgtaataaaaGGA
TAAAAAATAAGATACAAAAAGTAAGGGGTGTGCGTTTGGAAAATTATACTTGCTGATATGGTGAAATAACTCTGACCAAACTAACCTTCCAGCAA
TAAAAACAAATTTGGAAAACTGGAAAAAATATACATGGCAACATGTTAGGTCATCTTTGTCTGCCTTCAAACAACTATAAATATTGTTCTACCCA
AACAACTATAAATTTTGTAATACCTAGAACAATATAAATATTGTTCTACATTGTAAATTGTTCTACAATTTACAATGGTGTAAACTGTTATACAC
CATTTATTTGAGTAAATTTTGAAAATATCTATTCTTCATTTTTGCTGTTTCTCGTGTGGTATATATTTCTCAGATAAAAGATATTTTCCCTTTTA
TCTTTCCCTAAGCTCACACTACATATATTGCtaacgtacggtccctacgt
Figura 48. Archivo de referencia de 1000 nucleótidos en formato FASTA.
@1000b_29_98_0:0:0_0:0:0_0/1
ATGTCTTGATACATTTCTTCTTGAAAATGTTCATGCTTGCTGATTTGTCTGTTTGTTGAGAGGAGAATGT
+
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
@1000b_723_792_0:2:0_0:2:0_2/1
TGTCTGCCTTCAAACAACTATAAATATTGTTCTACCCAAACAAGTATAAATTTTGTAATACCTAGGACAA
+
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
Figura 49. Archivo de lecturas cortas de 70 nucleótidos en formato FASTQ.
La salida de ejecución se muestra en la figura 50, donde se realiza primeramente la lectura
de cada uno de los archivos de entrada, luego se da comienzo a la alineación permitiendo
un número de 3 errores por lectura, en este caso particular, la longitud mínima para una
semilla es de 17. En el procesamiento de la primera lectura, la semilla obtenida es de la
misma longitud que la lectura, por tal motivo se obtiene el valor del arreglo de sufijos que
determina la posición donde la semilla comienza a alinearse en la referencia y se presenta
inmediatamente el resultado de la alineación. La segunda lectura procesada encuentra dos
semillas en la etapa de siembra, la primera no llega a alcanzar la longitud mínima requerida,
descartándose inmediatamente, la segunda posee una longitud de 66, por tal razón se
continúa el proceso de alineación, obteniendo el valor del arreglo de sufijos y calculando
el segmento de referencia que usará en la etapa de extensión, donde se puede observar
claramente la alineación de la semilla en ambas cadenas. La etapa de extensión comienza
realizando el cálculo de la distancia de edición, obteniendo una distancia mínima de 1 que
es válido de acuerdo al número de errores permitidos en la alineación. Luego, mediante
el proceso de obtención de la ruta de alineación se encuentra la posición donde comienza
74
la alineación de la lectura en el segmento de referencia, además se construye el CIGAR y
se reporta el número de operaciones de ésta. Finalmente se imprimen los resultados de la
alineación de la segunda lectura, la más importante es la posición donde comienza la
alineación, que en efecto concuerda con el valor donde se tomó la lectura en la referencia
mediante el programa Wgsim, además, se imprime la alineación de ambas cadenas de
acuerdo a las operaciones y longitud del CIGAR.
[ubuntu@localhost Alineador]$ ./alineador indice lecturas.fq > alineacion.sam
==================================================
ALINEADOR DE LECTURAS CORTAS DE ADN
==================================================
--> Leyendo lecturas cortas...
--> Leyendo índices de FM...
--> Leyendo referencia comprimida...
--> Alinear 2 lecturas cortas permitiendo 3 errores en alineación....
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
PROCESANDO LECTURA 1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nombre : 1000b_29_98_0:0:0_0:0:0_0/1
Secuencia: ATGTCTTGATACATTTCTTCTTGAAAATGTTCATGCTTGCTGATTTGTCTGTTTGTTGAGAGGAGAATGT
ETAPA DE SIEMBRA
-----------------
1.- Obtener semilla...
Semilla: ATGTCTTGATACATTTCTTCTTGAAAATGTTCATGCTTGCTGATTTGTCTGTTTGTTGAGAGGAGAATGT
longitud = 70
inicio en lectura = 1
k = 270
l = 270
2.- Obtener Arreglo de Sufijos...
Arreglo de Sufijos = [ 28 ]
RESULTADO: ALINEACIÓN EXACTA !!
--------------------------------
Inicio de alineación en Referencia: 29
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
PROCESANDO LECTURA 2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nombre : 1000b_458_527_0:1:0_0:1:0_2/1
Secuencia: TAAAAAAAAAAAACTCACCGTTTGTATGAAATTGTTGTGTTCATATTTTATTTTTTATTTACTGTATGAT
ETAPA DE SIEMBRA
-----------------
1.- Obtener semilla...
Semilla: TGAT
longitud = 4
inicio en lectura = 67
k = 766
l = 771
ETAPA DE SIEMBRA
-----------------
1.- Obtener semilla...
Semilla: TAAAAAAAAAAAACTCACCGTTTGTATGAAATTGTTGTGTTCATATTTTATTTTTTATTTACTGTA
longitud = 66
inicio en lectura = 0
k = 583
l = 583
2.- Obtener Arreglo de Sufijos...
Arreglo de Sufijos = [ 457 ]
75
3.- Calcular Región 457...
Segmento Ref: TCAACTAAAAAAAAAAAACTCACCGTTTGTATGAAATTGTTGTGTTCATATTTTATTTTTTATTTACTGTATAATTCA
Semilla: TAAAAAAAAAAAACTCACCGTTTGTATGAAATTGTTGTGTTCATATTTTATTTTTTATTTACTGTA
Lectura: TAAAAAAAAAAAACTCACCGTTTGTATGAAATTGTTGTGTTCATATTTTATTTTTTATTTACTGTATGAT
ETAPA DE EXTENSIÓN en Región 457
--------------------------------
5.- Calcular distancia de edición
Distancia de edición: 1
Columna de distancia mínima: 74
6.- Obtener ruta de alineación...
Inicio de alineación en segmento: 5
Número de operaciones en CIGAR: 70
CIGAR: 70M
RESULTADO: ALINECIÓN INEXACTA !!
---------------------------------
Distancia de edición: 1
Inicio de alineación en Referencia: 458
CIGAR: 70M
Referencia: TAAAAAAAAAAAACTCACCGTTTGTATGAAATTGTTGTGTTCATATTTTATTTTTTATTTACTGTATAAT
Lectura: TAAAAAAAAAAAACTCACCGTTTGTATGAAATTGTTGTGTTCATATTTTATTTTTTATTTACTGTATGAT
Figura 50. Verificación funcional del alineador mediante la prueba de alineación de dos lecturas de 70 nucleótidos.
La versión anterior es solamente demostrativa por lo que se modificó para evitar los
tiempos de impresión de cada uno de los pasos realizados en la alineación, de esta manera
se tiene una estimación más cercana a los tiempos de procesamiento que se presentarán
en la siguiente sección. A continuación se muestra la salida de la alineación de 50 lecturas
de 100 nucleótidos alineados al cromosoma 21 (Figura 51). En los resultados se puede
apreciar que algunas lecturas no fueron alineadas, por 3 posibles razones: la primera es
que no se haya encontrado ninguna semilla de longitud mayor o igual a la longitud mínima
especificada, la segunda es que se haya encontrado una semilla que no se encuentra dentro
del margen de referencia durante el cálculo de la región de siembra, y la tercera es que
durante la fase de extensión, la distancia encontrada sea mucho mayor al número de
errores permitidos en la alineación de la lectura por tanto ni siquiera es requerido la
búsqueda de la ruta de alineación.
[ubuntu@localhost Alineador]$ ./alineador indice lecturas_50.fq > alineacion.sam
==================================================
ALINEADOR DE LECTURAS CORTAS DE ADN
==================================================
--> Leyendo lecturas cortas....
--> Leyendo índices de FM....
--> Leyendo referencia comprimida....
--> Alinear 50 lecturas cortas permitiendo 3 errores en alineación....
76
L1: chr21_18370559_18370982_0:0:0_0:0:0_0/1 ALINECIÓN EXACTA posición: 77888809
L2: chr21_25379435_25380009_0:0:0_0:0:0_1/1 ALINECIÓN EXACTA posición: 25379435
L3: chr21_39381193_39381609_0:0:0_0:0:1_2/1 LECTURA NO ALINEADA
L4: chr21_46527998_46528559_0:0:0_0:0:0_3/1 ALINECIÓN EXACTA posición: 46527998
L5: chr21_41051244_41051805_0:0:0_0:0:0_4/1 ALINECIÓN EXACTA posición: 41051244
L6: chr21_45134306_45134851_0:0:0_0:0:0_5/1 ALINECIÓN EXACTA posición: 45134306
L7: chr21_39144537_39144938_0:0:0_0:0:0_6/1 ALINECIÓN EXACTA posición: 39144537
L8: chr21_17947094_17947572_0:1:0_0:1:0_7/1 LECTURA NO ALINEADA
L9: chr21_32257648_32258158_0:0:0_0:0:0_8/1 ALINECIÓN EXACTA posición: 32257648
L10: chr21_45857019_45857540_0:2:0_0:0:0_9/1 ALINECIÓN INEXACTA posición: 45857019
L11: chr21_23199892_23200405_0:0:0_0:2:0_a/1 LECTURA NO ALINEADA
L12: chr21_26084678_26085245_0:0:0_0:0:0_b/1 ALINECIÓN EXACTA posición: 70174546
L13: chr21_41380515_41381024_0:0:0_0:0:0_c/1 ALINECIÓN EXACTA posición: 41380515
L14: chr21_47491844_47492263_0:0:0_0:1:0_d/1 ALINECIÓN EXACTA posición: 47491844
L15: chr21_29428777_29429339_0:0:0_0:0:0_e/1 ALINECIÓN EXACTA posición: 29428777
L16: chr21_41731439_41731971_0:0:0_0:0:0_f/1 ALINECIÓN EXACTA posición: 54527820
L17: chr21_32897755_32898280_0:1:0_0:0:0_10/1 ALINECIÓN INEXACTA posición: 32897755
L18: chr21_26374820_26375347_0:0:0_0:0:0_11/1 ALINECIÓN EXACTA posición: 26374820
L19: chr21_32093586_32094075_0:0:0_0:0:0_12/1 ALINECIÓN EXACTA posición: 32093586
L20: chr21_19440336_19440814_0:0:0_0:0:0_13/1 ALINECIÓN EXACTA posición: 19440336
L21: chr21_39910360_39910949_0:0:0_0:0:0_14/1 ALINECIÓN EXACTA posición: 39910360
L22: chr21_21670931_21671376_0:2:0_0:0:0_15/1 ALINECIÓN INEXACTA posición: 21670931
L23: chr21_28665980_28666432_0:0:0_0:2:0_16/1 LECTURA NO ALINEADA
L24: chr21_45419734_45420257_0:0:0_0:0:0_17/1 ALINECIÓN EXACTA posición: 45419734
L25: chr21_37318316_37318777_0:1:0_0:0:0_18/1 ALINECIÓN INEXACTA posición: 37318316
L26: chr21_41257876_41258405_0:0:0_0:1:0_19/1 LECTURA NO ALINEADA
L27: chr21_32810237_32810673_0:0:0_0:0:1_1a/1 LECTURA NO ALINEADA
L28: chr21_20046095_20046606_0:1:1_0:0:0_1b/1 LECTURA NO ALINEADA
L29: chr21_43549151_43549617_0:2:0_0:0:0_1c/1 ALINECIÓN INEXACTA posición: 43549151
L30: chr21_23782477_23782991_0:0:0_0:0:0_1d/1 ALINECIÓN EXACTA posición: 72476800
L31: chr21_29242793_29243367_0:0:0_0:0:0_1e/1 ALINECIÓN EXACTA posición: 67016424
L32: chr21_31546309_31546755_0:1:0_0:0:0_1f/1 ALINECIÓN INEXACTA posición: 31546309
L33: chr21_40687796_40688328_0:0:1_0:0:0_20/1 ALINECIÓN INEXACTA posición: 40687796
L34: chr21_37196435_37196936_0:1:0_0:0:0_21/1 ALINECIÓN INEXACTA posición: 37196435
L35: chr21_45439290_45439771_0:0:0_0:0:0_22/1 ALINECIÓN EXACTA posición: 50820020
L36: chr21_15984150_15984693_0:0:0_0:0:0_23/1 ALINECIÓN EXACTA posición: 80275098
L37: chr21_38280654_38281105_0:0:0_0:1:0_24/1 LECTURA NO ALINEADA
L38: chr21_43058944_43059521_0:0:0_0:0:0_25/1 ALINECIÓN EXACTA posición: 43058944
L39: chr21_14932007_14932525_0:0:0_0:0:0_26/1 ALINECIÓN EXACTA posición: 81327266
L40: chr21_21970466_21971040_0:0:0_0:0:0_27/1 ALINECIÓN EXACTA posición: 21970466
L41: chr21_39458637_39459064_0:0:0_0:1:0_28/1 LECTURA NO ALINEADA
L42: chr21_44880078_44880586_0:0:0_0:0:0_29/1 ALINECIÓN EXACTA posición: 51379205
L43: chr21_15715890_15716305_0:1:0_0:0:0_2a/1 ALINECIÓN INEXACTA posición: 15715890
L44: chr21_47863789_47864395_0:0:0_0:0:0_2b/1 ALINECIÓN EXACTA posición: 48395396
L45: chr21_44911556_44912078_0:0:0_0:2:0_2c/1 LECTURA NO ALINEADA
L46: chr21_39407888_39408383_0:0:0_0:0:0_2d/1 ALINECIÓN EXACTA posición: 56851408
L47: chr21_45329367_45329839_0:0:0_0:2:0_2e/1 LECTURA NO ALINEADA
L48: chr21_33581478_33581887_0:0:0_0:0:0_2f/1 ALINECIÓN EXACTA posición: 62677904
L49: chr21_35020414_35020893_0:0:0_0:0:0_30/1 ALINECIÓN EXACTA posición: 35020414
L50: chr21_38641028_38641516_0:0:0_0:1:0_31/1 LECTURA NO ALINEADA
Tiempo: 0.0058 sec
Alineaciones exactas: 29
Alineaciones inexactas: 9
Lecturas no alineadas: 12
Figura 51. Alineación de 50 lecturas de longitud 100 al cromosoma 21.
5.3 Caracterización del alineador
Posteriormente el programa fue probado alineando diferentes conjuntos de lecturas
cortas a diversos cromosomas del genoma humano, todas las lecturas fueron extraídas
utilizando el programa Gsim. Este programa permite simular diversos parámetros como
77
el número de lecturas cortas a generar, la longitud de las lecturas, el porcentaje de
mutación, el porcentaje de inserciones y eliminaciones, errores de secuenciación, entre
otros. Además, las lecturas generadas incluyen información respecto a la posición donde
fueron extraídas, lo cual permite verificar si las alineaciones realizadas fueron correctas.
Los parámetros utilizados para generar las lecturas se describen en la Tabla 4, donde el
porcentaje de mutación utilizado para las lecturas representa el límite en la variación del
genoma humano (Tishkoff & Kidd, 2004), de igual manera los porcentajes para indels y
extensión de indels (Mills, y otros, 2006). El porcentaje de error de secuenciación utilizado
es de 0.1%, valor típico en las máquinas secuenciadoras actuales (Fox, Reid-Bayliss,
Emond, & Loeb, 2015).
Tabla 4. Parámetros en Wgsim para generar las lecturas cortas de prueba
PARÁMETROS VALOR DESCRIPCIÓN
-N 100000 Número de lecturas cortas a generar
-1 64, 100 y 128 Longitud de las lecturas cortas
-r 0.4% Porcentaje de mutación
-R 25% Porcentaje de indels en las mutaciones
-X 70% Porcentaje de indels extendidas
-e 0.1% Porcentaje de error en la secuenciación
En la Tabla 5 se presentan los resultados al alinear conjuntos de 1 millón de lecturas cortas
entre 64, 100 y 128 nucleótidos a los cromosomas 19, 20, 21 y 22, todas con un número
máximo de 3 errores por lectura. El tiempo de procesamiento medido es de la alineación
de toda las lecturas, desde la búsqueda de la semilla hasta le generación del resultado en
formato SAM. Note que los resultados arrojan un gran número de alineaciones exactas,
esto es porque el 99.6% del ADN de los humanos es idéntica y sólo un 0.4% representan
las variaciones genéticas que distinguen uno del otro, éste dato es respecto al genoma
completo, pero es proporcional por cada cromosoma realizado en esta prueba.
78
Tabla 5. Pruebas de alineación de lecturas de diferentes longitudes a 4 cromosomas humanos.
Cromosomas Longitud Parámetros Pruebas de 1 millon
64 100 128
Chr21 48,129,895
Tiempo de alineación 87.6102 sec 111.4791 seg. 140.3348 seg.
Alineaciones exactas 792,243 694,295 625,945
Alineaciones inexactas 194,315 282,054 341,095
Lecturas no alineadas 13,442 23,651 32,960
Chr22 51,304,566
Tiempo de alineación 106.4055 seg. 113.1012 seg. 137.4106 seg.
Alineaciones exactas 791,210 692,092 625,501
Alineaciones inexactas 194,744 284,317 341,728
Lecturas no alineadas 14,046 23,591 32,771
Chr19 59,128,983
Tiempo de alineación 171.0945 seg. 141.8416 seg. 145.6519 seg.
Alineaciones exactas 791,111 693,280 626,486
Alineaciones inexactas 194,006 282,345 340,911
Lecturas no alineadas 14,883 24,375 32,603
Chr20 63,025,520
Tiempo de alineación 107.9522 seg. 120.3179 seg. 143.0820 seg.
Alineaciones exactas 791,214 694,703 626,984
Alineaciones inexactas 194,865 281,606 340,077
Lecturas no alineadas 13,921 23,691 32,939
De la tabla anterior, se tomaron las alineaciones exactas e inexactas y se verificaron los
porcentajes de alineaciones correctas e incorrectas con ayuda de las regiones
proporcionadas por Wgsim. Los porcentajes de éxito de alineación se muestran en la
Tabla 6 para cada alineación realizada. Donde se observa un buen porcentaje de aciertos
en la alineación, además, cabe resaltar que un pequeño porcentaje de las alineaciones
exactas obtenidas fueron en regiones múltiples, de las cuales sólo se tomó una de ellas y
en consecuencia pudo provocar una alineación incorrecta al no coincidir la posición
obtenida por el alineador con la posición que entrega Wgsim. En el caso de las lecturas
alineadas de forma inexacta, se consideraron correctas las que estuvieran entre ±10
nucleótidos, ya que es posible que por las inserciones o eliminaciones se halla obtenido
una posición desplazada a la posición real donde se tomó la lectura corta.
Tabla 6. Porcentajes de alineaciones correctas e incorrectas.
Cromosomas Parámetros Pruebas
64 100 128
Chr21
Total de alineaciones 986,558 976,349 967,040
Alineaciones correctas 98.94% 99.35% 99.38%
Alineaciones incorrectas 1.06% 0.65% 0.62%
Chr22
Total de alineaciones 985,954 976,409 967,229
Alineaciones correctas 97.01% 97.81% 98.01%
Alineaciones incorrectas 2.99% 2.19% 1.99%
79
Chr19
Total de alineaciones 985,117 975,625 967,397
Alineaciones correctas 97.67% 98.71% 98.88%
Alineaciones incorrectas 2.33% 1.29% 1.12%
Chr20
Total de alineaciones 986,079 976,309 967,061
Alineaciones correctas 98.66% 99.15 99.21%
Alineaciones incorrectas 1.34% 0.85% 0.79%
5.4 Comparación con otros alineadores
Finalmente se realizó una comparación de los tiempos de ejecución del alineador con los
tiempos de los algoritmos de alineación del programa BWA, éste alineador consta de tres
programas de alineación, donde dos de ellos utilizan la técnica de siembra y extiende:
BWA-SW y BWA-MEM. Ambos programas utilizan los índices de FM para la etapa de
siembra, el algoritmo de Smith-Waterman para la etapa de extensión en el caso de BWA-
SW y una combinación de alineación local y global para BWA-MEM. La siguiente
comparación no pretende definir si el alineador desarrollado es más rápido que los de
BWA, ya que tiene gran diferencia respecto a los parámetros de la alineación, las técnicas
para la obtención de semillas, la técnica de extensión utilizada, además cabe destacar que
dichos alineadores son más precisos. La comparación únicamente es para verificar que el
alineador desarrollado es funcional al igual que estas herramientas y en los resultados se
puede notar que los tiempos de ejecución del alineador no se encuentran tan alejados de
éstos programas. La Tabla 7 muestra los resultados de las alineaciones con estos
programas, dichas pruebas fueron realizadas con 1 millón de lecturas y la alineación ue
respecto al cromosoma 21.
Tabla 7. Pruebas de ejecución del alineador comparado con los tiempos de los algoritmos de BWA.
PARÁMETROS PRUEBAS
64 nucleótidos 100 nucleótidos 128 nucleótidos
Tiempo de alineación en
BWA-SW
178.908 seg. 309.936 seg. 138.7675 seg.
80
Tiempo de alineación en
BWA-MEM
55.220 seg. 73.820 seg. 93.092 seg.
Tiempo en Alineador
desarrollado
87.6102 sec 111.4791 seg. 140.3348 seg.
La salida de las alineaciones en formato SAM del alineador desarrollado fueron
comparadas con las salidas de los alineadores de BWA, en tales resultados, los tres tipos
de salidas de la alineación del alineador concuerdan con las salidas del programa BWA-
SW, variando únicamente en el formato CIGAR de la alineación de las secuencias. En
cambio la salida de BWA-MEM tiene similitud únicamente en las alineaciones exactas de
las cadenas, ya que BWA- es más preciso y determina con gran exactitud las alineaciones
inexactas.
81
Capítulo 6
6 CONCLUSIONES Y TRABAJOS A FUTURO
En este trabajó se realizó el diseño y codificación de un alineador genérico que
implementa la estrategia siembra y extiende a base de dos algoritmos principales. En la
fase de siembra se utilizaron los índices de FM y el algoritmo del mismo que permite
realizar búsquedas exactas de cadenas de forma rápida. Para la fase de extensión se
implementó el algoritmo de programación dinámica de Myers para el cálculo de la
distancia de edición entre dos cadenas. El alineador desarrollado es capaz de utilizar las
dos fases para realizar la alineación de lecturas cortas de ADN a cadenas de referencia de
más de 48 millones de nucleótidos.
Para realizar la fase de siembra, una de las primeras tareas fue analizar la Transformada
de Burrows-Wheeler de la cual se derivan los índices de FM. Después se revisó
detalladamente al algoritmo que utiliza los índices de FM para realizar búsquedas exactas
de cadenas. Una vez entendida la funcionalidad del algoritmo y el conjunto de estructuras
de datos que conforma los índices de FM se utilizó el programa BWA para generar dichos
índices, tal programa almacena los índices de forma binaria para reducir el espacio de
almacenamiento, por tal razón se hizo un pequeño análisis del archivo para entender el
formato del contenido y así poder recuperar los datos necesarios, luego se diseñaron las
estructuras necesarias para almacenar los índices leídos, así como el diseño para obtener
82
semillas a partir del algoritmo de búsqueda exacta. Para la fase de extensión se analizó
primeramente el algoritmo de programación dinámica para el cálculo de la distancia de
Levenshtein, luego el algoritmo de Myers, que utiliza los vectores de bits y operaciones
binarias para realizar el mismo cálculo pero en menos tiempo. Una vez comprendido el
algoritmo, se buscó la manera de obtener la ruta de alineación de las cadenas utilizando
de igual manera vectores de bits, se modificó ligeramente el algoritmo original para poder
obtener todas las rutas de alineación posibles, luego se diseñó un algoritmo que realizara
el recorrido hacia atrás y de esta manera obtener las operaciones en formato CIGAR.
Teniendo los diseños de los módulos de cada una de las dos fases, se realizó la codificación
de cada uno de ellos y sus pruebas de funcionalidad por aparte, luego ambas fases fueron
integradas para completar el alineador. El desarrollo de dicho alineador fue realizado bajo
el sistema Operativo Linux usando el lenguaje de Programación C. Para las pruebas de
alineación se generaron las lecturas cortas utilizando el programa Wgsim con 3 longitudes
de lecturas cortas diferentes (64,100 y 128) a cromosomas de referencia con más de 48
millones de nucleótidos. Los resultados indican que es factible combinar dichos
algoritmos para realizar alineaciones de lecturas cortas de ADN teniendo porcentajes de
error de alineación por debajo del 3%. Además la velocidad del alineador puede mejorarse
si se paraleliza con múltiples hilos. Respecto a la fase de extensión, el desarrollo fue basado
en bloques de longitud w, siendo uno de los limitantes de desarrollo en CPU, sin embargo,
la fase de extensión puede ser implementado en Hardware para no tener limitaciones en
tamaños de palabra, de esta manera las alineaciones inexactas podrían realizarse en un
solo bloque y con la posibilidad de aumentar más la longitud de las lecturas cortas a
alinear.
Como trabajo a futuro se propone mejorar el cálculo de las semillas utilizando semillas
SMEM con traslape, ya que permite obtener un mayor número de semillas, que podría
resolver los problemas de las lecturas que no se alinean por no encontrar una semilla de
longitud mínima. Además, se propone el uso de bandas de bloques para realizar el
Algoritmo de Myers en zonas de interés y así realizar el cálculo de distancia de edición
para longitudes lecturas más largas. Finalmente se propone paralelizar los algoritmos
utilizando múltiples hilos para acelerar el proceso de alineación.
83
Referencias
Ahmadi, A., Behm, A., Honnalli, N., Li, C., Weng, L., & Xie, X. H. (2012). Optimized gram-
based methods for efficient read alignment. Nucleic Acids Res, 40(41).
Ahmed, N., Bertels, K., & Al-Ars, Z. (2016). A comparison of seed-and-extend techniques in
modern DNA read alignment algorithms. In Bioinformatics and Biomedicine (BIBM), 1421-
1428.
Altschul, S., Gish, W., Miller, W., Myers, E. W., & Lipman, D. J. (1990). Basic local alignment
search tool. Journal of molecular biology, 215(3), 403-410.
Burrows, M., & Wheeler, D. J. (1994). A block sorting lossless data compression algorithm. Reporte
Técnico, Digital Equipment Corporation, Systems Research Center, Palo Alto,
California.
Ferragina, P., & Manzini, G. (2000). Opportunistic data structures with applications. Foundations
of computer science (pp. 390-398). Redondo Beach, CA: IEEE.
Fox, E. J., Reid-Bayliss, K., Emond, M., & Loeb, L. (2015). Accuracy of Next Generation Sequencing
Platforms (Vol. 1).
Frese, K. S., Katus, H. A., & Meder, B. (2013). Next-Generation Sequencing: From
understanding biology to personalized medicine. Biology, 2, 378-398.
Galil, Z., & Park, K. (1990). An improved algorithm for approximate string matching. SIAM J.
Comput., 19, 989 –999.
Gonzaga-Jauregui, C., Lupski, J. R., & Gibbs, R. A. (2012). Human Genome Sequencing in
Health and Disease. Annual Review of Medicine, 63, 35–61. Retrieved from
http://doi.org/10.1146/annurev-med-051010-162644
Griffiths, A. M. (2002). Genética 7ª edición. Madrid: Interamericana-McGraw.
Hoffmann, J., Zeckzer, D., & Bogdan, M. (2016). Using FPGAs to Accelerate Myers Bit-Vector
Algorithm. XIV Mediterranean Conference on Medical and Biological Engineering and Computing
2016, 7.
Jiang, H., & Wong, W. H. (2008). SeqMap: mapping massive amount of oligonucleotides to the
genome. Bioinformatics, 24(20), 2395-2396.
Kent, W. (2002, 12). BLAT-the BLAST-like alignment tool. Genome Res. Genome Res, 656–64.
Khan, Z., Bloom, J., Kruglyak, L., & Singh, M. (2009). A practical algorithm for finding maximal
exact matches in large sequence datasets using sparse suffix arrays. Bioinformatics, 25,
1609–1616.
84
Khiste, N., & Llie, L. (2015, February 15). E-MEM: efficient computation of maximal exact
matches for very large genomes. Bioinformatics, 31(4), 509–514. Retrieved from
https://doi.org/10.1093/bioinformatics/btu687
Landau, G. M., & Vishkin, U. (1988). Fast string matching with k differences. J. Comput. Syst.,
37, 63-78.
Langmead, B., & Salzberg, S. L. (2012). Fast gapped-read alignment with Bowtie 2. Nature
methods, 357-359.
Langmead, B., Trapnell, C., Pop, M., & Salzberg, S. (2009). Ultrafast and memory-efficient
alignment of short DNA sequences to the human genome. Genome Biology, 10(3).
Levenshtein, V. (1966). Binary codes capable of correcting deletions. Insertions Reversals. Sov.
Phys. Dokl, 10(8), 707.
Li, H. (2012, July). Exploring single-sample SNP and INDEL calling with whole-genome de
novo assembly. Bioinformatics, 28(14), 1838-1844.
Li, H. (2013). Aligning sequence reads, clone sequences and assembly contigs with BWA-MEM.
preprint, arXiv:1303.3997.
Li, H. & Durbin, R. (2009). Fast and accurate short read alignment with Burrows-Wheeler
transform. Bioinformatics, 25(14), 1754-1760.
Li, H. & Homer, N. (2010). A survey of sequence alignment algorithms for next-generation
sequencing. Brief. Bioinforma, 11, 473-483.
Li, H. Handsaker, B., A, W., & al., e. (2009). The Sequence Alignment/Map format and
SAMtools. Bioinformatics., 25(16), 2078-2079.
Li, R. e. (2008). SOAP: short oligonucleotide alignment program. Bioinformatics, Vol. 24, No. 5,
pp. 713-714.
Li, R., Yu, C., Li, Y., Lan, T. W., Yiu, S. M., Kristiansen, K., & Wang, J. (2009). SOAP2: an
improved ultrafast tool for short read alignment. Bioinformatics, 25(15), 1966-1967.
Lindner, R., & Friedel, C. C. (2012). A Comprehensive Evaluation of Alignment Algorithms in
the Context of RNA-Seq. PLoS ONE, 7(12), e52403. Retrieved from
https://doi.org/10.1371/journal.pone.0052403
Liu, Y., Schmidt, B., & Maskell, D. L. (2012). Cushaw:a cuda compatible short read aligner to
large genomes based on the burrows-wheeler transform. BMC research notes, 5(1), 27.
Mills, R. E., Luttig, C. T., Larkins, C. E., Beauchamp, A. D., Tsui, C., Pittard, W. S., & Devine,
S. E. (2006). An initial map of insertion and deletion (INDEL) variation in the human
genome. Genome research, 16(9), 1182-90.
85
Mullaney, J. M., Mills, R. E., Pittard, W. S., & Devine, S. E. (2010). Small insertions and
deletions (INDELs) in human genomes. Human Molecular Genetics, 19, 131-136.
doi:https://doi.org/10.1093/hmg/ddq400
Myers, G. (1999). A fast bit-vector algorithm for approximate string matching based on dynamic
programming. Journal of the ACM (JACM), 395-415.
Needleman, N., & Wunsch, C. (1970). A General Method Applicable to the Search for
Similarities in the Amino Acid Sequence of two Proteins. Journal of Molecular, 48(3), 443–
453.
Novocraft. (2014). Retrieved 10 3, 2017, from Novocraft Technologies Sdn Bhd:
http://www.novocraft.com/products/novoalign/.
Pacheco, B. D., González, P. M., & Algredo, B. I. (2015). De la secuenciación a la aceleración
hardware de los programas de alineación de ADN, una revisión integral. Revista
Mexicana de Ingeniería Biomédica, 259-277.
Pelak, K., Shianna, K. V., Ge, D., Maia, J. M., Zhu, M., Smith, J. P., & Cirulli, E. C. (2010). The
characterization of twenty sequenced human genomes. PLoS Genetics, 6(9).
Pop, M. (2009). Genome assembly reborn: recent computational challenges. Briefings in
bioinformatics, 354-366.
Pressman, R. S. (2002). Ingeniería del Software Un enfoque práctico (séptima edición ed.). México: Mc
Graw Hill.
Ramos, J. V. (2016). Reparación del ADN: un asunto de vida…y de Premios Nobel. Educación
Química, 93-96.
Research, I. N. (2015, Octubre 21). National Human Genome Research Institute. Retrieved from
National Human Genome Research Institute: https://www.genome.gov
Rizk, G., & Lavenier, D. (2010). GASSST: Global alignment short sequence search tool.
Bioinformatics, 26(20), 2534-2540.
Rumble, S., Lacroute, P., Dalca, A., Flume, M., Sidow, A., & Brudno, M. (2009, May 22).
SHRiMP: Accurate Mapping of Short Color-space Reads. PLoS Comput Biol, 5(5).
Salavert, J. T., Tárraga, J., Medina, I., Dopazo, J., & Blanquer, I. (2015). Fast inexact mapping
using advanced tree exploration on backward search methods. BMC Bioinformatics, 16,
18. doi:http://doi.org/10.1186/s12859-014-0438-3
Sedlazeck, F. J., Rescheneder, P., & von Haeseler, A. (2013, 11 1). NextGenMap: fast and
accurate read mapping in highly polymorphic genomes. Bioinformatics, 29(21), 2790–
2791. Retrieved from https://doi.org/10.1093/bioinformatics/btt468
86
Simpson, J. T., & Durbin, R. (2010). Efficient construction of an assembly string graph using
the FM-index. Bioinformatics, 26(12), 367–373.
doi:http://doi.org/10.1093/bioinformatics/btq217
Smith, T., & Waterman, M. (1981). Identification of common molecular subsequences. J. Mol.
Biol, 14(1), 195–197.
Šoši´c, M. (2015). An SIMD dynamic programming c/c++ library (Tesis de Maestría). University
of Zagreb.
Tishkoff, S. A., & Kidd, K. K. (2004). Implications of biogeography of human populations for
'race' and medicine. Nature Genetics, 36(11), S21-S22.
Ukkonen, E. (1985). Finding approximate patterns in strings. Journal of &Algorithms, 6, 132-137.
Wu, T. D. (2016). Bitpacking techniques for indexing genomes: I. Hash tables. 11(5), 1748-7188.
Wu, T. D., & Watanabe, C. K. (2005, 5 1). GMAP: a genomic mapping and alignment program
for mRNA and EST sequences. Bioinformatics, 21(9), 1859–1875. Retrieved from
https://doi.org/10.1093/bioinformatics/bti310