IFT3295 Démonstration 28 septembre 2011 Shift-And (avec erreurs)

Présentation au sujet: "IFT3295 Démonstration 28 septembre 2011 Shift-And (avec erreurs)"— Transcription de la présentation:

1 IFT3295 Démonstration 28 septembre 2011 Shift-And (avec erreurs)

2 Plan Présentation en détail de l'algorithme Shift-And (avec erreurs) Présentation de PROSITE

3 Shift-And (avec erreurs) Wu et Manber (1992) Base du logiciel agrep de Unix Recherche approximative d'un mot dans un texte Permet les insertions, les délétions et les substitutions de caractères

4 Shift-And (avec erreurs) Exemple : –Texte : aabaacaabacab –Mot : aabac (|mot| = m) –Alphabet : {a, b, c} Pré-traitement : –Pour chaque caractère x de l'alphabet, on construit un tableau de bits S x tel que S x [pos] = 1 si mot pos = x (pour 1 <= pos <= m)

5 Shift-And (avec erreurs) Pré-traitement : –Pour chaque caractère x de l'alphabet, on construit un tableau de bits S x tel que S x [pos] = 1 si mot pos = x (pour 1 <= pos <= m) 1 1 0 1 0 0 0 1 0 0 0 0 0 0 1 aabacaabac Mot : SaSa SbSb ScSc

6 Shift-And (avec erreurs) Soit k, le nombre d'erreurs que l'on veut permettre On doit construire (k+1) tableaux de bits R de taille m * (n+1) (où n = |texte|) (quoique la plupart des colonnes pourront être oubliées) : –R 0, R 1, …, R k

7 Shift-And (avec erreurs) Les tableaux R doivent être construits dans l'ordre croissant du nombre d'erreurs Regardons d'abord la construction de R 0, qui est l'équivalent de Shift-Or (recherche exacte)

8 Shift-And (avec erreurs) Au départ : aabaacaabacab 11111111111111 a0 a0 b0 a0 c0 R0R0

9 Shift-And (avec erreurs) Objectif : trouver 1 sur la ligne m match aabaacaabacab 11111111111111 a0 a0 b0 a0 c0 R0R0

10 Shift-And (avec erreurs) R 0 j+1 [i] = aabaacaabacab 11111111111111 a0 a0 b0 a0 c0 R0R0 1 si R 0 j [i-1] = 1 et mot i = texte j+1 0 sinon j+1j i i-1

11 Shift-And (avec erreurs) aabaacaabacab 11111111111111 a0 a0 b0 a0 c0 R0R0 R 0 j+1 [i] = 1 si R 0 j [i-1] = 1 et mot i = texte j+1 0 sinon j+1j i i-1

12 Shift-And (avec erreurs) aabaacaabacab 11111111111111 a01 a0 b0 a0 c0 R0R0 R 0 j+1 [i] = 1 si R 0 j [i-1] = 1 et mot i = texte j+1 0 sinon j+1j i i-1

13 Shift-And (avec erreurs) aabaacaabacab 11111111111111 a01 a0 b0 a0 c0 R0R0 R 0 j+1 [i] = 1 si R 0 j [i-1] = 1 et mot i = texte j+1 0 sinon j+1j i i-1

14 Shift-And (avec erreurs) aabaacaabacab 11111111111111 a01 a0 b0 a0 c0 R0R0 R 0 j+1 [i] = 1 si R 0 j [i-1] = 1 et mot i = texte j+1 0 sinon j+1j i i-1

15 Shift-And (avec erreurs) aabaacaabacab 11111111111111 a01 a00 b0 a0 c0 R0R0 R 0 j+1 [i] = 1 si R 0 j [i-1] = 1 et mot i = texte j+1 0 sinon j+1j i i-1

16 Shift-And (avec erreurs) aabaacaabacab 11111111111111 a01 a00 b00 a00 c00 R0R0 R 0 j+1 [i] = 1 si R 0 j [i-1] = 1 et mot i = texte j+1 0 sinon

17 Shift-And (avec erreurs) aabaacaabacab 11111111111111 a011 a001 b000 a000 c000 R0R0 R 0 j+1 [i] = 1 si R 0 j [i-1] = 1 et mot i = texte j+1 0 sinon

18 Shift-And (avec erreurs) Qu'est-ce que ça représente? aabaacaabacab 11111111111111 a011 a001 b000 a000 c000 R0R0 j+1j i i-1

19 Shift-And (avec erreurs) Qu'est-ce que ça représente? aabaacaabacab 11111111111111 a011 a001 b000 a000 c000 R0R0 j+1j i i-1

20 Shift-And (avec erreurs) Qu'est-ce que ça représente? aabaacaabacab 11111111111111 a011 a001 b000 a000 c000 R0R0 j+1j i i-1

21 Shift-And (avec erreurs) Qu'est-ce que ça représente? aabaacaabacab 11111111111111 a0110 a0010 b0001 a0000 c0000 R0R0 j+1j i i-1

22 Shift-And (avec erreurs) Qu'est-ce que ça représente? aabaacaabacab 11111111111111 a0110 a0010 b0001 a0000 c0000 R0R0 j+1j i i-1

23 Shift-And (avec erreurs) Qu'est-ce que ça représente? aabaacaabacab 11111111111111 a0110 a0010 b0001 a0000 c0000 R0R0 j+1j i i-1

24 Shift-And (avec erreurs) Cette transition peut être calculée bien plus efficacement R 0 j+1 = Rshift[R 0 j ] AND S j+1 où S j+1 est la table de pré- traitement du caractère qui est à la position j+1 dans le texte 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc

25 Shift-And (avec erreurs) Rshift : –On décale les bits à droite d'une position, on élimine le dernier bit et on insère 1 à gauche Rshift[00000] = 10000 Rshift[10001] = 11000

26 Shift-And (avec erreurs) R 0 j+1 = Rshift[R 0 j ] AND S j+1 aabaacaabacab a0 a0 b0 a0 c0 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc

27 Shift-And (avec erreurs) aabaacaabacab a0 a0 b0 a0 c0 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

28 Shift-And (avec erreurs) aabaacaabacab a01 a00 b00 a00 c00 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j 0 R 0 j+1 = Rshift[R 0 j ] AND S j+1

29 Shift-And (avec erreurs) aabaacaabacab a01 a00 b00 a00 c00 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

30 Shift-And (avec erreurs) aabaacaabacab a01 a00 b00 a00 c00 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

31 Shift-And (avec erreurs) aabaacaabacab a01 a00 b00 a00 c00 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

32 Shift-And (avec erreurs) aabaacaabacab a011 a001 b000 a000 c000 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j 0 R 0 j+1 = Rshift[R 0 j ] AND S j+1

33 Shift-And (avec erreurs) aabaacaabacab a011 a001 b000 a000 c000 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

34 Shift-And (avec erreurs) aabaacaabacab a011 a001 b000 a000 c000 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

35 Shift-And (avec erreurs) aabaacaabacab a011 a001 b000 a000 c000 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

36 Shift-And (avec erreurs) aabaacaabacab a0111 a0011 b0001 a0000 c0000 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j 0 R 0 j+1 = Rshift[R 0 j ] AND S j+1

37 Shift-And (avec erreurs) aabaacaabacab a0111 a0011 b0001 a0000 c0000 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

38 Shift-And (avec erreurs) aabaacaabacab a0110 a0010 b0001 a0000 c0000 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc j+1 j R 0 j+1 = Rshift[R 0 j ] AND S j+1

39 Shift-And (avec erreurs) aabaacaabacab a01101101101010 a00100100100000 b00010000010000 a00001000001000 c00000000000100 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc R 0 j+1 = Rshift[R 0 j ] AND S j+1

40 Shift-And (avec erreurs) Nous venons de voir la construction de R 0, qui est l'équivalent de Shift-Or (recherche exacte) Que fait-on pour R 1, R 2, …, R k ? Trois types d'erreurs sont permises : insertions, délétions et substitutions

41 Shift-And (avec erreurs) Insertion (1er cas) : a a b a a c a a b a c a b a j+1 i = 2 R 0 j+1 [2] = 0

42 Shift-And (avec erreurs) Insertion (1er cas) : a a b a a c a a b a c a b a a b j+1 i = 2 R 1 j+1 [2] = 1 R 0 j+1 [2] = 0

43 Shift-And (avec erreurs) Insertion (2e cas) : a a b a a c a a b a c a b a j+1 i = 2 R 0 j+1 [2] = 0

44 Shift-And (avec erreurs) Insertion (2e cas) : a a b a a c a a b a c a b a b a j+1 i = 2 R 0 j+1 [2] = 0 R 1 j+1 [2] = 1

45 Shift-And (avec erreurs) Délétion (1er cas) : a a b a a c a a b a c a b a b a a b j+1 i = 5 R 0 j+1 [5] = 0

46 Shift-And (avec erreurs) Délétion (1er cas) : a a b a a c a a b a c a b a b a a b j+1 i = 5 R 0 j+1 [5] = 0 R 1 j+1 [5] = 1

47 Shift-And (avec erreurs) Délétion (2e cas) : a a b a a c a a b a c a b a b a a b c j+1 i = 6 R 0 j+1 [6] = 0 R 1 j+1 [6] = 1

48 Shift-And (avec erreurs) Substitution (1er cas) : a a b a a c a a b a c a b a a b a c j+1 i = 5 R 0 j+1 [5] = 0

49 Shift-And (avec erreurs) Substitution (1er cas) : a a b a a c a a b a c a b a a b a c j+1 i = 5 R 0 j+1 [5] = 0 R 1 j+1 [5] = 1

50 Shift-And (avec erreurs) Substitution (2e cas) : a a b a a c a a b a c a b a a b c a j+1 i = 5 R 0 j+1 [5] = 0 R 1 j+1 [5] = 1

51 Shift-And (avec erreurs) On peut résumer tous ces cas dans la formule de transition suivante : R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j ] OR Rshift[R d-1 j+1 ] OR R d-1 j

52 Shift-And (avec erreurs) On peut résumer tous ces cas dans la formule de transition suivante : R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j OR R d-1 j+1 ] OR R d-1 j

53 Shift-And (avec erreurs) R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j OR R d-1 j+1 ] OR R d-1 j aabaacaabacab a0 a0 b0 a0 c0 R1R1

54 Shift-And (avec erreurs) R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j OR R d-1 j+1 ] OR R d-1 j aabaacaabacab a0 a0 b0 a0 c0 R1R1

55 Shift-And (avec erreurs) R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j OR R d-1 j+1 ] OR R d-1 j R 1 j+1 = Rshift[00000] AND 11010 OR Rshift[00000 OR 10000] OR 00000 = 10000 AND 11010 OR Rshift[10000] = 10000 OR 11000 = 11000 aabaacaabacab a0 a0 b0 a0 c0 R1R1 j+1 j

56 Shift-And (avec erreurs) aabaacaabacab a01101101101010 a00100100100000 b00010000010000 a00001000001000 c00000000000100 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc

57 R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j OR R d-1 j+1 ] OR R d-1 j R 1 j+1 = Rshift[00000] AND 11010 OR Rshift[00000 OR 10000] OR 00000 = 10000 AND 11010 OR Rshift[10000] = 10000 OR 11000 = 11000 aabaacaabacab a01 a01 b00 a00 c00 R1R1 j+1 j

58 Shift-And (avec erreurs) R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j OR R d-1 j+1 ] OR R d-1 j aabaacaabacab a01 a01 b00 a00 c00 R1R1 j+1 j

59 Shift-And (avec erreurs) R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j OR R d-1 j+1 ] OR R d-1 j R 1 j+1 = Rshift[11000] AND 11010 OR Rshift[10000 OR 11000] OR 10000 = 11100 AND 11010 OR Rshift[11000] OR 10000 = 11000 OR 11100 OR 10000 = 11100 aabaacaabacab a01 a01 b00 a00 c00 R1R1 j+1 j

60 Shift-And (avec erreurs) aabaacaabacab a01101101101010 a00100100100000 b00010000010000 a00001000001000 c00000000000100 R0R0 1 1 0 1 0 SaSa 0 0 1 0 0 SbSb 0 0 0 0 1 ScSc

61 R d j+1 = Rshift[R d j ] AND S j+1 OR Rshift[R d-1 j OR R d-1 j+1 ] OR R d-1 j R 1 j+1 = Rshift[11000] AND 11010 OR Rshift[10000 OR 11000] OR 10000 = 11100 AND 11010 OR Rshift[11000] OR 10000 = 11000 OR 11100 OR 10000 = 11100 aabaacaabacab a011 a011 b001 a000 c000 R1R1 j+1 j

62 Shift-And (avec erreurs) Il est inutile de garder toutes les colonnes des (k+1) tableaux en mémoire L'idée est de calculer la colonne (j+1) pour R 0, ensuite pour R 1, … et enfin pour R k Ensuite, on pourra oublier la colonne j de tous les tableaux lorsqu'on calculera la colonne (j+2)

63 Shift-And (avec erreurs) Complexité : –O(kn) lorsque le mot n'est pas trop grand avec k = nombre d'erreurs permises n = longueur du texte - O(kn * nbMotsMachine) sinon

64 PROSITE Base de données dédiée à l'identification de familles de protéines et de domaines Collection de motifs décrits en tant que patterns ou profils, reliés à la documentation décrivant les familles de protéines ou les domaines en question

65 PROSITE Pattern = expression régulière Les patterns sont identifiés à partir des alignements multiples des protéines d'une même famille

66 PROSITE Les patterns choisis représentent des motifs importants dans la séquence (10 à 20 acides aminés) –régions conservées qui ont une signification biologique importante (site catalytique, site de liaison, etc.) On peut identifier la fonction d'une protéine dont la séquence diffère beaucoup avec celles de la base de données si on y retrouve un certain pattern

67 PROSITE Syntaxe des patterns : –Chaque élément est séparé par - –x : n'importe quel –x(2) : x-x –x(2,4) : x-x, x-x-x ou x-x-x-x –[ALT] : Ala, Leu ou Thr –{AM} : n'importe quel sauf Ala, Met –< (au début) : doit être dans la partie N-terminale –> (à la fin) : doit être dans la partie C-terminale

68 PROSITE Exemples : –[AC]-x-V-x(4)-{ED} = [Ala or Cys]-any-Val-any-any-any-any-{any but Glu or Asp} –< A-x-[ST](2)-x(0,1)-V = Ala-any-[Ser or Thr]-[Ser or Thr]-(any or none)-Val qui doit être dans la partie N-terminale de la séquence