Stochastische Prozesse und Markow-Ketten

Transkript

1 Molekulare Biotechnologie Semester Heidelberg Abschlussprojekt Mathematik: Stochastische Prozesse und Markow-Ketten Nora Rieber Jens Keienburg Felix Bonowski Samuel Bandara

2 Inhaltsverzeichnis EINLEITUNG 1. DEFINITIONEN 1.1 Stochastischer Prozeß 1.2 Markow-Ketten 2. EINFÜHRUNG EINES MODELLS 2.1 Zustandsraum 2.2 Anfangsverteilung 2.3 Übergangswahrscheinlichkeiten 3. Die Übergangsmatrix 4. BESONDERE EIGENSCHAFTEN 4.1 Spezialfälle Reduzibilität der Übergangsmatrix Periodizität von Zuständen und Ketten Reguläre Markow-Ketten 4.2 Klassen von Zuständen Transitorische Zustände Rekurrente Zustände Absorbierende Zustände 5. LANGFRISTIGES VERHALTEN 6. BESTIMMTE WAHRSCHEINLICHKEITEN 6.1 Wahrscheinlichkeit eines Wegs

3 Einleitung Markow-Ketten eignen sich trotz ihrer vergleichsweise einfachen Mathematik dazu, eine große Zahl von in Alltag und Technik bedeutsamen Phänomenen treffend zu beschreiben. Sie finden praktische Anwendungen in so unterschiedlichen Gebieten wie der Spracherkennung, der Modellierung von Warteschlangen, der Marktforschung und der Identifizierung von Genen. In dieser Ausarbeitung wollen wir einen Überblick über die wichtigsten Definitionen im Zusammenhang mit Markow-Ketten geben und einige deren wichtigsten Eigenschaften vorstellen. Damit wollen wir dem Leser die nötigen Grundkenntnisse vermitteln, um sich in einem anwendungsorientierten Text zurechtzufinden. Im Anschluss gehen wir auf unser Projekt, ein auf der Anwendung von Markow-Ketten basierendes Programm zur Identifizierung von Genen in einem Bakteriengenom ein.

4 1. Definitionen 1.1 Stochastische Prozesse Unter einem stochastischen Prozeß versteht man eine Folge von Zufallsexperimenten, die sich anhand einer Familie von Zufallsvariablen X t, t T beschreiben lassen. Dabei wird T Parameterraum bzw. die Indexmenge genannt und steht für alle möglichen Zeitpunkte eines Systems. Die Menge M = X t t Theißt Zustandsraum. In ihr sind alle Werte enthalten, die die Zufallsvariablen annehmen können. X t0 ist der Wert der Zufallsvariable zum Zeitpunkt t 0. Bei einer stochastischen Kette ist der Parameterraum diskret, d.h. t N und X t kann nur abzählbar viele Zustände X 0, X 1, X 2, annehmen. Eine einfache Form von stochastischer Kette ist der n-malige Münzwurf; dabei enthält der Zustandsraum zwei Werte: Kopf und Zahl. 1.2 Markow-Ketten Eine Markow-Kette ist ein Spezialfall eines stochastischen Prozesses. Sie ist diskret in Zeit und Zustandsraum. Bei einer Folge X n mit n = 0, 1,, N (n kann verschiedene Werte eines N-Tupels annehmen) von diskreten Zufallsvariablen und mit Zustandsraum M = e 0, e 1,, e N, der also abzählbar viele Zustände enthält, handelt es sich um eine Markow-Kette, wenn P(X n+1 = e n+1 X 0 = e 0, X 1 = e 1,, X n = e n ) = P(X n+1 = e n+1 X n = e n ) erfüllt ist. Die Besonderheit der Markow-Kette liegt also darin, daß die Wahrscheinlichkeit eines Übergangs zum Zustand X n+1 nur vom vorherigen Zustand X n abhängt und nicht von den früheren Zuständen. Eine Markow-Kette wird bestimmt durch ihren Zustandsraum, ihre Anfangsverteilung, und ihre Übergangswahrscheinlichkeiten.

5 2. Einführung eines Modells Zur Veranschaulichung wird folgendes Modell eingeführt: Es besteht aus vier verschiedenen Zuständen, die über verschiedene Wege erreicht werden können. Abb. 1: Ein kleines Markow-Modell mit 4 Zuständen 2.1 Zustandsraum In diesem Modell gibt es vier Zustände: e 1, e 2, e 3, e 4. Also ist der Zustandsraum M = e 1, e 2, e 3, e Anfangsverteilung Die Anfangsverteilung beschreibt, mit welcher Wahrscheinlichkeit das System sich zu Beginn in einem bestimmten Zustand befindet. Sie kann in Form eines Zeilenvektors, dem Anfangsvektor p(0) ausgedrückt werden. p(0) hat bei N verschiedenen Zuständen die Form p(0) = (p 1 (0), p 2 (0),, p N (0) ) Dabei ist p i (0) die Wahrscheinlichkeit, daß die Markow-Kette in dem Zustand e i beginnt, mit N p i 0 und p i = 1. i= 1

6 Beispielsweise ist beim obigen Modell p(0) = (1, 0, 0, 0), wenn der Anfangszustand e 1 ist; wenn der Anfangszustand unbekannt ist, ist wenn man eine Gleichverteilung annimmt, p(0) = (1/4, 1/4, 1/4, 1/4). 2.3 Übergangswahrscheinlichkeiten Unter Übergangswahrscheinlichkeiten versteht man die Wahrscheinlichkeiten, daß das System in einem Schritt von dem Zustand e i in den Zustand e j wechselt. Wir definieren: p(e i e j ) = p ij Es gilt: Sollte der Übergang nicht möglich sein, ist p ij = 0; sollte der Übergang der N einzigmögliche sein, ist p ij = 1. Allgemein gilt: p ij = 1. Beim obigen Modell ist z.b. p 13 = 0 ; p 12 = 1/2 ; p 34 = 1/3, wenn man annimmt, daß in einem bestimmten Zustand jeder mögliche Übergang gleich wahrscheinlich ist. Von einer homogenen Markow-Kette spricht man dann, wenn sich die Übergangswahrscheinlichkeiten nicht mit der Zeit ändern. j= 1 3. Die Übergangsmatrix Zusammenfassen lassen sich diese Übergangswahrscheinlichkeiten in der sogenannten Übergangsmatrix. Bei N Zuständen hat diese Matrix allgemein die Form: P = p p M p N1 p p p M N 2 L L M L p p p 1N 2N M NN Für das obige Beispiel hat sie die Form: P =

7 Dabei steht in der i-ten Zeile und der j-ten Spalte die Wahrscheinlichkeit p ij, die ein Übergang vom Zustand e i in den Zustand e j besitzt. Die Übergangsmatrix ist eine quadratische N x N Matrix (bei N verschiedenen Zuständen). Des Weiteren ist sie stochastisch, d.h.: p ij [0,1] für i, j = 1, 2,, N N und = 1 (Zeilensumme gleich 1) j= 1 p ij Die Wahrscheinlichkeiten für den Zustand des Systems nach einem Durchgang erhält man dann, indem man den Anfangsvektor p(0) mit der Übergangsmatrix multipliziert: p11 p12 L p1n p21 p22 L p2n p(1) = p(0) * M M M M = (p 1 (1), p 2 (1),, p N (1)) pn1 pn 2 L pnn Beispielsweise ist für die Übergangsmatrix des obigen Modells und der Anfangsverteilung p(0) = (1, 0, 0, 0) die Verteilung nach einem Durchgang: p(1) = (1, 0, 0, 0) * 2 2 = (0, 1/2, 0, 1/2) Besondere Eigenschaften 4.1 Spezialfälle Reduzibilität der Übergangsmatrix Als reduzibel bezeichnet man eine Markow-Kette, wenn mindestens zwei Untermengen U,V M existieren, so dass gilt: p x U y V = 0 und p y V x U = 0 Die Übergangsmatrix lässt sich also durch Permutation in die Form P A = 0 bringen. 0 B A, B sind quadratische Untermatrizen mit den Übergangswahrscheinlichkeiten innerhalb U bzw. V

8 Die Markow-Kette zerfällt in diesem Fall in unabhängig voneinander untersuchbare Teile Periodizität von Zuständen und Ketten Ein Zustand e i heißt periodisch wenn es nicht mit jeder beliebigen Schrittzahl möglich ist, zu ihm zurückzukehren. X=n N 0, p ii (n) > 0 Die Periode ist die größte Zahl, die alle Elemente aus X teilt bzw., wenn X nur 0 enthält. Periodisch ist also ein Zustand, dessen Periode größer 1 ist. Als aperiodisch bezeichnet man Zustände mit einer Periode von 1 oder. Im Falle der Irreduzibilität der Markow-Kette spricht man auch von Periodizität der Markow- Kette als ganze Reguläre Markow-Ketten Als regulär bezeichnet man eine Markow-Kette, die irreduzibel ist und keine periodischen Zustände enthält. Homogenität und Regularität sind ein hinreichendes Kriterium für die Existenz der Grenzmatrix lim n (P n ) 4.2 Klassen von Zuständen Transiente Zustände Wenn es einen Zustand e k gibt, heißt ein Zustand e i heißt transient (=vorübergehend), wenn es von e i aus zwar einen Weg zum Zustand e k gibt, jedoch keinen, der von e k aus wieder zu e i zurückführt. In diesem Fall sinkt die Wahrscheinlichkeit dieses Zustandes mit wachsender Anzahl der Durchgänge monoton. Die Übergangsmatrix lässt sich in diesem Fall in eine Form P A = B bringen. 0 C Rekurrente Zustände A, C sind quadratische Untermatrizen, alle Übergangswahrscheinlichkeiten zu e i sind null Als rekurrent (=wiederkehrend) bezeichnet man alle Zustände, die nicht transient sind Absorbierende Zustände Zustände mit p ii =1 können nicht mehr verlassen werden. Man nennt sie absorbierend. In der Übergangsmatrix ist in diesem Fall in der i-ten Zeile der i-te Einheitsvektor.

9 Die Menge aller absorbierenden Zustände nennt man Rand von M Eine Markow-Kette, bei der von jedem Zustand aus ein Weg zu mindestens einem absorbierenden Zustand besteht, nennt man ebenfalls absorbierend. 5. Langfristiges Verhalten Hier interessiert man sich dafür, wie sich das System nach einer großen Anzahl n von Durchgängen verhält sowie insbesondere für dessen Grenzverhalten für n gegen unendlich. Einige interessante Eigenschaften lassen sich bereits aus der Übergangsmatrix P ablesen. So werden z.b. wie schon angesprochen transiente Zustände mit der Zeit verschwinden, absorbierende, zu denen ein Weg existiert hingegen eine immer größere Bedeutung gewinnen. Wenn der Grenzwert der Übergangsmatrix lim n (P n ) existiert, so geht die Verteilung p(n) für n gegen Unendlich in eine stationäre Verteilung p über, für die gilt: p *P= p Dies ist z.b. bei homogenen regulären Markow-Ketten immer der Fall. In unserem Beispiel aus (2.) ist diese Grenzmatrix (auf drei Stellen gerundet): P 0,276 0,276 = 0,276 0,276 0,207 0,207 0,207 0,207 0,207 0,207 0,207 0,207 0,310 0,310 0,310 0, Bestimmte Wahrscheinlichkeiten 6.1 Wahrscheinlichkeit eines Wegs Als Weg bezeichnet man eine Abfolge von nacheinander durchschrittenen Zuständen. Man kann einen Weg der Länge i eindeutig durch ein i-tupel von Zuständen beschreiben. Die Wahrscheinlichkeit dafür, dass beim Start in einem bestimmten Zustand ein bestimmter Weg beschritten wird, lässt sich einfach durch Aufmultiplizieren der dazugehörigen Übergangswahrscheinlichkeiten ermitteln: p(e i,e j,e k,e l )= p i *p ij *p jk *p kl

10 7. Hidden Markov Modelle in den Genomics : 7.1. Einleitung : Die Zahl sequenzierter Genome ist in den vergangenen Jahren dramatisch gestiegen und erfordert zur Auswertung der hohen Datenmengen zuverlässige und einfache Methoden. Der erste Schritt zum Verständnis des Genoms besteht in der Zuordnung von Genen, einschließlich aller seiner Elemente, wie Start-, Stopcodon, Intron-Exon-Bereich, Promotoren, Transkiptionsterminatoren, poly(a)-sites usw. Viele Gene können auf einfache Weise durch ihren hohen Homologiegrad zu Genen aus anderen Genomen näher charakterisiert werden. Der Großteil der Gene besitzt jedoch kein entsprechendens Pendant. Markovmodelle haben sich zu diesem Zweck als ein effizientes und einfaches Mittel bewährt. Sie bestimmen anhand der Übergänge von Basen die Wahrscheinlichkeit eines Gens. Diese Modelle sind mittlerweile so gut entwickelt, dass sie mit bis zu 97 % Sicherheit ein Gen richtig zuordnen. In diesem Projekt wurde die Anwendung von Markovmodellen höherer Ordnung zur Auffindung von Genen in Prokaryoten detailliert bearbeitet. Zu diesem Zweck wurde ein Computerprogramm entwickelt, anhand welchem die theoretischen Überlegungen getestet und die Eignung der Markovmodelle verifiziert werden konnten. 7.2 Einführung : In einem Genom besitzen codierende und nicht codierende Gensequenzen unterschiedliche Übergangswahrscheinlichkeiten zwischen den Basen. Man macht sich diese Tatsache zu Nutze, um anhand der Abfolge, in der die Basen erscheinen, die Wahrscheinlichkeit eines vorliegenden Gens zu berechnen. Die Methodik wird im folgenden detailliert erläutert. Definition von Open Reading Frame : Ein Open Reading Frame ist eine Gensequenz, die von einem Start- (ATG) und einem Stopcodon (TAA, TAG, TGA) terminiert wird. Dabei muss die Zahl der Nukleotide in der Sequenz ein Vielfaches von drei sein (Tripletcode). Bemerkungen : (1) Die Beschränkung auf eukaryotische Organismen schließt die Unterbrechung durch Introns aus. (2) Jedes Gen ist zugleich auch ein Open Reading Frame. Auf der anderen Seite ist jeder ORF ein Kanditat für ein Gen. (3) In einem Genom gibt es mehr ORFs als Gene, wobei das genaue Verhältnis stark von der Art des Organismus abhängt. Verwandte Organismen besitzen ähnlich aufgebaute Genome. Aufgrund dieser Tatsache lassen sich alle möglichen Gene exakt bestimmen. Der nächste Schritt besteht darin, aus der Menge der gegebenen ORFs die Gene zu extrahieren.

11 Deklaration der Markovkette : Im folgenden wird eine räumliche, homogene Markovkette zur Beschreibung von Gensequenzen deklariert. T sei die Indexmenge mit T = 1, 2,..., N, wobei N die Anzahl der betrachteten Basen bezeichnet. t weise jeder Base genau einen Index zu, wobei die Base mit Index t+1 der Base mit Index t unmittelbar folgt. Desweiteren sei M = A, C, G, T ein Zustandraum, wobei die Buchstaben die Basen umfassen, die eine Base annehmen kann. Sei die Familie der Zufallsvariblen X (t), t T ein stochastischer Prozess mit Parameterberech T und Zustandsraum M. Der stochstische Prozess X (t), t T besitze die Markow sche Eigenschaft : P( X (t) = m X(t-1) = m t-1, X(t-2) = m t-2,... X(1) = m 1 ) = P( X (t) = m X(t-1) = m t-1 ) Damit hängt die Wahrscheinlichkeit jedes Zustands einer Base nur von dem Zustand der vorherigen Base ab. Die Übergangswahrscheinlichkeit p m(t-1) -> m(t) sei von t unabhängig, was gleichbedeutend mit der Aussage ist, dass die Markovkette homogen ist. Hidden Markov Modelle : Ist X (t), t N eine Markovkette mit Parameterbereich N und Zustandsraum M, und p ij die Wahrscheinlichkeit des Übergangs vom Zustand i nach j, wenn i, j M ist, dann kann man zu jedem t N einen Zustand von X(t) beobachten. Diese Beobachtung liegt den Übergangswahrscheinlichkeiten p ij des Markovmodells zugrunde. Weil das Markovmodell dem Beobachter nicht zugänglich ist, spricht man von einem Hidden Markov Modell Markov Modelle höherer Ordnung : Aufgrund der Komplexität des Genoms ist es wenig überraschend, dass der Zustand einer Base von mehreren unmittelbar vorhergehenden Basen abhängt. Diese Tatsache gibt Anlass das Markov Modell so zu erweitern, dass es diese Abhängigkeiten in Rechnung zieht. Definition : Sei M ein abzählbarer Zustandsraum (z.b. M = e 1,...,e t ), T eine Indexmenge mit Elementen in Z + (z.b. T = 1,..., N), und eine Familie X t, t T von Zufallsvariablen ein stochastischer Prozess mit Zustandsraum M und Parameterbereich T. Der stochastische Prozess X t, t T heißt Markovkette k-ter Ordnung, wenn er der Eigenschaft P( X (t) = m n X(1) = m 1,..., X(t-2) = m n-2, X(t-1) = m n-1 ) genügt. = P( X (t) = m n X(t-k) = m n-k,..., X(t-2) = m n-2, X(t-1) = m n-1 )

12 Im oben betrachteten Beispiel ist die Kardinalität des Zustandsraumes 4 und die Indexmenge T stets größer als null, was die Bedingungen erfüllt. Die Ordnung eines Markovmodells bezeichnet den Grad der betrachteten Abhängigkeit. Die Wahrscheinlichkeit eines Übergangs hängt von allen k unmittelbar vorhergehenden Basen ab. In der Praxis geben Markovmodelle 5ter bis 8ter Ordnung einen guten Aufschluss über eine Gensequenz Markovmodelle : Die Übergangswahrscheinlichkeiten in einem Markov schen Prozess werden als Markovmodell zusammengefasst. Das Markovmodell wird durch eine Matrix repräsentiert. Die Übergangswahrscheinlichkeiten von einem Zustand m in einen Zustand j lassen sich ermitteln, indem man in einem Genom die Übergänge von dem Zustand m in den Zustand j zählt und zur Anzahl der gezählten Übergänge in Abhängigkeit von m relativiert. Im Falle eines Markovmodells k-ter Ordnung, wird ein k-tupel von Zuständen betrachtet, von denen der Zustand j abhängt. Um diese Übergangswahrscheinlichkeiten zu ermitteln, zählt man alle (k+1)-tupel aufeinanderfolgender Basen, wobei die k +1-te Base des Tupels den Zustand j der neuen Base angibt. Die Übergangswahrscheinlichkeiten berechnen sich wie folgt : P( X (t) = j X(t -1) = m t-1,...x(t - k) = m t-k ) = P( X( t) = j, X ( t 1) = m P( X( t 1) = m t 1 t 1,..., X ( t k) = m,..., X ( t k) = m t k ) t k ) Bemerkung : j I P( X (t) = j X(t -1) = m,... X(t - k) = m t -1 t-k = ) 1 Die Übergangswahrscheinlichkeiten werden in einer k + 1 dimensionalen Matrix festgehalten. Übergangswahrscheinlichkeiten in Gensequenzen verwandter Genome ähneln sich stark genug um Wahrscheinlichkeitsmodelle zu übertragen. Diese Eigenschaft macht man sich zu Nutze, um anhand bekannter Gene in verwandten Organismen ein Markovmodell zu entwickeln. Man berechnet Modelle, welche die Übergangswahrscheinlichkeiten in nicht codierenden und in codierenden Bereichen erfassen. Um die Übergänge statistisch besser beschreiben zu können entwickelt man für codierende Bereiche insgesamt sechs Modelle, wobei drei Modelle jeweils einen von drei möglichen Offsets widergeben. Dabei wird sowohl die vorwärts- als auch die rückwärts Richtung betrachtet. Für den nichtcodierenden Bereich reicht ein Modell aus. Die Modelle für den codierenden und den nichtcodierenden Bereich werden getrennt betrachtet. Die Modelle für die verschiedenen Offsets werden einfach miteinander verrechnet. Die Markovmodelle, die die Übergangswahrscheinlichkeiten liefern, werden an eindeutig bekannten Genen verwandter Genome trainiert. 7.5 Scoring : Um einen ORF als Gen charakterisieren zu können, berechnet man die Wahrscheinlichkeit, mit der eine bestimmte Sequenz auftritt, wobei man den Übergängen ein Markovmodell z.b. ein Modell für Gene - zugrunde legen muss. Es lässt sich also für einen ORF die Wahrscheinlichkeit p berechenen, mit der die Sequenz des ORF von einem Markovmodell

13 erzeugt wurde. Die Formel zur Berechnung der Wahrscheinlichkeit lässt sich leicht aus der Markov schen Eigenschaft herleiten : P ( X(1) = m 1, X(2) = m 2,... X(n-1) = m n-1, X(n) = m n ) = P( X(1) = m 1 ) * P(X(2) = m 2, X(1)= m 1 ) *... * P( X(n-1) = m n-1 ) X(n-2) = m n-2,..., X(2)= m 2, X(1)= m 1 ) * P( X(n) = m n ) X(n-1) = m n-1,..., X(2)= m 2, X(1)= m 1 ) Wegen der Markov schen Eigenschaft gilt : = P( X(1) = m 1 ) * P(X(2) = m 2, X(1)= m 1 ) *... * P( X(n-1) = m n-1 ) X(n-2) = m n-2,..., X((n-1)-(k-1)) = m (n-1)-(k-1), X((n-1)-k) = m n-(k+1) ) * P( X(n) = m n ) X(n-1) = m n-1,..., X(n-(k-1)) = m 2n-(k-1), X(n-k) = m n-k ) Der Einfachheit halber kann man die ersten k Basen vernachlässigen und erhält damit die Formel : P ( X(k+1) = m k+1, X(k+2) = m k+2,... X(n-1) = m n-1, X(n) = m n ) = Π j P mj, wobei m ein k-tupel von Zuständen ist und j auf m folgt. (Bemerkung : Die ersten drei Basen können vernachlässigt werden, weil jeder Open reading frame mit ATG beginnt. Zieht man die n-te Wurzel aus diesem Produkt, wenn n die Anzahl der betrachteten Basen ist, dann erhält man einen von der Länge der betrachteten Sequenz unabhängigen Score. Der Score ist ein Maß für die Wahrscheinlichkeit, dass ein Markovmodell zutrifft.

14 8. Versuch an E. Coli K12 : 8.1 Einleitung : Durch die öffentlich verfügbaren Genomdatendbanken kann man auf bequeme Art und Weise Zugang zu allen Sequenzdaten erhalten und daran Forschungen betreiben. Anhand von E. Coli K12 haben wir das von uns entwickelte Computerprogramm an einem biologischen Modellorganismus getestet. Im folgenden wird dargestellt, wie mit Hilfe eines Computerprogramms die Gene von E.Coli innerhalb der ersten Basen mit einer Sicherheit von 94 % gefunden werden können. 8.2 Versuchsbeschreibung : Das Genom und die annotierten Gene von E. Coli K12 wurden von der NCBI Datenbank geladen. Anhand aller 1800 Gene des E. Coli Genoms wurden Markovmodelle zweiter bis achter Ordnung berechnet. Desweiteren wurden aus den ersten Basen des Genoms 9300 ORFs ermittelt. Anhand der gefundenen ORFs, die auch Gene enthalten, wurden erneut Makovmodelle zweiter bis achter Ordnung erstellt. Diese Modelle wurden benutzt um den Score der ersten 9300 ORFs zu ermitteln. Die beiden durch die zwei unterschiedlichen Markovmodelle ermittelten Scores wurden durcheinander geteilt, und dann in einem Histogramm in Excel ausgewertet. 8.3 Versuchsauswertung : Hier ist das Histogramm, welches die Verteilung der ORFs und Gene über die Scores darstellt. 0,09 0,08 0,07 0,06 Verteilung von Genen und ORFs : ORFs Gene rel. Häufigkeit 0,05 0,04 0,03 0,02 0,01 0 0,5 0,54 0,58 0,62 0,66 0,7 0,74 0,78 0,82 0,86 0,9 0,94 0,98 1,02 score 1,06 1,1 1,14 1,18 1,22 1,26 1,3 1,34 1,38 1,42 1,46 1,5

15 Das Histogramm zeigt eine deutliche Aufspaltung zwischen den Genen und den ORFs. Der Mittelwert der Gene liegt bei ungefähr 1,23, der Mittelwert der ORFs dagegen bei ungefähr 0,98. Definiert man den Schwellenwert, ab dem alle Sequenzen mit einem größeren Score als Gene charakterisiert werden bei 1,11, dann würden 94 % aller Gene richtig erkannt und mindestens 90 Prozent aller nicht codierender ORFs ausgeschlossen werden. Die Leistung des Algorithmus, die sich an den relativen Häufigkeiten von Genen und ORFs orientiert hätte in diesem Bereich ein wahrscheinliches Maximum, wenn man berücksichtigt, dass unter den ORFs mit Scores gößer als 1,11 auch Gene sind. 8.4 Programmbeschreibung : Das gesamte Programm besteht aus drei Funktionen, die sich Profiler, Findorfs und Score nennen. Die Programme wurden in C++ auf einer Linuxplattform programmiert, was die Empfehlung nahelegt, diese auf einem Linuxrechner zu benutzen. Die Programme werden alle über die Kommandozeile gesteuert profiler.cpp : Profiler erstellt Markovmodelle zweiter bis achter Ordnung. Die Syntax für den Befehl in der Kommandozeile lautet :./profiler gene_file project_name first_base last_base, wobei gene_file eine beliebige FASTA-Datei ist, die noch manuell mit "<<" terminiert werden muss. FASTA-Dateien lassen sich auf der NCBI Datenbank an der Endung.ffn erkennen. project_name ist ein beliebiger Projektname wie zum Beispiel "ecoli", und first_base und last_base gibt den Bereich an, in dem die Trainingsgene liegen müssen, was den Vorteil hat, dass man nicht über alle Gene trainieren muss. Die Modelle werden nur aus den Genen berechnet, die im angegebenen Bereich liegen. Ein Beispiel für einen korrekten Programmstart wäre :./profiler NC_ ffn ecoli , wobei Markovmodelle aus den Genen in NC_ ffn, die im Bereich zwischen 0 und liegen, berechnet werden würden. Das Programm interpretiert die FASTA-Zeilen automatisch. Zusätzlich legt das Programm eine Datei "project_name.gtd" an, die eine Liste mit Startcodonpositionen enthält. Diese Liste lässt sich für die im folgenden beschriebene Funktion FindORFs dazu benutzen um aus allen ORFs nur nichtcodierende zu erhalten findorfs.cpp : FindORFs sucht alle Open Reading Frames in einer Genomdatei. Diese Dateien kennzeichnen sich durch die Endung.fna. Das Kommando für die Funktion lautet :./findorfs genome_file orf_output first_base last_base [exclusion_list]. genome_file gibt eine Genomdatei an, die von Hand mit << terminiert sein muss. orf_output steht für den Namen der Datei, in die die ORFs geschrieben werden sollen (wobei das FASTA-Format benutzt wird, so dass es formatmäßig keine Unterschiede zwischen Dateien von NCBI und unseren gibt!). first_base und last_base geben den Bereich an, in dem nach ORFs gesucht werden soll. Das Programm kann alle ORFs finden, egal mit welchem Offset oder in welche Richtung die ORFs gehen. Anhand der optionalen exclusion list (eine Datei wie "project_name.gtd", die von profiler erstellt wird) werden alle ORFs, die in dieser Liste durch Startcodons gekennzeichnet sind, fon findorfs ignoriert werden. Auf

16 diese Weise könnt Ihr zum Beispiel erst auf einem Zehntel des Genoms trainieren, wobei die Genpositionen herausgeschrieben werden, und diese Liste findorfs vorlegen, damit dieses Programm dann nur nicht codierende ORFs herausschreibt. Bsp.:./findorfs NC_ fna nogenes.fnn ecoli.gtd Es gibt im Quellcode eine Konstante threshold, mit der die Mindestlänge eines ORFs festgelegt werden kann scores.cpp : Scores berechnet die Scores aller ORFs in einer FASTA-Datei und schreibt diese excelimportierbar in eine Datei:./score gene_file output model_file order, wobei gene_file eine FASTA-Datei ist, output die zu erstellende Scoredatei, in der dann FASTA-Zeile und Score mit Tabulator separiert in jeder Zeile stehen, model_file gibt die Datei mit dem Markovmodell an und order dessen Ordnung. Beispiel:./score NC_ ffn scores.txt ecoli.gm3 3 Die Funktionsfähigkeit der Programme ist sehr zuverlässig. Wichtig ist, dass die Syntax in der Kommandozeile befolgt wird, so wie es oben beschrieben wurde. Die Einschränkung : die FASTA-Dateien, die die Programme schreiben, sind nicht automatisch mit "<<" terminiert. Das heisst, dass dies von Hand nachgeholt werden muss. Anmerkung : Aufgrund von Konvertierungsproblemen ist es möglich, dass nicht alle Gene in der exclusion list enthalten sind. Mithilfe dieser Funktionen lassen sich wichtige Experimente auf einfache Weise vollziehen. 8.5 Quellcode : Hier ist der Quellcode für die drei Programme : profiler.cpp : #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <memory.h> int base_index(char *seq, int order) int index = 0; // two bits for each base // const char base[4] = 'A', 'C', 'G', 'T'; for (int i = 0; i <= order; i ++) // order gives context size // for (int j = 0; j < 4; j ++)

17 if (base[j] == seq[i]) // align base code to index // index = (j << (2*(order-i))); return index; int profiler(char *orffile, int lobase, int hibase, int order, double **markov, int *&genelog, int &model_smoothed) const int msize = 8192; int mmsize, gene_unk, gene_lo, gene_hi, *occurrence[3], base = 0, cnt = 0, alloc = 0; char gene[msize]; bool skipgene; FILE *pfile; // the file specified by caller is not valid // if (! (pfile = fopen(orffile, "r"))) return -1; mmsize = 4; // calculate the size of model // for (int f = 0; f < order; f ++) mmsize *= 4; for (int i = 0; i < 3; i ++) // allocate and initialize memory for occurrence // occurrence[i] = (int *)malloc(mmsize * sizeof(int)); memset(occurrence[i], 0, mmsize * sizeof(int)); while ((gene[base] = fgetc(pfile))!= '<') // read in the entire fasta descriptor line // while ((gene[base ++] = fgetc(pfile))!= '\n'); gene[base] = '\0'; // terminate fasta line // strtok(gene, ":c-\n"); // tokenize // gene_unk = atoi(strtok(null, ":c-\n")); gene_lo = atoi(strtok(null, ":c-\n")); if (gene_unk < gene_lo) gene_hi = gene_lo; gene_lo = gene_unk; else gene_hi = gene_unk; base = 0; skipgene = ((lobase > gene_lo) (hibase < gene_hi))? true : false; // check for specified range // if (! skipgene) if ((genelog == 0L) (cnt == alloc)) // full list of processed genes // genelog = (int *) realloc(genelog, (alloc += 1024) * sizeof(int)); genelog[cnt] = gene_unk; // start // while (((gene[base] = fgetc(pfile))!= '<') && (gene[base]!= '>')) // read gene // if ((! skipgene) && (gene[base]!= '\n'))

18 if (base > (order - 1)) // increment occurrence of the tupel // occurrence[base % 3][base_index (gene + base - order, order)] ++; base ++; if (! skipgene) cnt ++; base = 0; fclose(pfile); for (int k = 0; k < mmsize; k += 4) // look at A, C, G, T at once // for (int off = 0; off < 3; off ++) int occ4 = 0; bool low_data = false; for (int next = 0; next < 4; next ++) // occurrence of preceding tupel // occ4 += occurrence[off][k + next]; if (occurrence[off][k + next] == 0) low_data = true; // smooth it // if (low_data == true) for (int base = 0; base < 4; base ++) // smooth markov probabilities // occurrence[off][k + base] ++; model_smoothed ++; occ4 += 4; for (int x = 0; x < 4; x ++) // calculate the transition probabilities // markov[off][k+x] = (double) occurrence[off] [k+x] / occ4 * 4.f; //... normalized // return cnt; int main(int argn, char *argv[]) // usage: profiler genome project first_base last_base // char *genome_file = argv[1], *project = argv[2]; int first_base = atoi(argv[3]), last_base = atoi(argv[4]); int i, p, msize, *gene_log, smoothed, gene_cnt; double *markov_model[3]; char model_filename[16]; FILE *pfile; printf("building models from %d to %d...\n", first_base, last_base); // confirm the range of bases to user // for (int order = 2; order < 9; order ++) for (i = 0; i < 3; i ++) // allocate memory //

19 msize = 4; // calculate size of model // for (p = 0; p < order; p ++) msize *= 4; markov_model[i] = (double *) malloc(msize * 8); gene_log = 0; smoothed = 0; gene_cnt = profiler(genome_file, first_base, last_base, order, markov_model, gene_log, smoothed); // run // printf("%d order model built, smoothed %d\n", order, smoothed); // write status msg // sprintf(model_filename, "%s.gm%d", project, order); pfile = fopen(model_filename, "w"); // open file // for (i = 0; i < 3; i ++) for (p = 0; p < msize*8; p ++) // store each markov model into output file // fputc(*(((char *)(markov_model[i]))+p), pfile); free(markov_model[i]); fclose(pfile); if (order == 8) // export list of genes to training file // sprintf(model_filename, "%s.gtd", project); pfile = fopen(model_filename, "w"); for (i = 0; i < 4; i ++) // number of genes // fputc(*(((char *)(& gene_cnt))+i), pfile); for (i = 0; i < gene_cnt*4; i ++) // write gene start addresses to file // fputc(*(((char *)(gene_log))+i), pfile); fclose(pfile); printf("%d genes taken into account, list is %s\n", gene_cnt, model_filename); // status message // free(gene_log); return 0; findorfs.cpp : #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <memory.h> int base_index(char *seq, int order) int index = 0; // two bits for each base // const char base[4] = 'A', 'C', 'G', 'T';

20 for (int i = 0; i <= order; i ++) // order gives context size // for (int j = 0; j < 4; j ++) if (base[j] == seq[i]) // align base code to index // index = (j << (2*(order-i))); return index; char complementary(char cmpl_base) // finds out a complementary base // const char base[4]='a','c','g','t'; for (char i = 0; i < 4; i ++) if (base[i] == cmpl_base) return base[(i ^ 0x03)]; return '\0'; int listsize = 0, *exclusionlist = 0; bool exclude(int start) // search the list of exclusion // for (int i = 0; i < listsize; i ++) if (exclusionlist[i] == start) return true; // exclude // return false; int findorfs(char *ifile, char *ofile, int lobase, int hibase) // extract open reading frames from specified the range // const int max_orf_size = 8192, max_overlap = 256, length_threshold = 50; const char ctnone=0, ctlrstart=1, ctlrstop=2, ctrlstart=3, ctrlstop=4, gcode[10][4] = 'A', 'T', 'G', ctlrstart, 'G', 'T', 'G', ctlrstart, 'T', 'A', 'A', ctlrstop, 'T', 'A', 'G', ctlrstop, 'T', 'G', 'A', ctlrstop, 'C', 'A', 'T', ctrlstart, 'T', 'T', 'A', ctrlstop, 'C', 'A', 'C', ctrlstart, 'C', 'T', 'A', ctrlstop, 'T', 'C', 'A', ctrlstop; char *orf[max_overlap], codon[4] = '\0','\0','\0','\0', codontype = ctnone; int i, orfpos, base = 3, cnt = 0; FILE *ifile, *ofile; memset(orf, 0, max_overlap * sizeof(char *)); // the file specified by user is not valid // if (! (ifile = fopen(ifile, "r"))) return -1; // skip genome description // while (fgetc(ifile)!= '\n');

21 // read the first two bases of the first codon // codon[0] = fgetc(ifile); codon[1] = fgetc(ifile); // open the output file // ofile = fopen(ofile, "w"); while ((codon[2] = fgetc(ifile))!= '<') // look at one codon after another // if (codon[2]!= '\n') if ((base >= lobase) && (base <= hibase)) // work within the specified range // for (i = 0; i < 10; i ++) // determine current codon type // if (! strncmp(codon, gcode[i], 3)) codontype = gcode[i][3]; for (i = 0; i < max_overlap; i ++) if ((orf[i]!= 0L) && (orf[i][0] == '\0')) // find end of the sequence first // for (orfpos = max_orf_size - 1; orf[i] [orfpos]!= '\0'; orfpos --); orf[i][orfpos]=complementary(codon[2]); if (((orfpos % 3) == 0) && (codontype == ctrlstart)) if ((max_orf_size-orfpos>length_threshold) && (exclude(base) == false)) fprintf(ofile, ">orf %d:c%d-%d", cnt, base, base + orfpos - max_orf_size); for (int j = orfpos; j < max_orf_size; j ++) if (! ((j - orfpos) % 70)) fputc('\n', ofile); fputc(orf[i][j], ofile); fputc('\n', ofile); cnt ++; free(orf[i]); orf[i] = 0L; else if (orf[i]!= 0L) for (orfpos=0; orf[i][orfpos]!= '\0'; orfpos ++); // end of sequence // orf[i][orfpos] = codon[2]; if (((orfpos % 3) == 2) && (codontype == ctlrstop)) if ((orfpos > length_threshold) && (exclude(base - orfpos) == false))

22 fprintf(ofile, ">orf %d:%d-%d", cnt, base - orfpos, base); for (int j=0; j<=orfpos; j ++) // file this sequence // if (! (j % 70)) fputc('\n', ofile); // break // fputc(orf[i][j], ofile); fputc('\n', ofile); cnt ++; free(orf[i]); orf[i] = 0L; fclose(ofile); fclose(ifile); if ((codontype==ctlrstart) (codontype==ctrlstop)) // find next free slot first // for (i = 0; orf[i]!= 0; i ++); // allocate & initialize some memory // orf[i] = (char *)malloc(max_orf_size); memset(orf[i], 0, max_orf_size); if (codontype == ctlrstart) // orf from left to right // for (int k = 0; k < 3; k ++) orf[i][k] = codon[k]; else if (codontype == ctrlstop) // orf from right to left // for (int k = 0; k < 3; k ++) orf[i][max_orf_size-1-k] = complementary(codon[k]); codontype = ctnone; base ++; // shift codon to the following offset // for (i = 0; i < 2; i ++) codon[i] = codon[i + 1]; // release incomplete sequences // for (i = 0; i < max_overlap; i ++) if (orf[i]!= 0L) free(orf[i]); return cnt; int main(int argn, char *argv[]) char *ifile = argv[1], *ofile = argv[2]; int i, first_base=atoi(argv[3]), last_base=atoi(argv[4]); FILE *pfile; if (argn == 6) // exclusion list provided // pfile = fopen(argv[5], "r");

23 for (i = 0; i < 4; i ++) // number of genes // *(((char *)(& listsize))+i) = fgetc(pfile); exclusionlist = (int *) malloc(listsize * 4); for (i = 0; i < listsize*4; i ++) // get position of the genes' start codon // *(((char *)exclusionlist)+i) = fgetc(pfile); fclose(pfile); printf("exclusion list loaded, %d genes\n", listsize); printf("searching for open reading frames...\n"); printf("%d orfs have been written to file\n", findorfs(ifile, ofile, first_base, last_base)); if (exclusionlist!= 0L) free(exclusionlist); return 0; score.cpp : #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <math.h> int base_index(char *seq, int order) int index = 0; // two bits for each base // const char base[4] = 'A', 'C', 'G', 'T'; for (int i = 0; i <= order; i ++) // order gives context size // for (int j = 0; j < 4; j ++) if (base[j] == seq[i]) // align base code to index // index = (j << (2*(order-i))); return index; double score_orf(char *seq, int order, double **markov) // scores given sequence, applying markov model // double score = 1; int base = 0; while (seq[base]!= '\0') if (base > (order - 1)) // apply relative markov probabilities // score *= markov[base % 3] [base_index(seq+base-order, order)]; base ++; // normalize result by calculating n-th root //

24 score = (double) pow(score, 1 / (double) base); return score; int main(int argn, char *argv[]) char orf[8192]; int order = atoi(argv[4]), base = 0; double *markov[3]; int msize = 4; // calculate size of model // for (int p = 0; p < order; p ++) msize *= 4; FILE *pfile = fopen(argv[3], "r"), *fout; for (int model = 0; model < 3; model ++) // allocate memory for markov model of third order // markov[model]=(double *)malloc(msize*sizeof(double)); for (int i = 0; i < msize; i ++) for (int j = 0; j < sizeof(double); j ++) // load transition probabilty in dirty way // ((char*)&(markov[model][i]))[j]=fgetc(pfile); fclose(pfile); // the file specified by caller is not valid // if (! (pfile = fopen(argv[1], "r"))) return -1; fout = fopen(argv[2], "w"); // output file // while ((orf[base] = fgetc(pfile))!= '<') // read in entire fasta descriptor line // while ((orf[++ base] = fgetc(pfile))!= '\n'); orf[base] = '\0'; fprintf(fout, "%s\t", orf); while (((orf[base] = fgetc(pfile))!= '<') && (orf[base]!= '>')) base ++; // terminate gene // orf[base] = '\0'; fprintf(fout, "%f\n", score_orf(orf, order, markov)); base = 0; fclose(fout); fclose(pfile); for (int mm = 0; mm < 3; mm ++) // release model memory // free(markov[mm]); return 0;

25 Quellen [1] Krengel U, Einführung in die Wahrscheinlichkeitstheorie und Statistik, 6. Auflage Vieweg [2] Anderson W, Continuous-Time Markov Chains, 1991 Springer Verlag [3] [4] [5] [6] Projekt : [7] Salzber S, Nucleic Acids Research, 1998, Vol 26 No 2, p , Microbial gene identification using interpolated Markov models