HAL Id: hal-01224740
https://hal.archives-ouvertes.fr/hal-01224740v2
Preprint submitted on 25 May 2016
HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci- entific research documents, whether they are pub- lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.
L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.
Algorithmes pour générer les conformations de surfaces
formées de triangles sans sommet interne
Alain Soyer
To cite this version:
Alain Soyer. Algorithmes pour générer les conformations de surfaces formées de triangles sans sommet interne. 2015. �hal-01224740v2�
Algorithmes pour générer les conformations de surfaces formées de triangles sans sommet interne
Alain Soyer (alain.soyer@impmc.upmc.fr)
Sorbonne Universités, UPMC Univ Paris 6, CNRS UMR7590, IRD, MNHN Institut de Minéralogie, de Physique des Matériaux et de Cosmochimie (IMPMC) 4 place Jussieu, Case 115
75005 Paris - France Introduction
Lors d'un travail sur la géométrie des protéines en collaboration avec J.-F. Sadoc, nous avons eu à considérer des « surfaces internes » s'appuyant sur la chaine principale de petites protéines, ou de fragments de protéines formant un contour fermé. Pour plus d'informations sur ce sujet nous renvoyons le lecteur intéressé à l'article de J.-F. Sadoc [1] (en particulier le paragraphe 5).
C'est pour cette raison que je me suis intéressé de manière générale aux surfaces 2D (non nécessairement planes) formées de triangles sans sommet interne, c'est-à-dire ayant tous leurs sommets sur le bord de la surface. Les arrêtes du bord reliant ces sommets forment un contour fermé.
Le but des algorithmes présentés ici est de générer toutes les Nc conformations possibles d'une surface ayant un nombre donné Nt de triangles, soit un nombre de sommets Ns = Nt + 2 . Les sommets sont indifférenciés c'est à dire non « étiquetés » mais on pourra, pour chaque conformation trouvée, envisager ensuite tous les étiquetages possibles (ce qui a été fait dans le cas des protéines en déplaçant les acides aminés sur les sommets du contour de la surface). D'autre part on ne se préoccupe pas de l'éventuelle chiralité des surfaces (espace non orienté) car l'application qui était faite était un calcul d'énergie.
Pour des raisons d'esthétique on a représenté des triangles équilatéraux dans les dessins qui suivent, mais on s'intéresse à la topologie des surfaces (et non à la métrique) : les triangles peuvent donc avoir des formes quelconques.
Remarque :
si on relie les barycentres des triangles d'une surface donnée on obtient son dual, soit un arbre binaire non étiqueté.
Notation
Une conformation sera codée sous la forme d'une liste de chiffres représentant les nombres de triangles aboutissant à chaque sommet lorsqu'on parcourt le contour de la surface. Pour minimiser la mémoire utilisée ces chiffres ne sont pas rangés dans des entiers mais dans des octets non signés.
Figure 1 : 6 triangles, 8 sommets arbre dual
Puisque le contour est fermé, le dernier chiffre de la liste doit être considéré comme voisin du premier (on peut estimer que la liste est périodique). De plus j'ai choisi la convention de rendre
maximum le nombre formé de la concaténation de ces chiffres.
Par exemple la conformation de la figure 1 sera notée {4, 2, 1, 4, 1, 3, 2, 1} et non pas {4, 1, 3, 2, 1, 4, 2, 1} ni {4, 1, 2, 4, 1, 2, 3, 1} ni {4, 1, 2, 3, 1, 4, 1, 2} , car
42141321 > 41321421 > 41241231 > 41231412 . Algorithme A1
La méthode qui vient naturellement à l'esprit pour générer toutes les conformations de Nt triangles consiste à utiliser un algorithme itératif.
Partant d'une conformation formée d'un triangle unique, on ajoute un triangle de manière itérative jusqu'à obtenir les conformations de Nt triangles.
Pour chaque conformation de l' itération courante, on envisage toutes les manières de coller un triangle supplémentaire sur ses arêtes libres.
Le code d'une nouvelle conformation est obtenu en insérant un zéro dans le code de la conformation de départ, entre les chiffres correspondant aux sommets extrémités de l'arête à laquelle le nouveau triangle est collé, puis en ajoutant le code du nouveau triangle, soit {1, 1, 1}.
Par exemple pour ajouter un triangle supplémentaire à gauche de la conformation de la figure 1 et obtenir celle de la figure 2, on insère 0 entre le 4 et le 1 ce qui donne le code
{4, 2, 1, 4, 0, 1, 3, 2, 1} puis on ajoute {1, 1, 1} centré sur le 0 .
Figure 2
On obtient {4, 2, 1, 5, 1, 2, 3, 2, 1} qui est un code qui ne suit pas la convention adoptée ci-dessus.
Il est donc nécessaire d'envisager une permutation circulaire et un éventuel changement de sens afin d'obtenir le code « maximum » ; dans cet exemple {5, 1, 2, 4, 1, 2, 3, 2, 1}.
Le tableau 1 montre les conformations obtenues et leur code jusqu'à Nt = 6 (Ns = 8).
Le nombre de conformations Nc augmente vite avec le nombre de triangles (3ème colonne du tableau 2) ce qui amène deux conséquences néfastes : une taille mémoire et un temps de calcul qui croissent rapidement.
Je ne donnerai pas plus de détail sur cet algorithme car son intérêt est limité à cause de sa lenteur.
Ceci est du au fait que lorsqu'on trouve une nouvelle conformation on doit vérifier qu'elle n'a pas déjà été générée précédemment. Cette vérification devient vite pénalisante en temps de calcul. Elle peut être accélérée en utilisant une recherche par dichotomie, mais cela ne suffit pas si l'on désire dépasser une vingtaine de sommets.
C'est ce que montre la 4ème colonne du tableau 2 où les temps de calcul T(A1) obtenus avec un programme en langage C implémentant cet algorithme sont indiqués pour un ordinateur équipé d'un processeur Intel Xeon E5-4650 cadencé à 2.7GHz.
Tableau 1
Nt Ns Nc Conformations Codes Nt_max
1 3 1 {1,1,1} 1
2 4 1 {2,1,2,1} 2
3 5 1 {3,1,2,2,1} 3
4 6 3
{3,1,3,1,3,1}
{3,2,1,3,2,1}
3
{4,1,2,2,2,1} 4
5 7 4 {3,3,1,2,3,2,1} 3
{4,1,3,1,3,2,1}
{4,2,1,3,2,2,1}
4
{5,1,2,2,2,2,1} 5
Tableau 1 (suite)
Nt Ns Nc Conformations Codes Nt_max
6 8 12 {3,3,2,1,3,3,2,1} 3
{4,1,3,1,4,1,3,1}
{4,1,4,1,2,3,2,1}
{4,2,1,3,2,3,1,2}
{4,2,1,3,3,1,3,1}
{4,2,1,4,1,3,2,1}
{4,2,2,1,4,2,2,1}
{4,3,1,2,3,2,2,1}
4
{5,1,2,3,1,3,2,1}
{5,1,3,1,3,2,2,1}
{5,2,1,3,2,2,2,1}
5
{6,1,2,2,2,2,2,1} 6
Tableau 2
Nt Ns Nc T(A1) T(A2) M(A2) Go T(A3)
1 3 1
2 4 1
3 5 1
4 6 3
5 7 4
6 8 12
7 9 27
8 10 82
9 11 228
10 12 733
11 13 2282
12 14 7528
13 15 24834
14 16 83898 1.3s
15 17 285357 14s
16 18 983244 2m24s 3s
17 19 3412420 26m16s 2.6s 0.13 11s
18 20 11944614 11h17m48s 9s 0.48 44s
19 21 42080170 34s 1.77 2m55s
20 22 149197152 2m09s 6.57 11m41s
21 23 531883768 10m01s 24.47 42m13s
22 24 1905930975 53m51s 91.49 2h45m24s
23 25 6861221666 343.06 11h10m18s
Algorithme A2
Il est itératif comme l'algorithme 1, mais comporte une importante amélioration qui permet d'éviter d'avoir à tester si une conformation a déjà été trouvée, ce qui diminue considérablement le temps de calcul. De plus il génère les conformations de manière ordonnée (par codes décroissants).
Pour générer les conformations de Ns sommets connaissant celles de Ns - 1 sommets (ordonnées par code décroissant) je commence par créer la conformation la plus « compacte », qui a le code maximum {Ns - 2, 1, 2, 2, ... , 2, 1} .
Puis pour chaque conformation de Ns - 1 sommets, j'envisage les différentes manière d'ajouter un triangle supplémentaire, avec l'astuce décrite ci-après qui consiste à imposer de conserver une certaine longueur du code.
Pour illustrer ce mécanisme prenons par exemple les 12 conformations de 8 sommets, déjà vues tableau 1, et dont les codes triés par ordre décroissant sont numérotés dans le tableau 3a. Voyons comment on obtient les codes des 27 conformations de 9 sommets du tableau 3b.
Tableau 3a
N° Codes Longueur conservée N° conformations générées en 3b 1
2 3 4 5 6 7 8 9 10 11 12
{6, 1, 2, 2, 2, 2, 2, 1}
{5, 2, 1, 3, 2, 2, 2, 1}
{5, 1, 3, 1, 3, 2, 2, 1}
{5, 1, 2, 3, 1, 3, 2, 1}
{4, 3, 1, 2, 3, 2, 2, 1}
{4, 2, 2, 1, 4, 2, 2, 1}
{4, 2, 1, 4, 1, 3, 2, 1}
{4, 2, 1, 3, 3, 1, 3, 1}
{4, 2, 1, 3, 2, 3, 1, 2}
{4, 1, 4, 1, 2, 3, 2, 1}
{4, 1, 3, 1, 4, 1, 3, 1}
{3, 3, 2, 1, 3, 3, 2, 1}
1 1 2 3 1 2 3 4 5 2 3 1
2, 3, 4
5, 6, 7, 8, 9, 10
7, 9, 11, 12, 13, 14
8, 13, 15
16, 17, 18, 19, 20, 21
18, 22
19, 23, 24, 25
18, 19, 20, 24, 25, 26
21, 22, 25 24, 26 24
27 Tableau 3b 1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
{7, 1, 2, 2, 2, 2, 2, 2, 1}
{6, 2, 1, 3, 2, 2, 2, 2, 1}
{6, 1, 3, 1, 3, 2, 2, 2, 1}
{6, 1, 2, 3, 1, 3, 2, 2, 1}
{5, 3, 1, 2, 3, 2, 2, 2, 1}
{5, 2, 2, 1, 4, 2, 2, 2, 1}
{5, 2, 1, 4, 1, 3, 2, 2, 1}
{5, 2, 1, 3, 3, 1, 3, 2, 1}
{5, 2, 1, 3, 2, 3, 1, 3, 1}
{5, 2, 1, 3, 2, 2, 3, 1, 2}
{5, 1, 4, 1, 2, 3, 2, 2, 1}
{5, 1, 3, 2, 1, 4, 2, 2, 1}
{5, 1, 3, 1, 4, 1, 3, 2, 1}
{5, 1, 3, 1, 3, 3, 1, 3, 1}
{5, 1, 2, 4, 1, 2, 3, 2, 1}
{4, 4, 1, 2, 2, 3, 2, 2, 1}
{4, 3, 2, 1, 3, 3, 2, 2, 1}
{4, 3, 1, 3, 1, 4, 2, 2, 1}
{4, 3, 1, 2, 4, 1, 3, 2, 1}
{4, 3, 1, 2, 3, 3, 1, 3, 1}
{4, 3, 1, 2, 3, 2, 3, 1, 2}
{4, 2, 3, 1, 2, 4, 2, 2, 1}
{4, 2, 1, 4, 2, 1, 4, 2, 1}
{4, 2, 1, 4, 1, 4, 1, 3, 1}
{4, 2, 1, 4, 1, 3, 3, 1, 2}
{4, 2, 1, 3, 3, 2, 1, 4, 1}
{3, 3, 3, 1, 2, 3, 3, 2, 1}
La numéro 1 est générée « ab-initio » comme décrit précédemment.
Puis l'algorithme va traiter successivement les 12 conformations de 8 sommets. Lors de l'ajout d'un triangle à une de ces conformations, on impose que le nouveau code obtenu soit conservé par
rapport au code initial sur la longueur indiquée colonne 3. Cette longueur est égale à [1 + le nombre de chiffres successifs communs, à partir du début, avec le code de la conformation précédente].
Les numéros des conformations de 9 sommets obtenues sont donnés colonne 4 ; celles dont le numéro est en gras sont gardées alors que les autres sont rejetées par le critère de conservation de longueur du code.
Ainsi les nouvelles conformations sont obtenues une seule fois et par ordre de codes décroissants.
Quand les conformations ont toutes été générées, on vérifie que leur nombre est correct. En effet celui-ci est connu car il a été calculé par G. Labelle et al. [2] en fonction des nombres de Catalan (voir équation 108 de leur article).
J'ai écris un programme en langage C implémentant cet algorithme et les temps de calcul obtenus T(A2) sont rapportés dans la 5ème colonne du tableau 2. Le gain par rapport à l'algorithme 1 est considérable.
La taille mémoire en Go demandée par le programme est indiquée colonne 6 : M(A2). Etant limité à 128 Go de mémoire sur le serveur disponible, je n'ai pas pu dépasser 24 sommets.
Algorithme A2P
Concernant le problème de la taille mémoire on pourrait penser, lors d'une itération, écrire les conformations dans un énorme fichier puis les relire à l'itération suivante, mais ceci ne serait pas efficace car les accès disques sont beaucoup plus lents que les accès mémoire, et le programme passerait la majorité de son temps en entrées sorties plutôt qu'à calculer.
Une autre idée est de paralléliser l'algorithme 2, non pas tant en vue de diminuer le temps de calcul que pour répartir la mémoire sur différents noeuds d'une machine parallèle. Cette tache n'est pas triviale car l'algorithme est peu favorable à la parallélisation.
Les conformations de Ns sommets peuvent être réparties en groupes suivant la valeur du nombre maximum de triangles par sommet, donc le premier nombre de leur code (noté Nt_max dans la dernière colonne du tableau 1). Par exemple pour Ns = 8 on a quarte groupes séparés par des lignes en pointillés (tableau 1).
Or nous avons vu que l'algorithme 2 impose de conserver au minimum le premier nombre du code, donc les conformations d'un groupe vont générer celle du nouveau groupe ayant le même Nt_max (ce que l'on vérifie tableau 3). D'où l'idée d'affecter le traitement de ces groupes à des processus s'exécutant en parallèle.
Malheureusement ceci n'est pas efficace car le nombre de groupes (égal à Ns – 4) est faible, donc on profite guère de la parallélisation, et ils sont peuplés très inégalement, ce qui a pour conséquence que lors de la synchronisation indispensable en fin d'itération les processus vont se mettre en attente de fin de traitement du groupe le plus peuplé.
C'est pourquoi il a été nécessaire à chaque itération de redistribuer les conformations entre les processus afin d'équilibrer la charge.
Je ne décrirai pas l'algorithme parallélisé en détail, mais donnerai seulement un certain nombre de principes utilisés.
On exécute Np processus en parallèle, dont un processus jouant le rôle de chef d'orchestre et Np - 1 processus de calcul.
Au cours d'une itération, un processus de calcul reçoit Nc1 conformations de longueur L1 et les range dans un tableau local Cfm1. Il génère Nc2 conformations de longueur L2 = L1 + 1 dans un tableau Cfm2.
Conceptuellement les parties utilisées des tableaux Cfm1 de chaque processus mises bout à bout
(par la pensée) forment un grand tableau « partagé » (idem pour Cfm2).
Nc2 est envoyé au processus 0, lequel après synchronisation, retourne les Nc2 des autres processus.
Ceci permet au processus de calcul de déterminer l'emplacement et le nombre de conformations à envoyer vers, et à recevoir depuis, d'autres processus de calcul afin d'équilibrer leur charge.
Le processus p envoie aussi la dernière Cfm1 au processus p+1 , et reçoit la dernière du processus p-1 afin de pouvoir calculer la longueur de code à conserver.
J'ai programmé cet algorithme en langage C et en faisant appel à la librairie parallèle MPI (Message Passing Interface) qui est la plus communément répandue.
Le tableau 4 indique pour le nombre Ns de sommets le nombre Nc de conformations, le nombre Np de processus utilisés, la mémoire par processus en Mo et le temps de calcul T(A2P) sur un IBM Regata Power 6 .
Tableau 4
Ns Nc Np Mo / p T(A2P)
20 11944614 4 180 7s
21 42080170 4 658 17s
22 149197152 8 1071 46s
23 531883768 24 1243 1m07s 24 1905930975 64 1735 2m38s 25 6861221666 144 2900 7m32s 26 24806004996 512 3162 13m21s
Avec 512 processus d'environ 3 Go on génère rapidement toutes les conformations de 26 sommets.
Algorithme A3
Tout le monde n'a pas accès facilement à un ordinateur parallèle doté de nombreux processeurs ou d'une très grande capacité mémoire. Si on est limité à un ordinateur personnel classique il est cependant possible de générer de nombreuses conformations grâce à un algorithme demandant très peu de mémoire.
Contrairement à A1 et A2 l'algorithme A3 n'est pas itératif mais récursif.
Il part de la conformation de code maximum de Ns sommets et de celle de Ns-1 sommets. Son principe est d'ajouter à cette dernière un triangle pour créer de nouvelles conformations de Ns sommets en gardant Nt_max constant, puis de supprimer un triangle de ces nouvelles
conformations afin d'obtenir des conformations de Ns – 1 sommets ayant un Nt_max plus petit.
Ces opérations sont répétées de manière récursive.
Le processus récursif exécute les taches suivantes en partant d'une conformation de Ns-1 sommets : - génération des conformations de Ns sommets par ajout d'un triangle en imposant Nt_max constant (lors de cette étape on conserve que les codes inférieurs au dernier code généré).
- boucle sur les conformations de Ns sommets que l'on vient d'obtenir :
- génération des conformations de Ns - 1 sommets par suppression d'un triangle en imposant de diminuer Nt_max . On conserve que la dernière (si il en en a, et si son code est inférieur au dernier généré).
- appel récursif à lui même avec cette dernière conformation - fin de boucle
Reprenons comme exemple la génération des conformations de 9 sommets du tableau 3b.
15 10
5 6 7 8 9 11 12 13 14
26
16 17 18 19 20 21 22 23 24 25
27
4
2 3
1
1
2 3 4
5 6 7 8 9 10 11
12
Ns=8 Ns=9
Figure 3
Nt_max=7
Nt_max=6
Nt_max=5
Nt_max=4
Nt_max=3
La figure 3 résume la filiation obtenue. Les numéros des conformations sont ceux de la première colonne du tableau 3 ; ils sont entourés d'un rectangle pour les conformations de 9 sommets et d'un cercle pour celles de 8. Les flèches en trait plein indiquent les filiations réalisées alors que celles en pointillés montrent les descendances éliminées.
Les valeurs de Nt_max sont indiquées du côté droit de la figure.
Initialement la conformations n°1 de 9 sommets est créée, puis la n°1 de 8 sommets.
L'algorithme récursif appliqué à cette dernière produira les conformations dans l'ordre indiqué tableau 5 (du haut en bas) en fonction de la profondeur de récursivité qui est égale au maximum à Ns – 5 .
Tableau 5
Profondeur 1 Profondeur 2 Profondeur 3 Profondeur 4
(1) => 2, 3, 4
(2) => 5, 6, 7, 8, 9, 10
(5) => 16, 17, 18, 19, 20, 21
(12) => 27 (6) => 22
(7) => 23, 24, 25 (8) => 26
(3) => 11, 12, 13, 14 (4) => 15
Bien sur cet algorithme ne donne pas les conformations par ordre décroissant comme avec A2.
Les temps de calculs T(A3) en fonction de Ns sont donnés dans la dernière colonne du tableau 2.
On constate que bien que nettement plus lent que l'algorithme A2, l'algorithme A3 grâce au peu de mémoire demandée (quelques Mo) permet de générer les conformations de 25 sommets.
Algorithme A3P
Il est possible de paralléliser l'algorithme A3 sur un nombre de processus égal à Ns – 4 en vue de gagner du temps, mais ceci n'est pas très rentable car à un moment des processus sont obligés de s'attendre afin de connaitre la dernière conformation générée par un processus précédent.
Par exemple pour Ns=25 et 21 processus on a un temps de calcul de 8h09m au lieu de 11h10m avec A3.
Donc si on dispose d'une machine parallèle il est préférable d'utiliser l'algorithme A2P.
Conclusion
Nous souhaitions générer toutes les conformations possibles d'une surface formée de triangles ayant tous leurs sommets en périphérie.
Le plus naturel a été de développer l'algorithme itératif A1 qui répond au problème. Mais celui-ci rencontre deux difficultés : la quantité de mémoire nécessaire pour ranger les conformations et le temps de calcul qui augmentent de manière prohibitive avec le nombre de sommets. C'est pourquoi j'ai été limité avec cet algorithme à la génération des conformations de 20 sommets.
J'ai trouvé une astuce consistant à imposer la conservation du code des conformations sur une certaine longueur ce qui a conduit à l'algorithme A2. Ce dernier permet de diminuer
considérablement le temps de calcul et d'obtenir les conformations de 24 sommets. La taille mémoire de l'ordinateur utilisé a été le facteur limitant pour cet algorithme.
Puis j'ai mis au point une version parallèle de l'algorithme A2 qui a permis de répartir la mémoire entre les noeuds de calcul d'un cluster. Les conformations de 26 sommets ont été générées
rapidement en utilisant 512 processus et l'utilisation d'une machine massivement parallèle doit permettre d'aller encore plus loin.
Enfin la mise au point d'un algorithme récursif très économe en mémoire m'a permit de générer les conformations de 25 sommets en moins d'une nuit sur un PC ordinaire.
Les sources en langage C des programmes implémentant les algorithmes A2, A2P et A3 sont disponibles sur simple demande.
Bibliographie
1. Geometry of proteins : search for internal surfaces J.-F. Sadoc
Biophysical Reviews and Letters, Vol. 3, No. 3 (2008) 365-385 2. A classification of plane and planar 2-trees
G. Labelle, C. Lamathe & P. Leroux
Theoretical Computer Science, Vol. 307, No. 2 (2003) 337-363
