Gotoh-Algorithmus

Der Gotoh-Algorithmus berechnet das Alignment von zwei Sequenzen bei affinen Gapkosten. Er verwendet das Programmierparadigma der dynamischen Programmierung.

Affine GapkostenBearbeiten

Mit affinen Gapkosten bezeichnet man Kosten für Gaps in Alignments, welche sich durch eine lineare Funktion   beschreiben lassen. Dabei ist   die Länge des Gaps.   sind die Kosten für den Start eines neuen Gap, und   sind die Kosten für die Erweiterung eines existierenden Gaps um eine Stelle.

Biologisch können affine Gapkosten mehr Sinn als rein lineare Gapkosten ergeben, da man eine Insertion bzw. Deletion von mehreren Zeichen in bestimmten Zusammenhängen als wahrscheinlicher betrachten möchte als eine Insertion oder Deletion von einem einzigen Zeichen, z. B. beim Alignieren von cDNA gegen Genom-DNA (Gusfield, 1999).

Matrix-RekurrenzenBearbeiten

Spezifikation des Algorithmus durch Matrix-Rekurrenzen:

Initialisierung:

A[0, 0] = 0

B[0, 0] = 0

C[0, 0] = 0

A[i, 0] = C[i, 0] = -inf, 1 <= i <= m

A[0, j] = B[0, j] = -inf, 1 <= j <= n

B[i, 0] = g(i), 1 <= i <= m

C[0, j] = g(j), 1 <= i <= n

Rekursion:

 

 

 

  • u,v – Sequenzen über einem Alphabet  
  • m = Länge(u), n = Länge(v)
  • w(a, b),  - Ähnlichkeits-Funktion
  • gap_start – Kosten für den Beginn eines Gaps
  • gap_extend – Kosten für die Erweiterung eines Gaps
  • g(l) - affine Gap-Kosten Funktion  
  • -inf =  
  • A(i,j) – der optimale Similarity Score des optimalen Alignment des Präfixes u[1..i] von u und des Präfixes v[1..j] von v unter affinen Gapkosten
  • B(i,j) – der optimale Similarity Score des optimalen Alignment des Präfixes u[1..i] von u und des Präfixes v[1..j] von v, welches mit einem Gap in u endet
  • C(i,j) – der optimale Similarity Score des optimalen Alignment des Präfixes u[1..i] von u und des Präfixes v[1..j] von v, welches mit einem Gap in v endet

Der optimale Score des Alignments ist das Maximum von: A[m, n], B[m, n], C[m, n].

Implementation in Pseudo-Code:

 1 //Initialisierung der Matrizen
 2 a[0, 0] = 0;
 3 b[0, 0] = 0;
 4 c[0, 0] = 0;
 5 
 6 FOR i = 1; TO i <= m; i++;
 7     a[i, 0] = c[i, 0] = -inf;
 8     b[i, 0] = g(i);
 9 
10 FOR j = 1; TO j <= n; j++;
11     a[0, j] = b[0, j] = -inf;
12     c[0, j] = g(j);
13 
14 //Berechnen der restlichen Matrix
15 FOR i = 1; TO i <= m; i++;
16     FOR j = 1; TO j <= n; j++;
17         a[i, j] = get_max(a[i - 1, j - 1],
18                             b[i - 1, j - 1],
19                             c[i - 1, j - 1]) +
20                             match_or_mismatch(u[i - 1], v[i - 1]);
21         b[i, j] = get_max(a[i - 1, j] + gap_start,
22                             b[i - 1, j] + gap_extend,
23                             c[i - 1, j] + gap_start);
24         c[i, j] = get_max(a[i, j - 1] + gap_start,
25                             b[i, j - 1] + gap_start,
26                             c[i, j - 1] + gap_extend);
27 //Speichere Ergebnis
28 result = get_max(a[m, n], b[m, n], c[m, n]);
29 
30 function g(l)
31     return gap_start + (l - 1) * gap_extend;
32 
33 function match_or_mismatch(x, y)
34         if( x == y)
35             return match_score;
36         else
37             return mismatch_score;

Implementation in C# (ohne Fehlerbehandlung):

 1 using System;
 2 using System.IO;
 3 using System.Linq;
 4 
 5 
 6 namespace DnaAlignment
 7 {
 8     class Program
 9     {
10         const int GAP_PENALTY_START = -10;
11         const int GAP_PENALTY_EXTEND = -0.5;
12         const int MIN_INF = int.MinValue + 100; //Pseudo-Unendlich
13         const int MATCH = 3;
14         const int MISMATCH = -3;
15         static void Main(string[] args)
16         {
17             using (StreamReader reader = File.OpenText(args[0]))
18                 while (!reader.EndOfStream)
19                 {
20                     string line = reader.ReadLine();
21                     if (null == line)
22                         continue;
23                     string[] sSplit = line.Split('|');
24                     if (sSplit.Count() != 2)
25                         continue;
26                     string seqA = sSplit[0].Trim(' ');
27                     string seqB = sSplit[1].Trim(' ');
28 
29                     //Initsialisiere Matrizen
30                     int[,] a = new int[seqA.Length + 1, seqB.Length + 1];
31                     int[,] b = new int[seqA.Length + 1, seqB.Length + 1];
32                     int[,] c = new int[seqA.Length + 1, seqB.Length + 1];
33                     a[0, 0] = 0;
34                     b[0, 0] = 0;
35                     c[0, 0] = 0;
36                     for (int i = 1; i <= seqA.Length; i++)
37                     {
38                         a[i, 0] = c[i, 0] = MIN_INF;
39                         b[i, 0] = G(i);
40                     }
41                     for (int j = 1; j <= seqB.Length; j++)
42                     {
43                         a[0, j] = b[0, j] = MIN_INF;
44                         c[0, j] = G(j);
45                     }
46                     //Berechne Matrizen
47                     for (int i = 1; i <= seqA.Length; i++)
48                     {
49                         for (int j = 1; j <= seqB.Length; j++)
50                         {
51                             a[i, j] = Get_Max_Value(
52                                         a[i - 1, j - 1],
53                                         b[i - 1, j - 1],
54                                         c[i - 1, j - 1]) +
55                                         Match_Or_Mismatch(seqA[i - 1], seqB[j - 1]);
56                             b[i, j] = Get_Max_Value(
57                                         a[i - 1, j] + GAP_PENALTY_START,
58                                         b[i - 1, j] + GAP_PENALTY_EXTEND,
59                                         c[i - 1, j] + GAP_PENALTY_START);
60                             c[i, j] = Get_Max_Value(
61                                         a[i, j - 1] + GAP_PENALTY_START,
62                                         b[i, j - 1] + GAP_PENALTY_START,
63                                         c[i, j - 1] + GAP_PENALTY_EXTEND);
64                         }
65                     }
66                     Console.WriteLine(Get_Max_Value(a[seqA.Length, seqB.Length],
67                                         b[seqA.Length, seqB.Length],
68                                         c[seqA.Length, seqB.Length]));
69                 }
70         }
71         private static int G(int index)
72         {
73             return GAP_PENALTY_START + (index - 1) * GAP_PENALTY_EXTEND;
74         }
75         private static int Get_Max_Value(int a, int b, int c)
76         {
77             return Math.Max(Math.Max(a, b), c);
78         }
79         private static int Match_Or_Mismatch(char a, char b)
80         {
81             return a == b ? MATCH : MISMATCH;
82         }
83     }
84 }

EffizienzBearbeiten

Die Laufzeit und der Speicherplatzbedarf des Algorithmus liegen in O(nm). Dies ist eine Verbesserung zum Needleman-Wunsch-Algorithmus, welcher für beliebige Gapkosten eine Laufzeit von   hat. Im schlimmsten Fall ist die Matrix quadratisch ( ), was beim Needleman-Wunsch-Algorithmus zu einer kubischen Laufzeit von   führt. Durch den Gotoh-Algorithmus mit seinen linearen Gap-Kosten verringert sich die Komplexität auf  .

Wenn nur der Score des optimalen Alignments berechnet werden soll, können alle Matrizen auch spalten- bzw. zeilenweise berechnet werden, da jeder Eintrag nur von der vorherigen Spalte bzw. Zeile abhängt. Also sinkt der Speicherplatzbedarf auf  .

Der Gotoh-Algorithmus kann auch mit der Divide-and-Conquer-Methode implementiert werden, so dass das optimale Alignment mit linearem Platzbedarf berechnet werden kann. Siehe Hirschberg-Algorithmus.

LiteraturBearbeiten

WeblinksBearbeiten

EinzelnachweiseBearbeiten

  1. Saad Mneimneh: Affine gap penalty function, multiple sequence alignment. (PDF) Abgerufen am 15. August 2015 (englisch).