Bioinformatikai Algoritmusok 9 GY Assembly s a legkisebb

Bioinformatikai Algoritmusok 9. GY Assembly és a legkisebb közös superstring Nyíri Tamás nytuaai@gmail. com http: //people. inf. elte. hu/nytuaai (Ben Langmead diasora alapján)

Assembly Read-ek X Reference genome + Input DNS Próbáljuk kirakni a puzzle-t a referencia kép nélkül.

Assembly A teljes genom “shotgun” szekvenciálása a DNS replikálásával és darabokra vágásával kezdődik. (Azért nevezik “Shotgun”-nak mert véletlenszerű darabokat kapunk a végén, mintha kilőttük volna egy shotgun-ból. ) Input: GGCGTCTATATCTCGGCTCTAGGCCCTCATTTTTT Másolat: GGCGTCTATATCTCGGCTCTAGGCCCTCATTTTTT Darabok: GGCGTCTA TATCTCGG CTCTAGGCCCTC ATTTTTT GGC GTCTATAT CTCGGCTCTAGGCCCTCA TTTTTT GGCGTC TATATCT CGGCTCTAGGCCCT CATTTTTT GGCGTCTAT ATCTCGGCTCTAG GCCCTCATTTTTT

Assembly Feltesszük, hogy a szekvenciálás elegendően sok replikát állít elő, hogy majdnem minden genom pozícióra sok másolatunk keletkezik… CTAGGCCCTCAATTTTT CTCTAGGCCCTCAATTTTT GGCTCTAGGCCCTCATTTTTT CTCGGCTCTAGCCCCTCATTTT TATCTCGACTCTAGGCCCTCA Ezt próbáljuk rekonstruálni TATCTCGACTCTAGGCC TCTATATCTCGGCTCTAGG GGCGTCTATATCTCG GGCGTCGATATCT GGCGTCTATATCTCGGCTCTAGGCCCTCATTTTTT Ezekből

Assembly. . . de nem tudjuk melyik honnan jött. Ezt próbáljuk rekonstruálni CTAGGCCCTCAATTTTT GGCGTCTATATCT CTCTAGGCCCTCAATTTTT TCTATATCTCGGCTCTAGGCCCTCATTTTTT CTCGGCTCTAGCCCCTCATTTT TATCTCGACTCTAGGCCCTCA GGCGTCGATATCTCGACTCTAGGCC GGCGTCTATATCTCGGCTCTAGGCCCTCATTTTTT Ezekből

Assembly Átlagos lefedettség: Az eredeti gén minden pozíciójára számoljuk meg hány darab read tartalmazza azt a pozíciójú nukleotidot és átlagoljuk. CTAGGCCCTCAATTTTT CTCTAGGCCCTCAATTTTT GGCTCTAGGCCCTCATTTTTT CTCGGCTCTAGCCCCTCATTTT TATCTCGACTCTAGGCCCTCA TATCTCGACTCTAGGCC TCTATATCTCGGCTCTAGG GGCGTCTATATCTCG GGCGTCGATATCT GGCGTCTATATCTCGGCTCTAGGCCCTCATTTTTT Átlagos lefedettség = 177 / 35 ≈ 7 x 177 nukleotid 35 nukleotid

Assembly Lefedettség adott helyen: Az eredeti genom egy bizonyos pozícióját hány read tartalmazza: CTAGGCCCTCAATTTTT CTCTAGGCCCTCAATTTTT GGCTCTAGGCCCTCATTTTTT CTCGGCTCTAGCCCCTCATTTT TATCTCGACTCTAGGCCCTCA TATCTCGACTCTAGGCC TCTATATCTCGGCTCTAGG GGCGTCTATATCTCG GGCGTCGATATCT GGCGTCTATATCTCGGCTCTAGGCCCTCATTTTTT Lefedettség ebben a pozícióban = 6

Assembly Minél nagyobb a hasonlóság az egyik read vége és egy másik eleje között. . . TATCTCGACTCTAGGCC ||||||| TCTATATCTCGGCTCTAGG. . . annál valószínűbb hogy ezek az eredeti genom egymást fedő részeiről származnak: TATCTCGACTCTAGGCC TCTATATCTCGGCTCTAGG GGCGTCTATATCTCGGCTCTAGGCCCTCATTTTTT

Assembly Tegyük fel hogy tényleg az eredeti genom egymást fedő részeiről származnak. Miért lehet bennük mégis eltérés? TATCTCGACTCTAGGCC ||||||| TCTATATCTCGGCTCTAGG 1. Szekvenciálási hiba 2. A kromoszóma öröklött másolataiban lévő különbség Pl. az emberek diploidok, azaz két másolattal rendelkeznek minden kromoszómából (apai és anyai). Ezek a másolatok különbözhetnek: anyai read: apai read: anyai szekvencia: apai szekvencia: TATCTCGACTCTAGGCC ||||||| TCTATATCTCGGCTCTAGG TCTATATCTCGACTCTAGGCC TCTATATCTCGGCTCTAGGCC Az egyszerűség kedvéért ezt most ignoráljuk, de a valódi eszközöknek figyelembe kell venniük.

Átfedések Megtalálhatjuk az összes átfedést úgy hogy készítünk egy irányított gráfot ahol a csúcsok a read-ek és az irányított élek az egymást fedő read-eket reprezentáló csúcsok között mennek. CTAGGCCCTCAATTTTT GGCGTCTATATCT CTCGGCTCTAGCCCCTCATTTT |||||||||| GGCTCTAGGCCCTCATTTTT CTCTAGGCCCTCAATTTTT TCTATATCTCGGCTCTAGGCCCTCATTTTTT CTCGGCTCTAGCCCCTCATTTT A forrás szuffix-e hasonló a nyelő prefix-éhez TATCTCGACTCTAGGCCCTCA GGCGTCGATATCTCGACTCTAGGCC GGCGTCTATATCTCG

Irányított gráfok - ismétlés Az irányított gráfot egy G(V, E) rendezett párral reprezentáljuk, ahol V a csúcsok halmaza és E az irányított élek halmaza. Egy irányított él csúcsok rendezett párjaként reprezentálható. a Az első a forrás, a második a nyelő. b A csúcsot grafikusan körrel reprezentáljuk. A két csúcs között futó élet pedig nyílként mely az egyik körből a másikba mutat. c d V = { a, b, c, d } E = { (a, b), (a, c), (c, b) } Forrás Nyelő

Átfedési gráf Alul: átfedési gráf, ahol az átfedés egy legalább 3 karakter hosszú szuffix/prefix illeszkedés. A csúcsok read-ek, az irányított élek átfedések a forrás szuffix-e és a nyelő prefix-e között. Csúcsok (read-ek): { a: CTCTAGGCC, b: GCCCTCAAT, c: CAATTTTT } Élek (átfedések): { (a, b), (b, c) } a: CTCTAGGCC 3 b: GCCCTCAAT CTCTAGGCC ||| GCCCTCAAT 4 c: CAATTTTT GCCCTCAAT |||| CAATTTTT

Átfedési gráf Az átfedési gráf tartalmazhat köröket is. A kör egy olyan út melynek az első és az utolsó csúcsa megegyezik. 7 a: CTCTAGGCC 3 b: GCCCTCACT Kör keletkezhet amiatt hogy DNS string maga is körkörös. (pl. a baktérium genomok gyakran körkörösek, illetve a mitokondriális DNS-ek is azok. Körök keletkezhetnek a DNS-ben lévő ismétlődő részek miatt is, amint látni fogjuk később. 4 c: CACTCTAGG

Átfedések keresése a: CTCTAGGCC b: GCCCTCAAT c: CAATTTTT Hogyan építjük fel az átfedési gráfot? Miből áll egy átfedés? Egyelőre nevezzük „átfedés”-nek azt amikor X egy ≥ l hosszú szuffix-e k helyen pontosan egyezik Y ugyanolyan hosszú prefixével adott k számra.

Átfedések keresése Átfedés: X egy l hosszú szuffix-e egyezik Y egy l hosszú prefixével ahol l adott. Egyszerű ötlet: keressük meg Y prefixében X k-hosszú szuffix-ét. Terjesszük ki a találatokat balra hogy biztosítsuk hogy az Y egész prefix-e egyezik. Legyen k = 3 Terjesszük ki balra; ebben az esetben megerősítjük, hogy Y 6 hosszú prefix-e egyezik X ugyanolyan hosszú szuffix-ével. Keressünk erre Y-ban, jobbról balra X: CTCTAGGCC Y: TAGGCCCTC Found it

Átfedések keresése: Implementáció def suffix. Prefix. Match(x, y, k): ''' Return length of longest suffix of length at least k that matches a prefix of y. Return 0 if there no suffix/prefix match has length at least k. ''' if len(x) <korlen(y) < k: return 0 idx = len(y) # start at the right end of y # Search right‐‐‐to‐‐‐left in y for length‐‐‐ksuffix of x while True: hit = string. rfind(y, x[‐‐‐ k: ], 0, idx) if hit == ‐‐‐: 1 # not found return 0 ln = hit + k # See if match can be extended to include entire prefix of y if x[‐‐‐ ln: ] == y[: ln]: return ln # return length of prefix idx = hit + k 1 ‐‐‐ # keep searching to left in Y return ‐‐‐ 1 Python példa: http: //nbviewer. ipython. org/7089885

Átfedések keresése él címke = átfedés hossza Példa átfedési gráfra (l=3) 5 ACGGCGC 3 5 GCATTAT 4 ATTATAT 5 3 ATATTGC 6 TATATTG 4 6 3 3 GCGTACG 4 CGCGTAC 3 5 ATTGCGC 3 CGCCGCT Eredeti string: GCATTATATATTGCGCGTACGGCGCCGCTACA 6 GCCGCTA 5 GTACGGC

Az assembly probléma megfogalmazása Az átfedések keresése fontos, és vissza fogunk térni rá, de a végső célünk a genom rekreálása (assembly-je). Hogyan tudjuk ezt a problémát megfogalmazni? Első próbálkozás: a legrövidebb közös superstring (SCS) keresése

Legrövidebb közös superstring Adott egy S string-ek halmaza. Találjuk meg a legrövidebb string-et aminek minden S-beli string rész-string-je. A „legrövidebb” megszorítás nélkül egyszerű: csak konkatenáljuk őket: Példa: S: BAA AAB BBA ABB BBB AAA BAB Konkatenáció: BAAAABBBAABAABBBBBAAABAB 24 SCS(S): AAABBBABAA 10 AAA AAB ABB BBA BAB ABA BAA

Legrövidebb közös superstring S: AAA AAB ABB BBA SCS(S): AAABBBA Meg tudjuk oldani? Képzeljünk el egy módosított átfedési gráfot ahol minden él költsége = -(az átfedés hossza) Az SCS megfelel annak az útnak amely mindegyik csúcsot egyszer látogatja meg, minimalizálva az út teljes költségét Ez az Utazó Ügynök Probléma (TSP), ami NP-teljes! AAA AAB ABB BBA AAB -2 -2 -1 -1 AAA -1 -1 BBB -1 ABB -2 -2 -2 BBA -2

Legrövidebb közös superstring Most hagyjuk figyelmen kívül az élsúlyokat és keressünk olyan utat ami mindegyik csúcsot pontosan egyszer látogatja meg. S: AAA AAB ABB BBA SCS(S): AAABBBA Ezt nevezik Hamilton útnak és ez is NP-teljes. AAB Ebből láthatjuk hogy az SCS maga is NP-teljes. AAA AAB ABB BBA AAA ABB BBA

Legrövidebb közös superstring és társai Az Utazó Ügynök, a Hamilton út, és a Legrövidebb Közös Superstring mind NP-teljesek. Ismétlésnek az Utazó Ügynökről, a Hamiltonian útról és az NPteljességről, lásd az “Introduction to Algorithms” - Cormen, Leiserson, Rivest and Stein 34. és 35. fejezetét, illetve az “Algorithms” - Dasgupta, Papadimitriou and Vazirani 8. és 9. fejezetét: http: //www. cs. berkeley. edu/~vazirani/algorithms

Legrövidebb közös superstring Egzakt választ tehát túl költséges (lassú) lenne találni. Közelítő megoldást nyújthat viszont a SCS mohó változata. A mohó algoritmus minden lépésben “mohón” választja a leghosszabbat a lehetséges átfedések közül, és összeolvasztja a forrását a nyelőjével.

Legrövidebb közös superstring: mohó verzió Mohó-SCS algoritmus működése (l = 1): 2 2 2 1 Input strings ABA ABB AAA AAB BBA BAB BAAB ABA ABB AAA BBB BBA BABB BAAB ABA AAA BBB BBAAB BABB ABA AAA BBB Vörössel jelölve azok a string. BBBAAB BABB ABA AAA ek amik a következő forduló BBBAABA BABB AAA előtt lesznek egyesítve BABBBAABA AAA Mohó válasz: BABBBAABAAA Superstring Igazi SCS: AAABBBABAA Egyesítési fordulók száma, soronként egyesítés. Az 1. oszlopban lévő szám = előző fordulóban egyesített átfedés hossza.

Legrövidebb közös superstring: mohó verzió Nem garantált hogy a mohó algoritmus a valódi SCS-hez vezető átfedéseket választja De jó approximáció; a mohó algoritmus által kapott superstring nem lesz több mint ~2. 5 x hosszabb mint a valódi SCS (see Gusfield 16. 17. 1)

Legrövidebb közös superstring: mohó verzió Mohó SCS algoritmus működése újra (l = 3): Input strings 6 6 5 5 5 3 ATTATAT CGCGTAC ATTGCGC GCATTAT ACGGCGC TATATTG GTACGGC GCGTACG ATATTGC TATATTGC ATTATAT CGCGTAC ATTGCGC GCATTAT ACGGCGC GTACGGC GCGTACG CGCGTACG TATATTGC ATTATAT ATTGCGC GCATTAT ACGGCGC GTACGGC CGCGTACG TATATTGCGC ATTATAT GCATTAT ACGGCGC GTACGGC CGCGTACGGC TATATTGCGC ATTATAT GCATTAT ACGGCGC CGCGTACGGCGC TATATTGCGC ATTATAT GCATTAT CGCGTACGGCGC GCATTATATTGCGC CGCGTACGGCGC GCATTATATTGCGCGTACGGCGC Superstring

Legrövidebb közös superstring: mohó verzió Másik példa a mohó SCS-re: adjuk meg az összes 6 hosszú substring-jét a a_long_long_time string-nek. l = 3. 5 5 5 5 4 ng_long_ a_long_l ong_ti ong_lo long_t g_long g_time ng_time ng_long_ a_long_l ong_ti ong_lo long_t g_long ng_time g_long_ ng_lon a_long_l ong_ti ong_lo long_time long_ti g_long_ ng_lon a_long_l ong_lo ng_time ong_lon long_ti g_long_ a_long_l ong_lon long_time g_long_ a_long long_lon g_long_time a_long_long_time a_long_time A válasz: a_long_time Mi történt? (hiányzik egy _long )

Legrövidebb közös superstring: mohó verzió Az átfedési gráf (l = 3): 3 3 5 a_long 4 3 5 ong_lo 4 4 5 3 3 long_l 4 5 ng_lon 4 3 5 4 3 g_long_ 3 4 4 ong_ti 5 5 long_t 5 4 3 3 5 4 4 ng_tim 3 5 g_time

Legrövidebb közös superstring: mohó verzió Az átfedési gráf (l = 3): 3 3 5 a_long 4 3 5 ong_lo 4 4 5 3 3 long_l 4 5 ng_lon 4 3 5 4 3 g_long_ 3 4 4 ong_ti 5 5 long_t 5 4 3 3 5 4 4 ng_tim 5 g_time 3 a_long_long_time Összes átfedés: 39

Legrövidebb közös superstring: mohó verzió Az átfedési gráf (l = 3): 3 3 5 a_long 4 3 5 ong_lo 4 4 5 3 3 long_l 4 5 ng_lon 4 3 5 4 3 g_long_ 3 4 4 ong_ti 5 5 long_t 5 4 3 3 5 4 4 ng_tim 5 g_time 3 a_long_time Összes átfedés: 44 Több mint a korrekt útnál!

Legrövidebb közös superstring: mohó verzió Ugyanaz a példa, csak a substring hossza 6 helyett 8 7 7 7 7 3 long_long_ _long_long_t ong_long_l ong_time a_long_l _long_time long_lon ng_long_ _long_lo g_long_t ong_long g_long_l a_long_l _long_time a_long_lon ng_long_t ong_long_l _long_time ong_long_ a_long_lon g_long_t g_long_l g_long_time ong_long_ a_long_lon g_long_l g_long_time ong_long_ a_long_long_l g_long_time ong_l a_long_long_time a_long_long_long_time a_long_long_time Megvan a válasz: a_long_long_time

Legrövidebb közös superstring: mohó verzió Miért elég hosszúak a 8 hosszú substring-ek ahhoz hogy rájöjjünk hogy 3 másolat van a long-ból? a_long_long_time g_long_l Egy 8 hosszú substring tartalmaz részt mindhárom long-ból

Ismétlések Az ismétlések gyakran elrontják az assembly-t. Az SCS-t legalábbis biztosan elrontják, a „legrövidebb” megszorítás miatt! A read-ek túl rövidek lehetnek ahhoz hogy felismerjék a repetitív szekvenciákat. A szekvenciálásnál ezért is törekednek a read hossz növelésére. Az algoritmusok amik nem foglalkoznak az ismétlésekkel (mint a mohó SCS algoritmusunk) összeolvaszthatják őket: a_long_long_time összeolvasztás a_long_time Az emberi genom ~ 50%-a repetitív!

Ismétlések Megfigyelés: az ismétlések elrontják az assembly-t Egy másik példa mohó SCS-t használva: Input: it_was_the_best_of_times_it_was_the_worst_of_times Gyűjtsük össze az összes k hosszú substring-et, aztán futtassuk a mohó SCS-t. Csináljuk ezt különböző l-ekre (minimális átfedési hossz) és k-kra. l, k output 3, 5 the_worst_of_times_it_was_the_best_o 3, 7 s_the_worst_of_times_it_was_the_best_of_t 3, 10 _was_the_best_of_times_it_was_the_worst_of_tim 3, 13 it_was_the_best_of_times_it_was_the_worst_of_times

Ismétlések Megfigyelés: az ismétlések elrontják az assembly-t Minél hosszabb substring-ek segítenek az repetitív régiókat hozzáigazítani a nem-repetitív kontextusukhoz: swinging_and_the_ringing_of_the_bells_bells_bells Sokszor mindkét oldalról megközelíthetjük az ismétléseket. Amikor középen találkozunk, megtaláltuk a kontextusukat : ringing_of_the_bells_bells_bells_to_the_rhyhming

Ismétlések Megfigyelés: az ismétlések elrontják az assembly-t Még egy példa mohó SCS-t használva : Input: swinging_and_the_ringing_of_the_bells_bells_bells l, k 3, 7 output swinging_and_the_ringing_of_the_bells 3, 13 swinging_and_the_ringing_of_the_bells_bells 3, 19 swinging_and_the_ringing_of_the_bells_bells_b 3, 25 swinging_and_the_ringing_of_the_bells_bells_bells A hosszabb és hosszabb substring -ek segítenek mélyebben belenyúlni az ismétlésekbe

Ismétlések Képzeljük el az átfedési gráf A ismétlést tartalmazó részét. Read-ek Genom részletek L 1 L 2 L 3 L 4 L 1 L 2 L 3 A ismétlés R 1 R 2 R 3 R 4 Feltételezzük hogy A hosszabb mint a read hossz Sok átfedés az A read-jei között L 4 Még ha el is tudjuk kerülni az A másolatainak összeomlasztását, akkor sem tudjuk melyik bemenő rész melyik kimenő részhez tartozik. R 1 R 2 R 3 R 4

Legrövidebb közös superstring: összefoglalás Az SCS nem tökéletes az assembly probléma megoldására Nincs kivitelezhető mód az optimális SCS megtalálására Mohó SCS-t kellett használni. A válaszok így túl hosszúak lehetnek. Az SCS tévesen összeomlasztja a repetitív szekvenciákat A válaszok így sokkal rövidebbek is lehetnek! Olyan formulációk kellenek amik (a) könnyen kontrollálhatók, és (b) a lehető legjobban bánnak az ismétlésekkel Emlékezzünk: Az ismétlések az algoritmustól függetlenül problémát okoznak az assembly-ben. Ez a read hossz és a genom repetitivitásának a függvénye.

Összefogalalás az assembly módszerekről Keressük a legtakarékosabb magyarázatot a read-ekre (legrövidebb superstring). Az egzakt megoldások nehezen kezelhetők (pl. a TSP), de van lehetőség egy mohó approximációra. Minden megoldás hamisan összeomlaszthatja az ismétléseket. Keressük a “maximum likelihood” magyarázatát a read-eknek; tehát kényszerítsük a megoldásokat hogy konzisztensek legyenek az uniform lefedettséggel. Nincsen könnyen kezelhető megoldása. Adjuk fel a feloldhatatlan ismétléseket és használjunk könnyen kezelhető algoritmusokat a feloldható régiók összeszerelésére. Ezt csinálják a gyakorlatban használt eszközök.