Alignement d une séquence avec une banque. Thierry Lecroq Université de Rouen 1

Dimension: px

Commencer à balayer dès la page:

Download "Alignement d une séquence avec une banque. Thierry Lecroq Université de Rouen 1"

Gauthier Richard
il y a 8 ans
Total affichages :

1 Alignement d une séquence avec une banque 1

2 Problématique générale Localiser des alignements significatifs entre une séquence requête x dans une banque de p séquences Y = {y 0,y 1,,y p 1 }. La solution par programmation dynamique en O(mn) si m = x et n = Σ y i est trop coûteuse. Il faut donc développer des heuristiques. 2

3 FASTA (alignement global avec brêche) [Pearson & Lipman 1988] On traite les y i séparément les unes à la suite des autres. On considère deux entiers : k,l > 0. 3 phases : localisation des facteurs de longueur l de x dans y ; sélection de la diagonale d contenant le plus de facteurs de longueur l ; alignement par programmation dynamique sur une bande de largeur 2k autour de la diagonale d. 3

3 phases : localisation des facteurs de longueur l de x dans y ; sélection de la diagonale d

4 n = y On définit la diagonale d sur { 1,0,1,,m 1} x { 1,0,1,,n 1} comme étant l ensemble des couples (i,j) tels que j i = d. 4

5 On définit l ensemble Z l par Z l = { (i,j) 0 i m l, 0 j n l et x[i..i+l 1] = y[j..j+l 1]} Autrement dit, l ensemble Z l contient tous les couples (i,j) tel que le facteur de longueur l qui commence à la position i sur x est égal au facteur de longueur l qui commence à la position j sur y. 5

6 Pour chaque diagonale m d n on considère le nombre d éléments de Z l se trouvant sur cette diagonale : compte[d] = card { (i,j) Z l j i = d } 6

7 Pour calculer les valeurs de la table compte : on associe de manière bijective un rang à chaque lettre a de l alphabet A : 0 rang(a) card A 1 pour a A 7

8 On pose l 1 code(w[0.. l 1]) = Σ rang(w[i]) x (card A) i i = 0 pour w A* et w = l. 8

9 Ainsi code(w[i..i+l 1]) = code(w[i 1..i+l 2]) / card A + rang(w[i+l 1]) x (card A) l 1 9

10 Les codes des facteurs de longueur l de x sont calculés en une seule passe et on accumule les facteurs dans une table position à (card A) l éléments : position[c] = { i code(x[i.. i+l 1]) = c } 10

11 algo HACHAGE(x,m,l) pour c 0 à (card A) l 1 faire position[c] exp 1 code 0 pour i 0 à l 1 faire code code + rang(x[i]) x exp exp exp x card A position[code] { 0 } pour i l à m 1 faire code code div card A + rang(x[i]) x exp position[code] position[code] U { i l+1 } retourner position 11

A position[code] { 0 } pour i l à m 1 faire code code div card A +

12 algo DIAGONALE(x,m,y,n,l) pour d m à n faire compte[d] 0 exp 1 code 0 pour j 0 à l 1 faire code code + rang(y[j]) x exp exp exp x card A pour chaque i position[code] faire compte[ i] 1 pour j l à n 1 faire code code div card A + rang(y[j]) x exp pour chaque i position[code] faire compte[j l+1 i] compte[j l+1 i] + 1 retourner compte 12

faire compte[ i] 1 pour j l à n 1 faire code code div card A + rang(y[j]) x exp

13 Il suffit alors de repérer la diagonale d ayant le compte le plus élevé pour ensuite effectuer un alignement par programmation dynamique autour de cette diagonale. 13

14 algo ALIGNEMENT BANDE(x,m,y,n,d,k) i max { 1, d 1 k} i min { d 1+k,m 1} j max { 1,d 1 k} j min {d 1+k,n 1} c g pour i i à i faire T[i, 1] c c c+g c g pour j j à j faire T[ 1,j] c c c+g pour i 0 à m 1 faire pour j i+d k à i+d+k faire si 0 j n 1 alors T[i,j] T[i 1,j 1] + Sub(x[i],y[j]) si j i 1 d k alors T[i,j] min { T[i,j],T[i,j 1]+g } si j i+1 d k alors T[i,j] min { T[i,j],T[i 1,j]+g } retourner T 14

1 faire pour j i+d k à i+d+k faire si 0 j n 1 alors T[i,j] T[i 1,j 1] + Sub(x[i],y[j]) si j i 1 d k

15 Exemple x = YWCQPGK, m = 7 y = LAWYQQKPGKA, n = 11 l = 2 k = 2 card A = 20 a A C G K L P Q W Y rang(a)

16 code(x[i..i+l 1]) GK PG QP CQ WC YW x[i..i+l 1] i position[c] c code(y[j..j+l 1)] KA GK PG KP QK QQ YQ WY AW LA y[j..j+l 1] j

.i+l 1] 5 4 3 2 1 0 i 0 2 3 5 4 1 position[c] 379 261 253 165

17 code(y[j..j+l 1)] KA GK PG KP QK QQ YQ WY AW LA y[j..j+l 1] j 2 compte [d] d

18 T L A W Y Q Q K P G K A 1 0 Y 1 W 2 C 3 Q 4 P 5 G 6 K 18

19 T L A W Y Q Q K P G K A 1 0 Y 1 W 2 C 3 Q 4 P 5 G 6 K 19

20 K G P Q C W Y A K G P K Q Q Y W A L T

17 14 11 8 5 W 1 15 12 9 8 5 Y 0 15 12 9 6 3 1

21 K G P Q C W Y A K G P K Q Q Y W A L T

22 YWCQ PGK AWYQQKPGK YWC Q PGK AWYQQKPGK YW CQ PGK AWYQQKPGK 22

23 l : ktup 6 pour les acides nucléiques 2 pour les acides aminés 23

24 BLAST (Alignement local sans brêche) [Altschul et al 1990] On considère deux entiers k et l. On considère le score s défini par u 1 s(u,v) = Σ Sub(u[i],v[i]) pour deux mots u et v de même longueur. i=0 24

25 On va construire l ensemble des voisins fréquentables de tous les facteurs de x de longueur l. Fact l (x) = { w w fact x et w = l } V k (Fact l (x)) = { z A l s(w,z) k 25 pour w Fact l (x) }

26 L ensemble V k (Fact l (x)) peut être construit en temps O(card V k (Fact l (x)) ) si on dispose pour chaque lettre a A de la liste des lettres de l alphabet triée dans l ordre décroissant des scores de leur substitution à a. Les éléments de cette liste sont des couples (b, Sub(a,b)) lettre score 26

27 Ces listes sont rangées dans une table à deux dimensions notée L. 27

28 algo GENERER VOISINS(l) V seuil[l 1] k pour i 0 à m l faire pour j l 1 à 1 faire seuil[j 1] seuil[j] score(l[x[i+j],0]) GV(i,ε,0,0,0) retourner V 28

29 algo GV (i,v,j,p,t) si j = l alors V V U { v } sinon si t < card A alors c L[x[i ],t] si p + score[c] seuil[j ] alors v v lettre[c] GV(i +1,v[0..j ],j +1,p+score[c],0) GV(i,v[0..j 1],j,p,t+1) 29

30 L appel GV(i,ε,0,0,0) calcule tous les voisins fréquentables de x[i..i+l 1]. Au début de GV(i,v,j,p,t) p = s(v[0..j 1],x[i j..i 1]) k et on essaie d étendre v par la lettre de L[x[i ],t]. 30

31 L A (A,5) (E, 2) (K, 3) (Q, 3) (R, 4) (Y, 5) E (E,5) (A, 2) (K, 3) (Q, 3) (R, 3) (Y, 5) K (K,5) (A, 3) (E, 3) (K, 3) (Q, 3) (Y, 5) Q (Q,5) (A, 3) (E, 3) (K, 3) (R, 3) (Y, 5) 31

32 x = EAAQK, k = 8, l = 3 seuil[2] 8 i (0,1,2) j (2,1) 32

33 i = 0, j = 2, seuil[1] 3 i = 0, j = 1, seuil[0] 2 GV(0,ε,0,0,0) GV(1,E,1,5,0) GV(2,EA,2,10,0) GV(3,EAA,3,15,0) GV(2,EA,2,10,1) GV(3,EAE,3,8,0) GV(2,EA,2,10,2) EAK,7 < seuil[j =2] GV(1,E,1,5,1) GV(2,EE,2,3,0) GV(3,EEA,3,8,0) GV(2,EE,2,3,1) EEE,1 < seuil[j =2] GV(1,E,1,5,2) EK,2 < seuil[j =1] GV(0,ε,0,0,1) GV(1,A,1, 2,0) GV(2,AA,2,3,0) GV(3,AAA,3,8,0) GV(2,AA,2,3,1) AAE,1 < seuil[j =2] GV(1,A,1, 2,1) AE, 4 < seuil[j =1] GV(0,ε,0,0,2) K, 3 < seuil[j =0] 33

34 GV(1,ε,0,0,0) GV(2,A,1,5,0) GV(3,AA,2,10,0) GV(4,AAQ,3,15,0) GV(3,AA,2,10,1) AAA,7 < seuil[j =2] GV(2,A,1,5,1) GV(3,AE,2,3,0) GV(4,AEQ,3,8,0) GV(3,AE,2,3,1) AEA, 1 < seuil[j =2] GV(2,A,1,5,2) AK,2 < seuil[j =1] GV(1,ε,0,0,1) GV(2,E,1, 2,0) GV(3,EA,2,3,0) GV(4,EAQ,3,8,0) GV(3,EA,2,3,1) EAA,0 < seuil[j =2] GV(2,E,1, 2,1) EE, 4 < seuil[j =1] GV(1,ε,0,0,2) K, 3 < seuil[j =0] 34

35 GV(2,ε,0,0,0) GV(3,A,1,5,0) GV(4,AQ,2,10,0) GV(5,AQK,3,15,0) GV(4,AQ,2,10,1) AQA,7 < seuil[j =2] GV(3,A,1,5,1) AA,2 < seuil[j =1] GV(2,ε,0,0,1) GV(3,E,1, 2,0) GV(4,EQ,2,3,0) GV(5,EQK,3,8,0) GV(4,EQ,2,3,1) EQA,0 < seuil[j =2] GV(3,E,1, 2,1) EA, 5 < seuil[j =1] GV(2,ε,0,0,2) K, 3 < seuil[j =0] 35

36 Ensuite on construit un AFD (automate fini déterministe) A tel que L(A) = A*V k (Fact l (x)) et on analyse y avec A. 36

37 Puis on étend (par programmation dynamique) vers la droite et vers la gauche les facteurs de y contenant des éléments de V k (Fact l (x)). 37

38 k : T (word score threshold) l : W (word size) 38

39 Différentes versions BLASTP BLASTN BLASTX requête protéine nucléique protéine banque protéine nucléique nucléique (traduction) TBLASTN TBLASTX nucléique (traduction) nucléique (traduction) protéine 39 nucléique (traduction)

40 Améliorations PSI BLAST : Position Specific Iterative : crée un profil pendant la recherche et le raffine au fur et à mesure des itérations. 40

Documents pareils

Jean-Philippe Préaux http://www.i2m.univ-amu.fr/~preaux

Jean-Philippe Préaux http://www.i2m.univ-amu.fr/~preaux Colonies de fourmis Comment procèdent les colonies de fourmi pour déterminer un chemin presque géodésique de la fourmilière à un stock de nourriture? Les premières fourmis se déplacent au hasard. Les fourmis