Alignement de séquences biologiques

(1)

Alignement de séquences biologiques

Nadia El-Mabrouk

Inspiré de:

An introduction de Bioinformatics Algorithms – www.bioalgorithms.info Neil C. Jones and Pavel A. Pevzner

(2)

Motivation

• Identification des gènes: Est-ce qu’un ORF est un gène? S’il existe un gène similaire dans un autre organisme, alors de forte chance que l’ORF représente un gène.

• Déduire la fonctionnalité d’un gène grâce à sa similarité avec un gène de fonction connue.

• Regrouper les gènes en familles d’homologues.

• Étudier l’évolution des espèces...

(3)

Alignement global/ local - Recherche

• Alignment Global

• Alignement local— trouver des régions conservées

• Recherche – trouver la position d’un gène

--T—-CC-C-AGT—-TATGT-CAGGGGACACG—A-GCATGCAGA-GAC | || | || | | | ||| || | | | | |||| | AATTGCCGCC-GTCGT-T-TTCAG----CA-GTTATG—T-CAGAT--C

tccCAGTTATGTCAGgggacacgagcatgcagagac ||||||||||||

aattgccgccgtcgttttcagCAGTTATGTCAGatc

tcccagtTATGTCAGGggacacgagcatgcagagac ||| |||||

TAT-TCAGG

(4)

Exemple

• Un alignement de séquence réalisé par ClustalW entre deux protéines humaines.

http://fr.wikipedia.org/wiki/Alignement_de_s%C3%A9quences

(5)

Modèle sous-jacent: mutations ponctuelles

X Y

Séquence ancestrale inconnue

Séquences observées

Exemple:

Substitution de caractères

G C G A C G I I

GCG ACG

Séquences observées ACG

A G

(6)

Alignement global

Alignement : matrice 2 * k ( k > m, n )

A T -- C T G A

-- T G C T A

v

w A

AT CT GATG T GCAT A C

v :w : m = 8

n = 7

4 matches 2 insertions 3 deletions

2 séquences v et w:

An introduction de Bioinformatics Algorithms – www.bioalgorithms.info

--

T --

G C

1 mismatch

(7)

Alignement global

Un alignement de v et w est une matrice A de 2 lignes et k colonnes, avec k ≥ max (n,m) telle que

• Pour tous 1 ≤i ≤2 et 1 ≤j ≤k, A[i,j] est dans {A,C,G,T,-};

• v (respectivement w) est obtenu en concaténant,

dans l’ordre, les lettres {A,C,G,T} de la 1ère (respec. la 2ème) ligne de A;

• Il n’existe aucune colonne j telle que A[1,j]=A[2,j]=“-”.

v :w : m = 8

n = 7

(8)

Alignement sans indels- Distance de Hamming

Deux séquences d’ ADN v et w :

v :

• Distance de Hamming : d_H(v, w) = 8

C’est beaucoup, bien que les séquences soient très similaires.

AT AT AT AT A T AT AT AT w :

(9)

Alignement avec indels

v : AT AT AT AT A T AT AT AT w : --

-- En décalant d’une seule position:

• La distance d’édition ou de Levenshtein (1966) D(v, w) = 2.

• D(v, w) = MIN d’opération élémentaires pour transformer v en w

(10)

Distance d’édition versus Hamming

V = ATATATAT W = TATATATA

Dist. de Hamming compare toujours i^-ème lettre de v et i^-ème lettre de w

Dist. de Hamming:

D(v, w)=8

Calculer distance de Hamming : trivial.

(11)

Dist. de Hamming: Distance d’Édition:

D(v, w)=8 D(v, w)=2

Calculer Hamming distance Calculer dist. d’édition tâche triviale tâche non-triviale

Comment trouver quel j va avec quel i ???

W = TATATATA -

Un seul shift et tout s’aligne

V = - ATATATAT

Dist. d’édition peut comparer i^-ème lettre of v et j^-ème lettre de w

Distance d’édition versus Hamming

Dist. de Hamming compare toujours i^-ème lettre de v et i^-ème lettre de w

V = ATATATAT W = TATATATA

(12)

Plus longue sous-séquence commune(LCS) – Alignement ignorant les Mismatches

• Étant donné deux mots

v = v₁ v₂…v_m et w = w₁ w₂…w_n

• LCS de v et w: séquence de positions dans

v: 1 < i₁ < i₂ < … < i_t < m et dans

w: 1 < j₁ < j₂ < … < j_t < n

telque la i_k lettre de v est égale à la j_k lettre de w pour tout 1 ≤ k ≤ t, et t est maximal

(13)

LCS: Exemple

A T ^-- C T G A T C

-- T G C T ^-- A ^-- C

v w

--

A 1

2

0 1

2 2

3 3

4 3

5 4

5 5

6 6

6 7

7 8

i:

j :

Matches en rouge positions dans v:

positions dans w:

2 < 3 < 4 < 6 < 8 1 < 3 < 5 < 6 < 7

Chemin dans une grille 2D: Graphe d’édition

0 0

(0,0)(1,0)(2,1)(2,2)(3,3)(3,4)(4,5)(5,5)(6,6)(7,6)(8,7)

(14)

T G C A T A C

1 2 3 4

5 6 7 0 i

A T C T G A T C

0 1 2 3 4 5 6 7 8

j

A T -- C T G A T C

-- T G C T -- A -- C

v w

-- A 1

2

0 1

2 2

3 3

4 3

5 4

5 5

6 6

6 7

7 8

i : j :

0 0

(15)

T G C A T A C

1 2 3 4

5 6 7 0 i

A T C T G A T C

0 1 2 3 4 5 6 7 8

j

A T -- C T G A T C

-- T G C T -- A -- C

-- A

LCS: Trouver un chemin avec un maximum

d’arêtes diagonales.

(16)

Comment calculer LCS (v,w)?

Pour chaques préfixes:

v[1,i] = v₁ … v_i de v et w[1,j] =w₁ … w_jde w On considère le dernier caractère de v_i et w_j . 3 cas possibles

• vi et wj sont alignés  lcs(v[1,i] ,w[1,j]) = lcs(v[1,i-1], w[1,j-1]) +1

• vi n’est pas aligné lcs(v[1,i],w[1,j]) = lcs(v[1,i-1], w[1,j])

• w n’est pas aligné lcs(v[1,i],w[1,j]) = lcs(v[1,i], w[1,j-1])

(17)

Programmation dynamique!

Pour résoudre un problème (ici lcs(v,w)),on a besoin de résoudre tous les sous-problèmes (ici lcs(v[1,i] ,w[1,j]) pour tous les i et j).

Pour simplifier, notons lcs(i,j) au lieu de lcs(v[1,i] ,w[1,j])

lcs (i,j) = max lcs (i-1,j) lcs (i,j-1)

lcs (i-1, j-1) + 1 si v_i = w_j

Conditions initiales: lcs (i,0) =lcs (0,j) =0

(18)

Graphe d’édition/Table de programmation dynamique

T G C A T A C

1 2 3 4

5 6 7 0 i

A T C T G A T C

0 1 2 3 4 5 6 7 8

j

(19)

Graphe d’édition/Table de programmation dynamique

2 3

4 5

6

7

T G C A T A C

1 0

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

(20)

Graphe d’édition/Table de programmation dynamique

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

T G C A T A C

1 0

(i,j)

(i-1,j) (i-1,j-1)

(i,j-1)

+1 +0

+0

2 3

4 5

6

(21)

Graphe d’édition/Table de programmation dynamique

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

T G C A T A C

1 0

2 3

4 5

6

7

(22)

Graphe d’édition/Table de programmation dynamique

0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

T G C A T A C

1 0

2 3

4 5

6

(23)

Graphe d’édition/Table de programmation dynamique

0 0 0 0 0 0 0 0 0

0 0 1 1 1 1 1 1 1

0 0 1 1 1 2 2 2 2

0 0 1 2 2 2 2 2 3

0 1 1 2 2 2 3 3 3

0 1 2 2 3 3 3 4 4

0 1 2 2 3 3 4 4 4

0 1 2 3 3 3 4 4 5

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

T G C A T A C

1 0

2 3

4 5

6

7

(24)

Graphe d’édition/Table de programmation dynamique

0 0 0 0 0 0 0 0 0

0 0 1 1 1 1 1 1 1

0 0 1 1 1 2 2 2 2

0 0 1 2 2 2 2 2 3

0 1 1 2 2 2 3 3 3

0 1 2 2 3 3 3 4 4

0 1 2 2 3 3 4 4 4

0 1 2 3 3 3 4 4 5

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

T G C A T A C

1 0

2 3

4 5

6

(25)

Graphe d’édition/Table de programmation dynamique

0 0 0 0 0 0 0 0 0

0 0 1 1 1 1 1 1 1

0 0 1 1 1 2 2 2 2

0 0 1 2 2 2 2 2 3

0 1 1 2 2 2 3 3 3

0 1 2 2 3 3 3 4 4

0 1 2 2 3 3 4 4 4

0 1 2 3 3 3 4 4 5

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

T G C A T A C

1 0

2 3

4 5

6

7

(26)

Graphe d’édition/Table de programmation dynamique

0 0 0 0 0 0 0 0 0

0 0 1 1 1 1 1 1 1

0 0 1 1 1 2 2 2 2

0 0 1 2 2 2 2 2 3

0 1 1 2 2 2 3 3 3

0 1 2 2 3 3 3 4 4

0 1 2 2 3 3 4 4 4

0 1 2 3 3 3 4 4 5

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

T G C A T A C

1 0

2 3

4 5

6

(27)

A T -- C T G A T C

-- T G C T -- A -- C

-- A

0 0 0 0 0 0 0 0 0

0 0 1 1 1 1 1 1 1

0 0 1 1 1 2 2 2 2

0 0 1 2 2 2 2 2 3

0 1 1 2 2 2 3 3 3

0 1 2 2 3 3 3 4 4

0 1 2 2 3 3 4 4 4

0 1 2 3 3 3 4 4 5

i A T C T G A T C

0 1 2 3 4 5 6 7 8

j

T G C A T A C

1 0

2 3 4 5

6

7

(28)

Distance d’édition

• D(i,j) = MIN d’erreurs (substitutions,

insersions, suppressions) entre v[1,j] et w[1,i]

v :w : m = 8

n = 7

i=6 j=7

(29)

Distance d’édition

• 3 cas possibles:

1. V_jest impliqué dans un indel:

AT CT GAT T GCAT A v :w :

j=7

i=6

(30)

Distance d’édition

1. V_jest impliqué dans un indel:

AT CT GAT T GCAT A - v :w :

j-1=6

i=6

[ ]

(31)

Distance d’édition

2. W_iest impliqué dans un indel:

j=7

i=6

(32)

Distance d’édition

2. W_iest impliqué dans un indel:

AT CT GAT - T GCAT A v :w :

j=7

i-1=5

[ ]

(33)

Distance d’édition

3. V_i et W_isont alignés:

j=7

i=6

(34)

Distance d’édition

3. V_i et W_isont alignés:

j-1=6

i-1=5

[ ]

(35)

Distance d’édition

insersions, suppressions) entre v[1,i] et w[1,j]

D (i,j) = max

D (i-1,j) +1 D (i,j-1) +1

D (i-1, j-1) + 1 si v_i ≠ w_j D (i-1, j-1) si v_i = w_j

Conditions initiales: D (i,0) =i; D(0,j) =j

(36)

D G T C A G G T 0 1 2 3 4 5 6 7 C 1

A 2 T 3 A 4

G 5 T 6

G 7

1 2 2 3

G C

T C A G 4

G 5

T 6 A 2 2 3 2 3 4 5 T 3 2 3 3 3 4 4 A 4 3 3 3 4 4 5

4 4 4 4 3 4 5

5 4 5 5 4 4 4

6 5 5 6 5 4 5

- T G

G T

- G

G A

A -

C T

T A

G C

-

(37)

Algorithme

distEdit(v,w)

for i  1 to n D(i,0)  i

for j  1 to m D(0,j)  j for i  1 to n

for j  1 to m

D(i-1,j) +1 D(i,j)  max D(i,j-1) +1

D(i-1, j-1) if v_i = w_j

D(i-1, j-1) + 1, if v_i ≠ w_j

“ “ if D(i,j) = D(i-1,j) b_i,j  “ “ if D(i,j) = D(i,j-1)

“ “ otherwise return (D(n,m), b)

{ {

{

(38)

Complexité

• Temps constant pour chaque chaque i,j avec 1≤i ≤n et 1≤j ≤m

• Temps proportionnel à O(nm) pour remplire la table de n lignes et m colonnes.

• Complexité en espace: également O(nm).

(39)

Distance d’édition avec pondération des opérations

• On peut associer un score à chaque opération:

– d pour une insertion/délétion – r pour une substitution

– e pour un match

• d>0, r>0 et e≥0. En général e=0.

• Il faut que r<2d, sinon jamais de substitutions.

• Relations de récurrence:

D(i,0) = i x d; D(0,j) = j x d

D(i,j) = min [D(i,j-1)+d, D(i-1,j)+d, D(i-1,j-1)+p(i,j)]

où p(i,j) = e si vi = wj et p(i,j) =r sinon.

(40)

Distance d’édition généralisée

• Le score d dépend des caractères. Par exemple, remplacer une purine par une pyrimidine plus

coûteux que remplacer une purine par une purine

D(i,0) = S_{1≤k ≤i} d_(v_i,-); D(0,j) = S_{1≤k ≤j} d_(-,w_j₎ D(i,j) = min [D(i,j-1)+ d(-,wj), D(i-1,j)+d(vi ,-),

D(i-1,j-1)+ d_(v_i_,w_j_)]

• Si d est une distance, alors D est une distance

(séparation, symétrie et inégalité triangulaire)

(41)

Similarité entre deux séquences

• Plutôt que de mesurer la différence entre deux séquences, mesurer leur degré de similarité

• P(a,b): score de l’appariement (a,b): Positif si a=b et ≤0 sinon. V(i,j): valeur de l’alignement optimal de v[1,i] et w[1,j]

V(i,0) = S_{1≤k ≤i}_P(v_i,-); V(0,j) = S_{1≤k ≤j}_P(-,w_j₎ V(i,j) = max [V(i,j-1)+ P(-,w_j), V(i-1,j)+P(v_i ,-),

V(i-1,j-1)+ P(v_i,w_j)]

• Ça s’appelle: Algorithme de Needleman-Wunch.

(42)

Score simple

• Lorsque mismatches pénalisés par –μ, indels

pénalisés by –σ, et matches gratifiés d’un +Ɛ, le score d’un alignement est:

Ɛ(#matches) – μ(#mismatches) – σ (#indels)

• Exemple: Ɛ =2; μ = σ = 1;

A T -- C T G A

-- T G C T A

v

w A

--

T --

G C

Score = 2x4-1x6=2

4 matches 2 insertions 3 deletions 1 mismatch

(43)

Matrice de score pour les AA: Blosum50

(44)

Alignement local: Algorithme de Smith- Waterman

• Alignement global: Plus long chemin entre (0,0) et (n,m).

• Alignement local: Plus long chemin entre n’importe quelles arêtes (i,j) et (i’, j’) du graphe d’édition.

• Quelle mesure de distance/similarité?

– Distance d’édition: Alignement vide! Pas de sens.

– Mesure de similarité avec scores négatifs

(45)

Alignement local: Exemple

Input : Deux séquences v, w et une matrice de scores de similarité d.

Output : Trouver deux facteurs de v et w dont le score de similarité est maximal parmi tous les facteurs

possibles.

Global alignment

Local alignment

(46)

Pourquoi faire de l’alignement local?

• Deux gènes dans deux espèces peuvent être similaires sur de courtes régions, mais

dissimilaires dans l’ensemble.

• Exemple:

– Les gènes Homeobox ont une courte région appelée « homeodomain » très conservées.

– Un alignement global ne trouverait pas cette région.

(47)

Solution directe

En temps O(n⁴): Il y a n x n arêtes dans le graphe d’éditions  n² arêtes sources et n² arêtes cible.

Calculer la valeur de similarité maximale d’un chemin prend un temps O(n²).

Global alignment

Local alignment

(48)

Solution directe

En temps O(n⁴): Il y a n x n arêtes dans le graphe d’éditions  n² arêtes sources et n² arêtes cible.

Calculer la valeur de similarité maximale d’un chemin prend un temps O(n²).

(49)

Solution: Parcours gratuits

Vertex (0,0)

The dashed edges represent the free rides from (0,0) to every other node.

Yeah, a free ride!

(50)

Alignement local: Récurrences

• La plus grande valeur V(i,j) est le score du meilleur alignement local.

• Récurrences:

0

V(i,j) = max V(i-1,j-1) + δ (v_i, w_j) V(i-1,j) + δ (v_i, -) V(i,j-1) + δ (-, w_j)

{

Seules différences avec l’alignement

global. Réinitialisation à 0. Possibilité

d’arrivée à chaque arête par un parcours gratuit!

V(i,0) = V(0,j) = 0

(51)

Alignement local: Récurrences

• Récurrences:

• Remplire la table de programmation dynamique

• Rechercher une case (i,j) contenant une valeur maximale.

• Démarrer à (i,j) et remonter les pointeurs jusqu’à tomber sur un 0.

0

V(i,j) = max V(i-1,j-1) + δ (v_i, w_j) V(i-1,j) + δ (v_i, -) V(i,j-1) + δ (-, w_j)

{

V(i,0) = V(0,j) = 0

(52)

D G T C A G C C 0 0 0 0 0 0 0 0 C 0

A 0 T 0 A 0

G 0 T 0

G 0

0 0 2 1

G C

T C A G 0

C 2

C 2 A 0 0 1 4 3 2 1

0 2 1 3 3 2 1

0 1 1 3 2 2 1

2 1 0 2 5 4 3

1 4 3 2 4 4 3

2 3 3 2 4 3 3

Match =2; Mismatch, indel = -1

(53)

D G T C A G C C 0 0 0 0 0 0 0 0 C 0

A 0 T 0 A 0

G 0 T 0

G 0

0 0 2 2 1 2 2

0 0 1 4 3 2 1

0 2 1 3 3 2 1

0 1 1 3 2 2 1

2 1 0 2 5 4 3

1 4 3 2 4 4 3

2 3 3 2 4 3 3

G

G G A

A

A A C

C -- T

T

T T

(54)

Scores des indels: Approche naïve

• Un score de pénalité

σ

pour chaque indel:

– -σ pour 1 indel,

– -2σ pour 2 indels consécutifs

– -3σ pour 3 indels consécutifs, etc.

Peut être trop sévère pour une suite de 100 indels consécutifs

(55)

Considérer les gaps

• En fait, des indels consécutifs dans les

séquences biologiques sont plutôt dûs à un événement unique:

ATA__GC ATATTGC

ATAG_GC AT_GTGC

Le score “naïf”

donnerait la même valeur aux deux alignements

Plus probable Moins probable

(56)

Considérer les gaps

• Gaps: séquence d’indels consécutifs sur une ligne de l’alignement

• Contient 7 indels, mais seulement 4 gaps.

• Score particulier pour les gaps: influence la distribution des indels.

C T T T A A C --- --- A --- A C

C --- --- --- C A C C C A T --- C

(57)

Pondération constante

• Score d’un gap indépendant de sa taille:

pénalité constante r.

• Score d’un alignement entre v et w contenant k gaps S_{1≤i ≤t}d(v_i,w_j)-kr

Exemple:

score = 3d(C,C) + 2d(A,A) + d(A,C)-4r

C T T T A A C --- --- A --- A C

C --- --- --- C A C C C A T --- C

(58)

Pondération affine

• Pénalités pour les gaps:

– -ρ-σ pou 1 indel – -ρ-2σ pour 2 indels

– -ρ-3σ pour 3 indels, etc.

• r : pénalité d’ouverture d’un gap σ : pénalité d’extension.

• Score d’un gap de taille t: -r -t.σ

• Score d’un alignement de taille l contenant k gaps et q indels: S_1≤i

≤ld(v_i,wj)-kr -qσ

• Permet une pénalité réduite pour les grands gaps.

• Exemple:

score = 3d(C,C) + 2d(A,A) + d(A,C)-4r-7σ

C T T T A A C --- --- A --- A C

C --- --- --- C A C C C A T --- C

(59)

Autres pondérations

• Pondération convexe: chaque indel

supplémentaire est moins pénalisé que le précédent.

Exemple: score d’un gap de taille t: -r -log_e(t)

• Pondération quelconque w:

Fonction quelconque de la taille du gap.

Exemple: score d’un gap de taille t: -w(t)

(60)

Alignement avec gap – Pondération quelconque

• Trois alignements possibles de v[1,i] avec w[1,j]:

1. Alignement de v[1,i] avec w[1,j-1] suivit de (-,w_j) 2. Alignement de v[1,i-1] avec w[1,j] suivit de (v_j,-)

3. Alignement de v[1,i-1] avec w[1,j-1] suivit de (v_j,w_j)

• E(i,j): Valeur maximale d’un alignement de type 1.

• F(i,j): Valeur maximale d’un alignement de type 2.

• G(i,j): Valeur maximale d’un alignement de type 3.

V(i,j) = max [E(i,j), F(i,j), G(i,j)]

(61)

Alignement avec gap – Pondération quelconque

W_j

V_i

(62)

Alignement global avec gap – Pondération quelconque

• Conditions initiales:

– V(i,0) = F(i,0) = -w_(i) – V(0,j) = E(0,j) = -w(j)

– G(i,j) = V(i-1,j-1) + d(v_i,w_j)

– E(i,j) = max_0≤k≤j-1[V(i,k) – w(j-k)]

– F(i,j) = max_0≤k≤i-1[V(k,j) – w(i-k)]

• Valeur optimale: V(m,n)

• Complexité: O(m²n+nm²)

(63)

Alignement avec gap – Pondération affine

• Conditions initiales:

– V(i,0) = F(i,0) = -r – i.s – V(0,j) = E(0,j) = -r _{– j.}s

– G(i,j) = V(i-1,j-1) + d_(v_i_,w_j₎

– E(i,j) = max[ E(i,j-1), V(i,j-1) - r ] -s – F(i,j) = max[ F(i-1,j), V(i-1,j) - r _{] -}s

• Complexité: O(mn)

(64)

Parallélisme

• Table de programmation dynamique pour

l’alignement: Pour calculer une case (i,j), on a besoin des 3 cases voisines (i-1,j), (i-1,j-1), (I,j-1)

 Remplissage ligne par ligne, colonne par colonne, ou anti-diagonale par anti-diagonale:

(65)

Parallélisme

• Pour chaque anti-diagonale k, on a besoin des anti-diagonales k-1 et k-2.

• Observation clef: Chaque case d’une anti-

diagonale k est calculée indépendamment des autres cases de l’anti-diagonale k

 Un processeur peut-être assigné au calcul de chaque case

• Complexité en temps: O(n)!