Bioinformatique : théorie et pratique

Bioinformatique : théorie et pratique

Olivier Elemento, olivier@ligm.igh.cnrs.fr

Attention : ce document est loin d'être complet, et évolue selon le temps que j'ai a y consacrer. Si vous avez une question particulière liée au contenu de ce document, ou plus généralement au domaine de la Bioinformatique, vous pouvez la poser sur le forum de Bioinformatique associé.


Table of Contents

1. Introduction
2. Environnement de travail du bioinformaticien
Connaître les différents types d'environnements
Installer une station de travail sous Linux
Choisir une distribution Linux
Choisir une interface graphique
Installer de nouveaux programmes
Utiliser UNIX
Exécuter une commande Unix, lancer un programme
Se déplacer dans les répertoires, lister, créer et effacer des répertoires
Copier, déplacer, renommer fichiers et répertoires
Rechercher des fichiers avec find et locate
Afficher un fichier texte avec more et cat, rechercher une chaine de caractère avec grep et egrep
Changer les droits d'accès à un fichier avec chmod, son mot de passe avec passwd
Archiver et compresser avec tar et gzip
Executer des commandes à intervalles réguliers avec cron
Autres opérations
Communiquer entre machines
accéder à une machine distante avec Telnet
échanger des fichiers avec ftp
Editer des fichiers texte
Utiliser Emacs pour l'édition avancée
Utiliser vi ou cat pour l'édition rapide
Autres utilitaires Unix
Ecrire des scripts shell
Documentation
3. Rechercher des informations
Les moteurs de recherche
Google, star des moteurs de recherche
Utiliser Google dans vos programmes Perl
Les bases de données
Pubmed
Genbank, EMBL, DDBJ
Swissprot
Les journaux online
4. L'analyse de séquences
Recherche de similarités entre séquences
Alignement local par la méthode de Smith-Waterman
BLAST
FASTA
Alignments globaux
Alignements multiples
Recherche de motifs
Utiliser les expressions régulières Perl
Utiliser une structure de données de type "trie" (de retrieval)
Réseaux de neurones
Utilisation de profils
Détection, prédiction et annotation de gènes
Recherche de mini/micro satellites et de séquences répétées en tandem
Clustering d'EST
Les outils intégrés d'analyse de séquences
5. Evolution des génomes et analyse phylogénétique
Contruire des alignements multiples
Les principales méthodes de reconstruction phylogénétique
Parcimonie
Evolution minimum
Maximum de vraisemblance
Les principaux outils de reconstruction phylogénétique
PHYLIP
Qu'est-ce que PHYLIP?
Quels sont les principaux programmes informatiques de reconstruction phylogénétique dans PHYLIP ?
Quel est les opérations à effectuer pour obtenir un arbre à partir de séquences nucléotidiques?
Quel est le format de données en entrée des programmes PHYLIP?
Comment aligner des séquences au format FASTA et obtenir un fichier au format PHYLIP?
Comment calculer une matrice de distance à partir de séquences nucléotidiques ou protéiques ?
Comment générer un arbre à partir de distances entre séquences?
Comment visualiser un arbre de manière graphique?
Dessiner des arbres phylogénétuques
6. Analyser les données du transcriptome et les données d'expression de gènes
Techniques de mesure d'expressions de gènes
cDNA microarrays
Puces à oligo-nucléotides
RT-PCR
Serial Analysis of Gene Expression (SAGE)
7. Programmer en Perl
Introduction à Perl et premiers pas
concepts fondamentaux de la syntaxe Perl
Applications en bioinformatique
BioPerl
programmer en C
Quels sont les points clé du langage C?
Quel environnement de programmation?
Utiliser les Makefiles
Chasser les erreurs de programmation (débugger)
Résolution de problèmes bioinformatique en C
programmer en Java
Installer un kit de développement Java
Compiler et éxécuter un programme Java
Construire un programme en langage Java
Exemple de code Java pour la bioinformatique
programmer avec XML
Utiliser un parseur XML en Perl
programmation Corba
programmation parallèle
PVM : Parallel Virtual Machine
MPI : Message Passing Interface
Distribuer ses programmes
8. La programmation d'applications web
HTML
structure générale d'un fichier HTML
mise en page de divers éléments (images, textes)
Les tableaux
Création de formulaires HTML
Javascript pour la validation de formulaires HTML
Utiliser Perl pour le développement d'application web dynamiques
traitement de formulaires avec le module CGI
templates avec HTML::Template
sessions avec Apache::Session
interaction avec une base de données MySQL
Utiliser MySQL pour stocker les données
9. Méthodes et algorithmes en bioinformatique
Structures de données
Listes chainées
Tableaux
Arbres
Files
Graphes
Les algorithmes de tri
Algorithmes de recherche et optimisation
recuit simulé
algorithmes génétiques
monte-carlo
descente de gradient
tabu search
Modèles de Markov
Analyse de données et data mining
Analyse en Composantes Principales
Que sont les "règles d'association" (et comment les induire)?
Techniques de classification supervisée
Techniques de classification non supervisée
10. Prédiction de structure 3D
Prédiction de structure
Utilisation du profil hydrophylique
Visualisation de structures 3D
11. Le stockage des données et les bases de données
Les bases de données
Les bases de données généralistes
Les format de données
XML
Passer d'un format XML à un autre grâce aux transformations XSLT
12. Construction de base de données
Choix technologiques
Pourquoi Apache ?
Pourquoi Perl ?
Pourquoi MySQL ?
Création de la base de données
Conception Merise et diagrammes
Création de la base de données et des tables
Entrer des données dans la base
Entrer de nouvelles données via SQL
Entrer de nouvelles données via Perl et SQL
Définir un formulaire HTML d'entrée de donnée
Construire le script Perl correspondant
Constrôle des données entrées via le formulaire
Interroger la base
Bonus : utilisation des logs Apache et Perl
Comment trouver les erreurs dans les scripts Perl ?
Qui consulte votre base de données ?
Interfacer des outils externes : FASTA
13. Sites et listes de diffusion

List of Figures

4.1. ClustalX
6.1. Kohonen
6.2. Projection
10.1. Profil hydrophobique de la Rhodopsin humaine (tiré de http://lectures.molgen.mpg.de/Individual/Intro/)
12.1. PROTDB
12.2. PROTDB
12.3. PROTDB
12.4. Liste des protéines à consulter
12.5. résultats : affichage d'une fiche protéine
12.6. webalizer

List of Tables

2.1. Les commandes simples
2.2. vi et ses commmandes de base
2.3. Divers outils bien utiles sous Linux
4.1. Les programmes d'alignements locaux du package FASTA3x
4.2. les programmes gratuits d'alignement global entre 2 séquences
5.1.

Chapter 1. Introduction

Les programmes de génomique, de protéomique, d'analyse de l'expression de gènes manipulent d'énormes volumes de données hétérogènes créées par les technologies à haut débit. L'acquisition, le stockage, l'analyse et le traitement de ces données brutes et des données annotées, leur comparaison avec d'autres données de bases extérieures généralistes ou spécifiques, leur consultation, ..., nécessitent l'acquisition de compétences spécifiques dans le domaine de la bioinformatique (application de l'informatique à la biologie). Le but de cet ouvrage est de vous présenter la bioinformatique par ses aspects pratiques, tout en faisant un point concis sur les divers algorithmes et théories, ainsi que les logiciels couramment utilisés. Ce document est fait pour que vous trouviez une solution aux problèmes qui vous sont posés, ou du moins les moyens d'arriver à une solution. L'accent est mis sur l'apprentissage de la programmation, la construction de bases de données, et d'interfaces conviviales et performantes. Ressources:

Developing Bioinformatics Computer Skills par Cynthia Gibas et Per Jambeck
home page de Cynthia Gibas
Bioinformatics: The Machine Learning Approach (Adaptive Computation and Machine Learning) par Pierre Baldi et Soren Brunak

Remarque : ce document a été formatté en XML via DOCBOOK, puis transformé en HTML grace a la commande xsltproc /usr/share/sgml/docbook/xsl-stylesheets-1.29/html/docbook.xsl bioinfo.xml > bioinfo.html pour obtenir un document sur une seule page, et xsltproc /usr/share/sgml/docbook/xsl-stylesheets-1.29/html/chunk.xsl bioinfo.xml pour obtenir un document multi-pages.

Chapter 2. Environnement de travail du bioinformaticien

Connaître les différents types d'environnements

Il existe deux grands types d'environnement : Windows et Unix. Windows, bien que possédant une certaine convivialité est en réalité peu adapté aux besoins des bioinformaticiens. Lui font essentiellement défaut des outils permettant de programmer de nouveaux logiciels et d'automatiser certaines taches.

Unix donne en revanche accès à de nombreux outils de programmation (langages, interfaces), à une pléthore d'outils gratuits (serveur web, systèmes de gestion de bases de données) utiles dans la majeure partie des problèmatiques bioinformatiques. De plus, tous les Unix (Linux, Solaris, FreeBSD, etc.) possèdent des logiciels de visualisation (gv, gnuplot, gqview), ou éditeurs (vim, emacs). Unix profite de très nombreux outils gratuits de très bonne qualité : OpenOffice pour la bureatique, Scilab pour le calcul scientifique, R pour l'analyse statistique, etc. Le bioinformaticien doit avoir le controle complet sur sa machine : il doit pouvoir éxécuter des commandes précises sur ses fichiers, faire des recherches de texte, automatiser des taches, lancer des taches à heures précises ... seul Unix lui confère ce contrôle.

On pourrait également évoquer la supériorité des Unix au niveau stabilité (pas besoin de rebooter) et rapidité. Enfin il existe pour les Unix libres (Linux, *BSD) une masse de documentation énorme, voire pléthorique, disponible librement et facilement au travers du réseau Internet

Installer une station de travail sous Linux

Choisir une distribution Linux

Le choix est vaste. Parmi les distributions en vogue se trouvent la Debian, la Mandrake, la Red Hat, ou encore la SuSE. On s'interessera de plus en plus a des distributions adhèrant à la LSB (Linux Standard Base). Dès lors que le choix est effectué, il suffit d'aller sur le site de l'éditeur, de télécharger la ou les images ISO correspondant aux CD d'installation, de graver les CD à partir de ces images, et de lancer l'intallation.

Choisir une interface graphique

Sous Linux, les deux interfaces graphiques les plus connues sont Gnome et KDE. Ce sont des bureaux virtuels, c'est à dire qu'ils permettent l'accès convivial à un grand nombre d'applications très utilisées (programmes de lectures de mails, navigateurs web, divers utilitaires de visualisation, etc.). KDE et Gnome sont maintenant très murs, et très conviviaux. Pour se faire une idée de ce à quoi ressemble un bureau KDE ou Gnome, il existe des "screenshots" sur les sites KDE.org et gnome.org. On notera cependant que ce sont deux bureaux "lourds", c'est à dire gourmand en ressources, et notamment mémoire vive (nettement moins gourmands que Windows néanmoins). Pour ceux à qui cela pourrait poser problème, il existe d'autres bureaux : IceWM, Enlightment, AfterStep, etc.

Installer de nouveaux programmes

Il existe deux principales manières d'installer des nouveaux programmes sous Linux : à partir des sources et grâce à des binaires précompilés. Les sources se trouvent généralement sous forme d'archive compressées (fichier dont l'extension est .tar.gz). Dans ce cas la, la première étape consiste à decompresser l'archive :
tar xvfz archive.tar.gz
Il est conseillé d'afficher le contenu de l'archive avant la décompression, afin de savoir si les fichiers archivés seront décompréssés dans le répertoire courant ou bien si un répertoire va être créé. La commande est similaire :
tar tvfz archive.tar.gz
On lira ensuite les fichiers README ou INSTALL afin d'avoir des indications sur l'installation. Néanmoins, dans la plupart des cas, la manière de procéder est la suivante:
configure 
make 
su
make install

La commande configure crée un fichier Makefile, qui contient les instructions pour compiler le code source (de le transformer en code machine). La commande make permet ensuite de lancer la compilation. su permet de changer d'utilisateur et notamment de passer root. Cela est nécessaire pour l'installation de programmes hors de son répertoire personnel. Enfin make install permet de copier les binaires dans les répertoires d'installation. Notons que généralement, il est possible de spécifier l'endroit ou seront copiés les fichiers à installer, grâce à l'option --prefix.

configure --prefix=/usr 

L'installation de packages precompilés peut par exemple se faire via le programme rpm. Pour installer un nouveau package nommé archive.rpm, la commande est la suivante :

rpm -i archive.rpm

Pour que l'installation soit un peu plus "parlante", on tapera la commande suivante :

rpm -ivvh archive.rpm

Pour mettre a jourvun programme existant, on utilisera la ligne suivante :

rpm -Uvh archive.rpm

Le programme rpm vérifie par défaut les dépendances du package, et ne permet pas l'installation si celles-ci ne sont pas résolues. Il est néanmoins possible d'éviter cette vérification grâce à l'option --nodeps. par exemple :

rpm -Uvh --nodeps archive.rpm

Un package RPM peut également contenir les sources d'un programme. Dans ce cas, pour compiler et installer ce package, on tapera :

rpm --rebuild archive.src.rpm

Ressources :

Using RPM: The Basics
site de RPM , contenant notamment l'ouvrage 'Maximum RPM'
site de RPM , base de données de packages RPM

Utiliser UNIX

Exécuter une commande Unix, lancer un programme

Après la procédure d'identification, un programme nommé "shell" est lancé automatiquement ou bien dans une fenetre graphique (xterm par exemple). Il s'agit d'un environnement d'execution de commandes, a partir duquel il est possible de lancer des commandes Unix et d'exexuter des programmes externes. Pour lancer une commande ou éxécuter un programme, il suffit de taper son nom. Dans le cas d'un programme, si celui-ci ne se trouve pas dans le répertoire courant, il faudra que la variable d'environnement $PATH précise le répertoire dans lequel il se trouve. Pour ajouter un répertoire au $PATH, il suffit d'utiliser la commande export. Par exemple, pour rajouter le répertoire /home/olly/bin au $PATH :
export PATH=$PATH:/home/olly/bin

Se déplacer dans les répertoires, lister, créer et effacer des répertoires

ls permet d'afficher le contenu du répertoire courant. ls possède de nombreuses options :

ls -l permet d'avoir de plus amples informations concernant chacun des fichiers et répertoires.

ls -t permet de lister les fichiers dans l'ordre de leur création (ou modification)

ls -a permet de lister également les fichiers cachés

Il est bien sur possible de combiner ces options. Par exemple, ls -atl affiche le détail de tous les fichiers, et ce dans l'ordre chronologique de leur création.

ls -atl 
La commande pwdpermet de connaitre le répertoire courant. du -k ou du -b

Copier, déplacer, renommer fichiers et répertoires

La commande cp permet de copier un fichier vers un répertoire. Par exemple, pour copier le fichier fichier1 vers le répertoire rep1, on utilisera la ligne de commande suivante :
cp fichier1 rep1/
Au lieu de copier certains fichiers, il peut être souhaitable de créer des liens symboliques, c'est à dire donner l'accès dans un répertoire à un fichier d'un autre répertoire ou portant un autre nom.
ln 

Rechercher des fichiers avec find et locate

find . permet de lister l'ensemble des fichiers a partir du répertoire courant. find /home/olly -name "*.html" permet de lister l'ensemble des fichiers HTML a partir du répertoire /home/olly Il est également possible d'éxécuter une commande sur les fichiers trouvés par find, gràce à l'option --exec. Par exemple, pour afficher les fichiers contenant la chaine "TATTAA", on utilisera la commande suivante :

find . -name "*.seq" -print -exec grep TATTAA {} \;

Afficher un fichier texte avec more et cat, rechercher une chaine de caractère avec grep et egrep

RET permet d'avancer d'un eligne Espace permet d'avancer d'une page b permet de revenir une page en arrière / suivi d'une chaine de caractère permet de faire une recherche en cours. 'n' permet de chercher la prochaine occurence.

Changer les droits d'accès à un fichier avec chmod, son mot de passe avec passwd

Les droits d'acces aux fichiers sont gérés sous Linux grace a deux commandes : chmod et chown. chmod permet de modifier les droits d'un fichier. Par exemple :

chmod +x fichier permet de rendre le fichier éxécutable (par tout le monde).

chmod a-w fichier permet de retirer les droits d'execution d'ecriturea tout le monde. chmod a-x repertoire permet d'empecher a quiconque d'entrer (via la commande cd) dans le repertoire.

Pour changer son mot de passe, on utilisera la commande suivante : passswd

Archiver et compresser avec tar et gzip

* Lister le contenu de l'archive ZIP

unzip -l archive.zip

gunzip permet de décompresser les fichiers compréssés avec gzip (possédant l'extension .gz) gzip tar cvfz

Executer des commandes à intervalles réguliers avec cron

Pour éxécuter une tache de manière régulière, et à des moments bien précis, il existe un "démon" Unix nommé cron. Celui-ci est commandé via une tables de taches à éxécuter, que l'on nomme crontab. La commande crontab permet de gérer les taches via le fichier crontab. * Lister le contenu de crontab

[olly@MPLPC18 public_html]$ crontab -l
# DO NOT EDIT THIS FILE - edit the master and reinstall.
# (/tmp/crontab.2474 installed on Thu Nov 29 00:10:10 2001)
# (Cron version -- $Id: crontab.c,v 2.13 1994/01/17 03:20:37 vixie Exp $)
0 0 * * * /home/olly/public_html/dailybackup.sh

* Editer le contenu de crontab (via l'éditeur décrit par la variable $EDITOR, ou vi par défaut)

[olly@MPLPC18 public_html]$ crontab -e

La syntaxe du crontab est quelque peu particulière. Sans rentrer dans les détails, disons que une commande possède 5 champs permettant de définir le moment d'éxécution de la commande : MINUTE(0-59) HOUR(0-23) DAYOFMONTH(1-31) MONTHOFYEAR(1-12) DAYOFWEEK(0-6). La commande suivante spécifie que le script dailybackup.sh doit être lancé dès que le chiffre des minutes de l'heure système passe à 0, c'est à dire toutes les heures :

0 * * * * /home/olly/public_html/dailybackup.sh

La commande suivante spécifie que le même script doit être lancé dès que le chiffre des minutes , ainsi que le chiffre de l'heure système sont simultanément à 0, c'est à dire tous les jours a minuit :

0 0 * * * /home/olly/public_html/dailybackup.sh

Cron peut être utilisé dans le domaine bioinformatique pour de maintes applications, comme par exemple: rapatrier des données à partir de bases de données externes, recréer une page web à intervalle régulier, etc. Par exemple, pour effectuer la copie mirroir des fichiers d'un site vers un autre (utile dans le cas de "bases de données" simples de type pages HTML statiques) :

0 0 * * * lftp -e "open machine.domaine.com; user login pass; lcd /var/httpd/htdocs;  cd public_html; mirror -Rev"

Autres opérations

* lister les processus la commande ps permet de lister les processus. En tant qu'utilisateur, lister unqiuement ses propres processus se fait avec la commande ps xf.

mysql    17382  1253  0 08:08 ?        00:00:00 /usr/sbin/mysqld --basedir=/ --datadir=/var/l
mysql    17395  1253  0 08:11 ?        00:00:00 /usr/sbin/mysqld --basedir=/ --datadir=/var/l
mysql    17403  1253  0 08:11 ?        00:00:00 /usr/sbin/mysqld --basedir=/ --datadir=/var/l
olly     17762  1972  0 09:40 pts/2    00:00:05 emacs dtADDTREEn4.c
olly     27962  1321  0 10:28 ?        00:03:01 /usr/lib/netscape/netscape-communicator -sess
olly     27980 27962  0 10:28 ?        00:00:00 (dns helper)
mysql    28011  1253  0 10:39 ?        00:00:00 /usr/sbin/mysqld --basedir=/ --datadir=/var/l
mysql    28031  1253  0 10:45 ?        00:00:00 /usr/sbin/mysqld --basedir=/ --datadir=/var/l
mysql    28044  1253  0 10:47 ?        00:00:00 /usr/sbin/mysqld --basedir=/ --datadir=/var/l
olly     28694  1972  0 12:29 pts/2    00:00:08 lyx
olly     28779  1321  0 14:46 ?        00:00:00 /usr/X11R6/bin/rxvt.bin -T  RXVT (fr) -menu  
olly     28784 28779  0 14:46 pts/1    00:00:00 bash
postfix  29935   842  0 16:10 ?        00:00:00 pickup -l -t fifo
> ps auxf | grep mathieu | awk '{ print $2 }' | xargs kill -9

* Concaténér une série de fichiers

cat fichier1.txt fichier3.txt fichier3.txt  > fichier.txt 

* Compter le nombre de lignes ou de mots d'un fichier

wc -l fichier
wc fichier

* Trier sort sed awk permet de traiter des fichiers de données sur plusieurs colonnes de manière simple. Supposons que l'on souhaite afficher la première colonne de ce fichier (nommé numbers.txt), suivi du produit des trois colonnes suivantes :

5	100000		69787	15		100000		21095		105		32
6	100000		44029	105		100000		9860		945		183
7	100000		22280	945		100000		4029		10395		1240
8	100000		9592	10395		100000		1543		135135		9698
9	100000		4069	135135		100000		515		2027025		85820
10	100000		1471	2027025		100000		157		34459425	847047
11	100000		312	34459425	100000		34		654729075	9.22054e+06
12	100000		103	654729075	1000000		124		13749310575	1.09703e+08
13	100000		25	13749310575	1000000		29		316234143225	1.41597e+09
14	1000000		44	316234143225	10000000	74		7.90585e+12	1.97037e+10
15	10000000	142	7.90585e+12	10000000	13		2.13458e+14	2.9402e+11

la commande awk permettant de réaliser cela est la suivante :

awk '{ print $1, $3*$4/$2 }' numbers.txt 

En combinant wak et sed, il est possible d'extraire de l'information plus "enfouie". Par exemple, pour extraire les accession numbers du fichier suivant (nommé seqs.txt), il suffit de taper :

awk '{ print $1 }' seqs.txt | sed -e 's/\,.*$//g'

Z73653,IGLV1-36  QSVLTQPPS.VSEAPRQRVTISCSGS SSNIGNNA.... VNWYQQLPGKAPKLLIY YDD....... LLPSGVS.DRFSGSK..SGTSASLAISGLQSEDEADYYC AAWDDSLNG...
M94116,IGLV1-40  QSVLTQPPS.VSGAPGQRVTISCTGS SSNIGAGYD... VHWYQQLPGTAPKLLIY GNS....... NRPSGVP.DRFSGSK..SGTSASLAITGLQAEDEADYYC QSYDSSLSG...
M94118,IGLV1-41  QSVLTQPPS.VSAAPGQKVTISCSGS SSDMGNYA.... VSWYQQLPGTAPKLLIY ENN....... KRPSGIP.DRFSGSK..SGTSATLGITGLWPEDEADYYC LAWDTSPRA...
Z73654,IGLV1-44  QSVLTQPPS.ASGTPGQRVTISCSGS SSNIGSNT.... VNWYQQLPGTAPKLLIY SNN....... QRPSGVP.DRFSGSK..SGTSASLAISGLQSEDEADYYC AAWDDSLNG...
Z73663,IGLV1-47  QSVLTQPPS.ASGTPGQRVTISCSGS SSNIGSNY.... VYWYQQLPGTAPKLLIY RNN....... QRPSGVP.DRFSGSK..SGTSASLAISGLRSEDEADYYC AAWDDSLSG...
M94112,IGLV1-50  QSVLTQPPS.VSGAPGQRVTISCTGS SSNIGAGYV... VHWYQQLPGTAPKLLIY GNS....... NRPSGVP.DQFSGSK..SGTSASLAITGLQSEDEADYYC KAWDNSLNA...

Communiquer entre machines

telnet, ftp, etc.. de manière sécurisée ssh (openssh)

accéder à une machine distante avec Telnet

Exemple de session telnet: telnet machine1 exit c'est à dire éxécuter des commandes sur cette machine. Notons qu'il existe une alternative sécurisée à telnet. Il s'agit de ssh. Grace à SSH, il est possible de transferer des données de manière cryptée.

échanger des fichiers avec ftp

Examinons les différentes commandes disponibles: put get changer de répértoire sur la machine distante cd envoyer plusieurs fichiers sur la machine distante mput exemple mput *.php (upload tous les fichiers du répertoire courant possédant l'extension .php) mget lcd ls (dir) lcd permet de changer de répertoire sur la machine locale de l'utilisateur (à l'inverse de cd qui permet de faire cela sur la machine distante)

Si les transferts de fichiers sont fréquents, il peut être nécéssaire d'automatiser le processus d'identification, et également d'automatiser certaines tâches. Pour cela il suffit de créer un fichier .netrc dans le répertoire $HOME. Par exemple, le fichier .netrc suivant permet d'automatiser la phase d'identification :

machine nom.machine.fr login toto password tata

machine nom.machine.fr login toto password tata
macdef init
cd public_html

Pour ne pas utiliser cette procédure, il suffit de lancer ftp avec l'option -n ftp -n machine

Editer des fichiers texte

Utiliser Emacs pour l'édition avancée

Emacs est de loin l'éditeur de texte le plus avancé du marché. Il fournit des outils de recherche de caractères très évoluées, par exemple des outils basés sur les expression régulières. Emacs possède des fonctionalité avancées de recherche et de remplacement de caractères grâce également aux expressions régulières. Il est capable d'opération d'édition complexes, comme l'indentation automatique de code source, la séléction et si souhaitée l'effacement de zones rectangulaires.

Table 2.1. Les commandes simples

Ctrl-x spermet de sauver un fichier
Ctrl-x fpermet d'ouvrir un nouveau fichier (la completion des noms de fichiers fonctionne sous Emacs, comme sous certains shells, avec la touche TAB)
Ctrl-x wpermet de sauvegarder un fichier sous un autre nom
Ctrl-x cpermet de quitter Emacs
Ctrl-k permet d'effacer une ligne
Ctrl-s permet de rechercher une chaine de caractères dans le texte. Chaque nouvel appel a cette fonction recherche la chaîne plus loin dans le texte.
Ctrl-r permet de faire la même opération que Ctrl-s, mais la recherche se fait au dessus de la position courante dans le fichier.
ESC-x permet de remplacer une chaîne de caractères par une autre

D'autres commandes, plus compliquées existent. Par exemple, pour effacer une zone rectangulaire, il suffit de selectionner une zone avec la souris. Les caractères de début et de fin de cette zone définissent alors une zone rectangulaire, qu'il est possible d'effacer avec la commande ESC-X kill-rectangle.

Utiliser vi ou cat pour l'édition rapide

vi est un éditeur de texte très puissant mais également très peu convivial. Son interêt réside dans le fait qu'il est d'être présent sur tous les systèmes Unix du monde, et qu'il est également très rapide, dès lors que l'on connait les quelques commandes de base.

Table 2.2. vi et ses commmandes de base

iinsére du texte à la gauche du curseur (entrée en mode "insert ion")
ainsére du texte à la droite du curseur
ESCsort du mode "insertion"
xefface le caractère sur lequel se trouve le curseur
ddefface la ligne
:wsauve le fichier
:qquitte vi
uundo la dernière commande

Pour créer de manière rapide un fichier texte, il est également possible de faire appel à cat, en l'utilisant de la manière suivante :

cat > monfichier
xxxx
hhhh

Une fois l'édition terminée, on tape Ctrl-D. Le fichier monfichier contient alors les lignes de texte saisies.

Autres utilitaires Unix

De nombreux outils installés avec Linux peuvent rendre de fiers services au bioinformaticien :

Table 2.3. Divers outils bien utiles sous Linux

gv, ghostview, xpsviewpermettent de visionner des fichiers PostScript (.ps) ou Portable Document Format (.pdf). En effet, de très nombreux articles ou documents téléchargés à partir du web se trouvent être sous l'un de ces deux formats.
xv, gqviewpermet de visualiser des images dans pratiquement tous les formats actuels (GIF, PNG, ...)
xfigpermet de tracer des figures et de les sauver en Postcript
latex permet de créer des documents scientifiques (articles, rapports, livres)
gnuplotTracer des courbes avec gnuplot Il permet de faire du fitting de droites (trouver la droite ou la courbe la plus représentative d'un nuage de points). Exemple: on souhaite ajuster une droite de type f(x) = a * x + b à un ensemble de points, stockés en deux colonnes (x puis f(x)) dans un fichier nommé data.txt. Voici comment procéder sous GnuPlot:
f(x)=a * x + b
fit f(x) "data.txt" using 1:2 via a,b	
Le résultat est une valeur pour les coefficients a et b, obtenus au bout d'un certain nombre d'itérations.
bc effectuer des calculs simples avec bc bc -l lance bc en mode mathématique avancé : il est alors possible d'utiliser les fonctions e(x), l(x), et la précision des calculs est fixé à 20 chiffres après la virgule. le . correspond au dernier résultat obtenu.
acroread n'est malheureusement pas un logiciel libre mais peut s'avérer bien pratique (en effet gv rencontre parfois des difficultés à ouvrir certains fichiers pdf). Acroread peut également être utilisé en mode plein écran, ce qui rend alors possible les présentations type "PowerPoint" sous Linux et sous Windows.

Ecrire des scripts shell

but : automatiser une série de commandes Un petit exemple de boucle "for" (utilisé pour lancer 5 fois de suite Bambe, donne les mêmes résultats que ceux-ci dépendent du seed) :

#!/bin/bash
for i in `seq 1 5`;
do
echo "run $i : " 
\rm trgv.*
../Source/bambe < trgvrc &> /dev/null
../Source/summarize trgv.top | bambe_pdh.pl
echo "\n"
done

affectation de variables :

toto = 5
echo $toto

Supposons que le programme random fournisse un nombre aléatoire. pour affecter le nombre en sortie de random à la variable toto :

toto = `random`
echo $toto

sed -e "s/<random\/>/$toto/" trgvrc.template > trgvrc

Introduction à la programmation Bash
Programmation Bash avancée
Bash : Soyez plus à l'aise dans votre coquille, Linux Magazine France

Documentation

le web les pages man : Par exemple pour accéder à la syntaxe de la commande ps, on tape : man ps

Chapter 3. Rechercher des informations

Les moteurs de recherche

Google, star des moteurs de recherche

A l'heure actuelle, Google est le moteur de recherche numéro 1. Sa rapidité, et la qualité des résultats obtenus en font de loin le meilleur moteur de recherche. Néanmoins, une recherche efficace sur Google nécéssite quelques astuces. Par exemple, pour chercher une page contenant les deux mots "antibody" et "engineering" :
antibody engineering
Pour chercher le morceau de phrase "antibody engineering" :
"antibody engineering"
Il s'agit d'une fonctionalité très utile dans Google, permettant de limiter drastiquement le nombre de résultats et d'en augmenter la pertinence. Par exemple, pour chercher le morceau de phrase "antibody engineering" sur le site http://imgt.cines.fr :
site:imgt.cines.fr "antibody engineering"

Utiliser Google dans vos programmes Perl

Depuis peu de temps, Google peut être utilisé comme un web service, c'est-a-dire être intégré au sein d'un programme, écrit en Perl par exemple. Tou d'abord, il est nécéssaire de s'inscire sur Google.com à l'adresse http://www.google.com/apis/, afin de recevoir une clé d'accès, et pouvoir télécharger le fichier WSDL nécéssaire (celui-ci contient une définition de l'interface du service web nécéssaire).


#!/usr/bin/perl -w


# basé sur un programmes de : 11apr2002 - matt@interconnected.org http://interconnected.org/home/

use strict;
use SOAP::Lite;

# Configuration
my $key   = "XXXXXXXXXXXXXXXXXXXXXXXXXXX"; # <-- PUT YOUR KEY HERE
my $query = $ARGV[0] || "google api"; # either type on the command line,
                                      # or it defaults to 'google api'

# Redefine how the default deserializer handles booleans.
# Workaround because the 1999 schema implementation incorrectly doesn't
# accept "true" and "false" for boolean values.
# See http://groups.yahoo.com/group/soaplite/message/895
*SOAP::XMLSchema1999::Deserializer::as_boolean =
    *SOAP::XMLSchemaSOAP1_1::Deserializer::as_boolean = 
    \&SOAP::XMLSchema2001::Deserializer::as_boolean;

# Initialise with local SOAP::Lite file
my $service = SOAP::Lite
    -> service('file:./GoogleSearch.wsdl');

my $result = $service
    -> doGoogleSearch(
                      $key,                               # key
                      $query,                             # search query
                      0,                                  # start results
                      10,                                  # max results
                      "false",                            # filter: boolean
                      "",                                 # restrict (string)
                      "false",                            # safeSearch: boolean
                      "",                                 # lr
                      "latin1",                           # ie
                      "latin1"                            # oe
                      );

# $result is hash of the return structure. Each result is an element in the
# array keyed by 'resultElements'. See the WSDL for more details. 
if(defined($result->{resultElements})) {

    my @results = @{$result->{resultElements}};
    my $res;
    foreach $res (@results) {
      print join "\n",
      "Found:",
      $res->{title},
      $res->{URL} . "\n"
    }
}



Les bases de données

Pubmed

Pour rechercher un article de R. Wells, publié en 1993 dans le journal "Journal of Biological Chemistry" :
			wells r [au] AND 1996 [dp] AND J Biol Chem [ta]
		

Genbank, EMBL, DDBJ

Swissprot

Les journaux online

Pubcrawler, un service gratuit mais méconnu qui permet de poser de façon automatique des questions à Medline. Les résultats sont envoyés tous les jours par e-mail ou consultables sur une page personnalisée protégée par mot de passe.

Chapter 4. L'analyse de séquences

Recherche de similarités entre séquences

Les séquences nucléotidiques ou d'acides aminés sont généralement stockées au format Fasta. Voici un exemple d'un tel fichier :
>R1 UbiA repeat unit 1
CATGCAAATCTTCGTCAAAACGTTGACTGGAAAAACTATCACCCTGGAGGTGGAGGCTTCCGATACCATCGAAAATGTCAAAGCCAAGATCCAAGACAAGGAAGGAATTCCACCAGATCAGCAGAGACTTATTTTTGCTGGTACGTTGGCAAAATATCTAATATTTGACCTAAAATTTATTATATATTTTCAGGAAAGCAACTCGAGGATGGCCGTACCCTTTCGGATTACAATATCCAGAAGGAATCAACCCTCCATTTGGTCCTCCGCCTAAGAGGAGG

>R2 UbiA repeat unit 2
AATGCAGATCTTCGTCAAGACTTTGACCGGAAAGACTATTACACTTGAGGTTGAAGCTTCTGACACTATCGAGAATGTGAAGGCCAAGATCCAAGACAAGGAAGGTATCCCTCCGGATCAACAGCGTTTGATCTTTGCCGGAAAGCAACTCGAGGATGGCCGTACTCTCTCCGATTACAACATCCAAAAGGAGTCTACTCTTCATCTGGTTCTGCGTCTCCGAGGAGG

>R3 UbiA repeat unit 3
AATGCAAATCTTCGTCAAGACTCTTACTGGAAAGACCATCACCCTCGAAGTCGAAGCCTCCGATACCATCGAGAACGTGAAGGCCAAGATTCAGGACAAGGAAGGAATTCCACCAGATCAGCAGCGTCTCATCTTCGCCGGAAAGCAGCTCGAGGACGGCCGCACCCTTTCTGACTACAACATCCAGAAGGAATCTACTCTTCACTTGGTTCTTCGTTTGAGAGGAGG

>R4 UbiA repeat unit 4
AATGCAGATCTTTGTCAAGACTTTGACTGGAAAGACCATCACACTTGAAGTTGAAGCTTCCGACACGATCGAGAACGTCAAGGCCAAGATTCAAGACAAGGAGGGAATCCCGCCAGATCAGCAGCGTCTTATCTTTGCTGGTATGTTACATATAACAAATTTTGTTCATGAGAGACTAATTTTTTCAGGAAAGCAATTGGAAGATGGACGCACACTCTCTGATTACAATATTCAGAAAGAGTCTACTCTCCACTTGGTGCTCCGTCTCAGAGGAGG
Il existe une multitude de formats, et passer de l'un a l'autre peut se faire grace au programme readseq. Il s'utilise en ligne de commande et celle-ci a la forme suivante :
readseq fichier.entree -format=fmt  -output=fichier.sortie
fmt est une chaine de caractère caractérisant le format de sortie, à choisir parmi les suivantes :
IG/StanfordGenBank/GB NBRFEMBLGCGDNAStriderFitchPearson/FastaZukerOlsenPhylip3.2PhylipPlain/RawPIR/CODATAMSFASN.1PAUPPretty
    Par exemple, pour obtenir un fichier au format FASTA à partir d'un fichier au format PHYLIP :
    readseq sequences.phy -format=Pearson/Fasta  -output=sequences.fasta
    
    readseq est également disponible au travers d'une interface web, à l'adresse http://bioweb.pasteur.fr/seqanal/interfaces/readseq-simple.html

    Alignement local par la méthode de Smith-Waterman

    BLAST

    Blast est un programme permettant de réaliser un alignement local entre deux séquences (nucléiques ou protéiques). Sa rapidité permet d'effectuer des comparaisons entre une séquence donnée et un très grand ensemble de séquences, par exemple l'intégralité de la base GenBank.

    Les différents programmes de BLAST

    Blast est fourni sous la forme d'un "package", composé des programmes suivants:

    blastp compare une séquence d'acides aminés avec une base de données de séquences protéiques
    blastn compare une séquence de nucléotides avec une base de données de séquences nucléotidiques
    blastx compares a nucleotide query sequence translated in all reading frames against a protein sequence database
    tblastn compares a protein query sequence against a nucleotide sequence database dynamically translated in all reading frames
    tblastx compares the six-frame translations of a nucleotide query sequence against the six-frame translations of a nucleotide sequence database.

    Partant d'une séquence donnée, BLAST fournit les résultats sous la forme de 'hits'. Un hit correspond à une séquence déterminé par BLAST (compte tenu des parametres fournis par l'utilisateur ou par défaut) comme étant homologue à la séquence donnée. Chaque hit est associé à un score et à une E-value. Le score (en bits) d'un alignement est la somme (normalisée) des scores lettre-à-lettre entre la séquence donnée et la séquence homologue), selon une matrice de scores donnée. La E-value d'un alignement de deux séquences de tailles m et n correspond à la probabilité de trouver un alignement de même score pour deux séquences aléatoires de tailles m et n. Plus cette probabilité est faible, et plus l'alignement est significatif.

    Les bases de données BLAST "prêtes a l'emploi"

    Blast travaille sur des bases de données pré-indéxées, c'est-à-dire traitées de manière à respecter une structure de données précise. L'indexation d'une base de données se fait au moyen de la commande 'formatdb' (voir ci-dessous). Sur le site du NCBI, il est néanmoins possible de télécharger un certain nombre de bases de données pré-indexées:

    Installer BLAST sur sa machine

    Pour installer BLAST sur sa propre machine, il faut tout d'abord télécharger les éxécutables à partir du site du NCBI. Le fichier ftp://ftp.ncbi.nlm.nih.gov/blast/executables/README.bls fournit les instructions d'installation. Le principal avantage de BLAST version "standalone" est qu'il permet de créer et d'utiliser ses propres bases de données. Le site FTP du NCBI contient néanmoins une série de bases de données courament utilisées : ftp://ftp.ncbi.nlm.nih.gov/blast/db/.

    Utiliser BLAST

    Rappelons que BLAST permet de comparer une séquence donnée à un ensemble de séquences, que l'on appelle "base de séquences". La première étape lors de l'utilisation de BLAST consiste à construire une base de séquences utilisable par BLAST. Le programme formatdb, fourni dans le package BLAST, permet de créer une telle base de données, à partir de séquences stockées au format FASTA. Supposons que l'on souhaite formater le fichier ecoli.nt contenant un grand ensemble de séquences d'E. coli. La commande nécéssaire est:

    formatdb -i ecoli.nt -p F -o T

    Il est ensuite possible de faire des requètes sur la base ainsi créée. Supposons que notre séquence inconnue soit contenue dans le fichier test.txt, la commande permettant de la comparer aux séquences provenant ecoli.nt est la suivante:

    blastall -p blastn -d ecoli.nt -i test.txt -o test.out

    L'option -p [prg] indique à BLAST le type de comparaison requis (ici une comparaion entre séquences nucléiques). Le résultat de cette commande est dans notre cas stocké dans un fichier nommé test.out. L'option -T permet de sortir ces memes résultats au format HTML.

    Plusieurs parametres permettent de controler le comportement de BLAST. Par exemple, recherchons les homologues d'une séquence nucléotidique contenue dans le fichier K03455seqref.fas (format FASTA), avec un seuil égal à 0.15 (E-value < 0.15), dans la base GenBank (supposons celle-ci installée en local). Pour cela, on souhaite utiliser 10 processeurs (-a 10), et afficher aux environs de 5000 résultats, sans aucun alignements (-b 0). La commande nécéssaire est la suivante:

    	
    blastall -p blastn -d nr -i K03455seqref.fas -a 10 -e 0.15 -v 5000 -b 0
    

    Notons que blastall ne permet pas de choisir l'espèce (l'interface Web du NCBI le permet, au travers d'une requète Entrez).

    pour récupérer une séquence stockée dans une base de données créée avec formatdb :

    fastacmd -d base_de_donnée -s id_sequence

    Seqsblast permet de réaliser la même opération (celui-ci possède une interface web http://analysis.molbiol.ox.ac.uk/pise_html/seqsblast.html).

    Un certain nombre de sites rendent également Blast accessible via une interface web. Il s'agit notamment du Blast-NCBI, ou du Blast-EBI. Voici une copie d'écran du BLAST-EBI :

    La principale différence entre Blast et Blast2 est que ce dernier inclut l'algorithme "gapped BLAST". Celui-ci permet aux gaps (insertion et délétions) d'être introduits dans l'alignement retourné.

    On notera qu'il est possible de faire un BLAST contre sur les données du génome humain en utilisant par exemple cet outil

    signification des résultats BLAST

    Pour évaluer si un alignement donné constitue la preuve d'une homologie entre les 2 séquences, il est souvent nécéssaire de savoir la probabilité avec laquelle cet alignement aurait pu être obtenu "par chance". Cela signifie que l'on cherche a savoir la valeur de cette probabilité si la séquence était comparée avec (1) une séquence non homologue, (2) une séquence homologue mais complétement mélangée, (3) une séquence issue d'un modèle réaliste de séquences, tenant compte par exemple des différences avérées de compositions en bases. http://www.ncbi.nlm.nih.gov/BLAST/tutorial/Altschul-1.html

    PSI-BLAST

    PSI-BLAST (Position-Specific Iterative BLAST) is a protein BLAST search that uses a PSSM (position-specific scoring matrix) as a query instead of an individual sequence. However, it generally isn?t used this way directly. PSI-BLAST includes a user interface to do an iterated search with an individual sequence, and it begins like a regular protein BLAST search. However, the process assumes that some, but not all, of the matches of interest will be found in this first search. The more distant and possibly more interesting homologies may be missed. Next, PSI-BLAST constructs a PSSM from the relevant hits (which you have to determine based on their annotation), and repeats the search. This time, the PSSM is more sensitive and can pull in new distantly related sequences. This can be iterated several times until either no new matches are found or the search finds too many false positives.

    FASTA

    Les programmes FASTA sont disponibles à l'adresse suivante. Exemple d'utilisation de FASTA : aligner une séquence au format FASTA contenue dans le fichier sequence.seq sur une banque de séquences contenue dans banque.seq. Voila la commande correspondante :

    fasta sequence.seq banque.seq -A -a -Q -b1 -w 80 -E 10
    

    La signification des options est la suivante :

    -bX permet de n'afficher que les X résultats
    -wY permet de limiter la taille des lignes à Y caractères
    -A force l'utilisation de l'algorithme Smith-Waterman pour les séquences nucléiques
    -a affiche les deux séquence dans leur intégralité
    -E Z permet de limiter le nombre de scores et d'alignements (10.0 par défaut)
    -Q permet de lancer Fasta en mode non interactif

    Table 4.1. Les programmes d'alignements locaux du package FASTA3x

    programme description
    fasta3 aligne une séquence protéique contre une banque de séquences protéiques, ou une séquence nucléique contre une banque de séquences nucléiques
    ssearch3 même fonctionalité que fasta3 mais utilise l'algorithme Smith-Waterman : sensibilité accrue, pour des performances fortement dégradées
    fastx3/ fasty3 compare une séquence nucléique à une base de données de séquences protéiques, dans les 3 cadres, et en autorisant les gaps et les changements de cadres.
      

    Ressources:

    Cours de Bioinformatique (LES BANQUES DE SEQUENCES BIOLOGIQUES, LA RECHERCHE DE SIMILITUDES ENTRE SEQUENCES) par Christian Fondrat

    Alignments globaux

    Table 4.2. les programmes gratuits d'alignement global entre 2 séquences

    programme provenance description
    align FASTA alignement global de 2 séquences par l'algorithme de Myers & Miller, AVEC pénalisation pour l'introduction de gaps en fin de séquences. Ceci signifie que le programme peut être forcé à ne pas introduire de gaps en fin de séquences, en instaurant des pénalités élevées.
    align0 FASTA alignement global de 2 séquences par l'algorithme de Myers & Miller, SANS pénalisation pour l'introduction de gaps en fin de séquences.
    needle EMBOSS alignement global de 2 séquences par l'algorithme Needleman-Wunsch
    stretcher EMBOSS Alignement global par l'algorithme Myers & Miller. Infos complémentaires

    Exemple d'utilisation du programme Stretcher :

    $ stretcher -sequencea s1 -sequenceb s2 
    
    
     hbahum                                              141  vs.
     hbbhum                                              146 
     scoring matrix: BLOSUM62, gap penalties: 12/2
     43.2% identity;         Global alignment score: 272
    
                     10        20        30        40         50        
     hbahum V-LSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHF-DLSH-----GSA
            : :.: .:. : : ::::  .. : :.::: :... .: :. .:  : :::      :. 
     hbbhum VHLTPEEKSAVTALWGKV--NVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNP
                    10          20        30        40        50        
    
                 60        70        80        90       100       110   
     hbahum QVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHL
            .::.:::::  :.....::.:.. .....::.::. ::.::: ::.::.. :. .:: :.
     hbbhum KVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHCDKLHVDPENFRLLGNVLVCVLAHHF
            60        70        80        90       100       110        
    
                120       130       140 
     hbahum PAEFTPAVHASLDKFLASVSTVLTSKYR
              :::: :.:. .: .:.:...:. ::.
     hbbhum GKEFTPPVQAAYQKVVAGVANALAHKYH
           120       130       140      
    
    

    Alignements multiples

    Le programme Clustalw permet de réaliser des alignements multiples à partir de fichiers de séquences (au format fasta par exemple). Pour information, ClustalW est le successeur du programme ClustalV. ClustalW est disponible à cette adresse. Le programme ClustalX fournit une interface graphique à ClustalW, et permet notamment d'analyser les résultats de manière plus visuelle. Il est disponible à l'adresse ftp://ftp-igbmc.u-strasbg.fr/pub/ClustalX

    Figure 4.1. ClustalX

    Il existe d'autres éditeurs d'alignement, par exemple Jalview disponible à l'adresse http://www2.ebi.ac.uk/~michele/jalview/contents.html

    Recherche de motifs

    Utiliser les expressions régulières Perl

    Les expressions régulières du langage Perl peuvent permettre de trouver un motif particulier au sein d'une séquence donnée. Pour trouver des sites d'enzymes de restriction commes EcoRI (GAATTC) ou HindII (AAGCTT) :

    
    
    
    # usage : ecori.pl < my.seq où my.seq contient seulement une séquence de nucléotides
      while ( <> ) {
         chomp;
         if ($_ =~ m/GAATTC/){
            print "Trouvé un site EcoRI site!\n";
            $sites++;
         }
       }
       print "Il y a $sites sites EcoRI dans la séquence.\n"
    
    

    Il existe plus d'un millier d'enzymes de restrictions. Les descriptions de celles-ci peuvent être trouvées sur REBASE à l'adresse http://www.neb.com/rebase/rebase.html.

    Autre exemple, trouver les sites de méthylation. Il s'agit de sites de la forme (Pu-C-X-G), soit dans l'ordre : une purine (A ou G), un C, n'importe quelle base, puis un G.

    
    
    
    
    # usage : ecori.pl < my.seq où my.seq contient seulement une séquence de nucléotides
      while ( <> ) {
         chomp;
         if ($_ =~ /[GA]C.?G/){
            print "Trouvé un site de methylation!\n";
            $sites++;
         }
       }
       print "Il y a $sites sites de méthylation dans la séquence.\n"
    
    

    On notera au passage qu'en Perl, le . matche n'importe quel caractère, tandis que le ? précise que l'on cherche 0 ou 1 occurence du caractère spécifié précedemment.

    Utiliser une structure de données de type "trie" (de retrieval)

    Un "trie" (prononcer try) est une structure de données arborée, dans laquelle les noeuds représentent une lettre. Le "trie" est en général utilisé pour indexer et mémoriser des données. Une fois la structure de données créée, le trie peut être également utilisé pour completer des mots dont seul le début est donné. Un module Perl implementant un Trie existe a l'adresse http://www.cpan.org/authors/id/A/AV/AVIF/.
    use Tree::Trie;
    use strict;
    
    my($trie) = new Tree::Trie;
    $trie->add(qw[aeode calliope clio erato euterpe melete melpomene mneme polymnia terpsichore thalia urania]);
    my(@all) = $trie->lookup("");
    my(@ms)  = $trie->lookup("m");
    $" = "--";
    print "All muses: @all\nMuses beginning with 'm': @ms\n";
    my(@deleted) = $trie->remove(qw[calliope thalia doc]);
    print "Deleted muses: @deleted\n";
    
    

    Détection de STS (Sequence Tagged Site)

    Un STS est une portion d'ADN d'une longueur comprise entre 200 et 300 bp, dont les extrémités 3' et 5', long de 20 à 30 bp, n'apparaissent qu'une seule fois à l'interieur d'un même génome. Sachant qu'il existe plusieurs centaines de milliers de STS dans les bases de données, le problème est de trouver quels STS sont contenus dans une portion d'ADN donnée (fraichement séquencée) par exemple, afin d'en déterminer la position sur la carte génomique. Pour cela, il est commode d'utiliser une structure de données nommée "keyword tree", associé à un algorithme nommé Aho-Corasick.

    - Parsing Protein Domains with Perl, par James Tisdall. Exemple d'utilisation de Perl pour la reconnaissance de domaines protéiques à partir de la banque PROSITE.

    Réseaux de neurones

    Le NetPhos WWW server , à base de réseau de neurones multi-couches, permet de détecter (prédire) les sites de phosphorylation serine, threonine, et tyrosine chez les protéines eucaryotes.

    Splice Site Prediction by Neural Network

    Utilisation de profils

    L'alignement de plusieurs séquences (nucléiques ou protéiques) indique les positions très conservées, ainsi que d'importantes informations sur le degré avec lequel gaps et insertions sont permis a certains emplacements. La méthode d'alignement par profil, introduite par Gribskov en 1987, tire parti d'un alignement multiple existant (donc de référence) pour l'alignement de nouvelles séquences homologues. Les méthodes d'alignement par profil utilisent des scores spécifiques d'une position. Dans la version simple de l'analyse par profil, le score d'un acide aminé (ou d'un nucléotide) est simplement donné par sa fréquence d'apparition à cette position dans l'alignement de référence. Ainsi, si l'on considère l'alignement de référence suivant :
    T A T A A T
    - A T A C T
    T A T A A A
    C A G A A T
    T G T A - T
    T - A C G T
    G C T A A T
    
    Si l'on compte, pour chaque nucléotide et pour chaque position, le nombre de fois ou il est présent, on obtiens :
    A : 0 4 1 6 4 1
    C : 1 1 0 1 1 0
    G : 1 1 1 0 1 0
    T : 4 0 5 0 0 6
    
    Supposons que l'on reçoive une nouvelle séquence, le but est de savoir si celle-ci "colle" à l'alignement. POur cela, on utilise un dérivé de l'algorithme Smith-Waterman. Dans un premier temps on calcule les fréquences relatives par colonnes f(i, x). Le lettres de la séquence "query" sont simplement alignées contre les colonnes du profil.

    Détection, prédiction et annotation de gènes

    Il existe à ce jour un grand nombre de programmes permettant de faire de la prédiction de gènes. Au lieu d'en utiliser un seul et unique, la stratégie des chercheurs chargés du séquençage du génome humain les utilisent tous ensembles, et choisissent les résultats correspondant à un consensus. Parmi ces programmes se trouvent :

    GenScan : un programme d'identification de gènes permettant d'annlyser les séquences DNA d'une grande variété d'organismes (humains, autres vertébrés, invertébrés, plantes). Il s'agit d'un logiciel gratuit, disponible en version "standalone" à l'adresse suivante. Il existe également un serveur Genescan avec une interface web permettant de soumettre des séquences, à l'adresse suivante. Notons que le module BioPerl Bio::Tools::Genscan (documenté ici) permet de parser facilement un fichier de sortie de GenScan.
    GeneId : geneid is a program to predict genes along a DNA sequence in human and others vertebrates organisms as well as in Drosophila. While its accuracy compares favorably to that of other existing tools,geneid is more efficient in terms of speed and memory usage and it offers some rudimentary support to integrate predictions from multiple source. Disponibilité : GeneId
    MZEF
    GRAIL 2
    FGENES

    Mais la stratégie la plus simple en l'absence de ces programmes est d'utiliser la notion d'homologie. En effet, si une séquence données presente une forte homologie avec un gène existant, il y a fort a parier qu'il s'agit également d'une région codante. Les programmes classiques de comparaison de séquences, tels que Blast, Fasta, sont tout adapté pour effectuer ce genre de travail. On notera que les EST fournissent aussi un moyen efficace de répérer des séquences codantes. Pour cela, il suffit d'effectuer un blast de la séquence inconnue contre une base d'EST. S'il y a match, il est fort probable que la séquence inconnué soit exprimée. annotation de gènes les expressions régulières et leurs limites les matrices et leur limites exemple en perl (ou sed) trouver un motif particulier (ex queue poly-A)

    Recherche de mini/micro satellites et de séquences répétées en tandem

    Programmes permettant de détecter des séquences répétées en tandem (pas trop larges) :
    - TRF (tandem repeats finder) written by Dr Gary Benson
    - mreps written by Gregory Kucherov
    - etandem and equicktandem from the EMBOSS package (http://www.hgmp.mrc.ac.uk/Software/EMBOSS/Apps/etandem.html)
    Une manière plus "manuelle" de détecter les séquences répétées en tandem est de réaliser un dotplot d'une séquence contre elle-même. Pour cela, on pourra par exemple utiliser le programme "dottup" de EMBOSS.

    Clustering d'EST

    Un EST est un petit fragment d'un gène entier, un morceau d'un clone cDNA ayant été séquencé. Ces ESTs sont séquencés en masse, mais malheurement partiellement traités. Lorsque l'on parle de clustering d'EST, il ne s'agit pas de clustering au sens classique du terme (classification), mais plutot de rassembler dans de mêmes "sacs" les EST correspondant aux mêmes gènes. L'interet est que ces ESTs, une fois caractèrisés, sont des outils forts utiles dans une perspective de découverte de gènes, d'études d'expression ou de régulation.

    Le clustering d'EST peut être effectué de la manière suivante : on rassemble (regrouper) les EST correspondant à une même séquence codante. Ceci peut être fait en utilisant des programmes connus de manière itérative, tels que Blast ou Fasta. Par exemple, on effectue un BLAST d'un EST contre la banque d'EST a regrouper, on garde l'EST (ou les 2 EST) trouvé qui overlappe l'EST initial de manière optimale, et on recommence la procédure au début, en enlevant (sans remise) de la banque la séquence à comparer. En fin de procédure, on a une partie codante composée de plusieurs EST se chevauchant.

    Les outils intégrés d'analyse de séquences

    Ressources:

    GeneMine Système intégré d'analyse de séquences, utilisant les ressources disponibles sur le web (mettre une photo d'écran) (les services)
    EMBOSS The European Molecular Biology Open Software Suite. Il s'agit d'une "suite" de logiciels, analogue au package GCG. La liste des applications de cette "suite" est particulièrement importante, et grossit de manière constante. Cette liste est disponible à l'adresse http://www.uk.embnet.org/Software/EMBOSS/Apps/index.html. Par exemple, les programmmes getorf ou plotorf permettent de répérer les ORF de manière simple au sein d'une séquence.
    %> entret htg_mus:AC092094_v6_c8
    Reads and writes (returns) flatfile entries
    Output file [ac092094_v6_c8.entret]: 
    %> more ac092094_v6_c8.entret
    %> seqret htg_mus:AC092094_v6_c8       
    Reads and writes (returns) sequences
    Output sequence [ac092094_v6_c8.fasta]: 
    %> more ac092094_v6_c8.fasta
    >AC092094_v6_c8 Mus musculus clone RP23-261m19, WORKING DRAFT SEQUENCE, 8
    unordered pieces.
    CAGGACAGCCAGGGCTACACAGAGAAACCCTGTCTCAAAAAACAAAAAAACAAAAAAAAA
    ACAAAAGAAGAAGAAAATGTCTGTGAATACCCTGGAAAAGTTACTCAGTGAAAGTAGATG
    AGTCCCTGAGTCAGTGACAGGAAGTGAGTGCAGTCTGAGCACTGGCTTGTGACCAATGAC
    AAAAACATAAGCTAGACTTGCTCTGCAAAGTGGAGGACAGAACAGACAAAGCCCCAGAGT
    
    dbifasta permet d'indexer une série de fichier au format FASTA. seqret et entret permettent alors de récupérer des séquences. Notons qu'un GUI existe pour EMBOSS, basé sur kaptain.
    SRS The Sequence Retrieval System. SRS permet d'explorer le contenu de bases de données au travers d'une interface web conviviale, d'explorer les liens vers les autres bases et de lancer des analyses sur les données récupérées. SRS est disponible gratuitement pour les académiques.

    Ensembl : SI permettant l'annotation automatique (production et maintenance) de génomes eucaryotiques http://www.ensembl.org

    Chapter 5. Evolution des génomes et analyse phylogénétique

    Pour construire un arbre phylogénétique à partir de séquences nucléotidiques, il faut tout d'abord aligner ces séquences, de façon à faire correspondre les positions dans la séquences ayant une origine communes.

    Contruire des alignements multiples

    Le programme CLUSTALW est le plus connu et le plus utilisé des programmes d'alignement multiple. Il peut s'avérer nécessaire de remplacer les gaps (-) par des caractères inconnus (?). Une solution est dr emplacer dans emacs (avec ESC-%), néanmoins celle-ci peut s'avérer fastidieuse. Une autre solution est d'utiliser la ligne de Perl suivante :
    perl -pi -e 's/-/\?/g' *.phy

    Les principales méthodes de reconstruction phylogénétique

    Parcimonie

    A chaque fois qu'un arbre est généré, il est évalué selon le critère

    Evolution minimum

    L'algorithme de reconstruction optimise le critère

    Maximum de vraisemblance

    Les principaux outils de reconstruction phylogénétique

    PHYLIP

    PHYLIP est téléchargeable à l'adresse http://evolution.genetics.washington.edu/phylip.html. PHYLIP est également disponible en tant que membre du package EMBOSS, mais soumis aux conditions de licence initiale. Les programmes PHYLIP-EMBOSS sont plus facilement integrables dans des scripts d'automatisation. Par exemple, pour obtenir à l'écran la matrice de distances K2P d'une série de séquences contenues dans un fichier nommé iglc.phy, on utilise la ligne de commande suivante :
    ednadist iglc.phy stdout -method Kimura -matrix S -ttratio 2.0
    
    ce qui produira un résultat du type :
    Nucleic acid sequence Distance Matrix program
    Kimura
        7
    C1          0.0000  0.0540  0.0718  0.2162  0.1590  0.0541  0.0686
    C2          0.0540  0.0000  0.0297  0.2128  0.1657  0.0469  0.0471
    C3          0.0718  0.0297  0.0000  0.2051  0.1744  0.0576  0.0508
    C4          0.2162  0.2128  0.2051  0.0000  0.2467  0.2012  0.1933
    C5          0.1590  0.1657  0.1744  0.2467  0.0000  0.1542  0.1593
    C6          0.0541  0.0469  0.0576  0.2012  0.1542  0.0000  0.0617
    C7          0.0686  0.0471  0.0508  0.1933  0.1593  0.0617  0.0000
    
    FastDNAMl est une alternative rapide à DNAML. Téléchargeable à l'adresse http://geta.life.uiuc.edu:80/~gary/programs/fastDNAml/,il s'emploie de la manière suivante :
    fastdnaml < ighv.phy > ighv.tree
    

    Qu'est-ce que PHYLIP?

    PHYLIP est une suite de programmes informatiques permettant de faire de la reconstruction phylogénétique, c'est-à-dire de retrouver l'arbre d'évolution d'une série de séquences nucléotidiques ou protéiques.PHYLIP est directement disponibles sur le web l'adresse http://evolution.genetics.washington.edu/phylip.html, ainsi que dans le package EMBOSS à l'adresse http://www.hgmp.mrc.ac.uk/Software/EMBOSS/ (sous forme de package EMBASSY, c'est-à-dire qu'ils ne sont pas astreint aux condition de licenses des autres programmes EMBOSS). La version EMBOSS est sensiblement plus simple à utiliser en ligne de commande, et peut plus facilement être intégrée dans des scripts ou programmes externes.

    Quels sont les principaux programmes informatiques de reconstruction phylogénétique dans PHYLIP ?

    Il existe trois grands type de méthodes en reconstruction phylogénétique : les méthodes de parcimonie, les méthodes de distances, et les méthodes de vraisemblance. L'objectif des méthodes de parcimonie est de trouver l'arbre induisant le minimum d'évènements de mutations (substitutions) entre les séquences observées. Celui des méthodes de distances est de retrouver un arbre à partir d'une matrice de distances calculée à partir des séquences, et suivant un modèle de substitution déterminé. Enfin, l'objectif des méthodes de vraisemblances est de trouver l'arbre maximisant la probabilité d'observer les séquences étudiées. La plupart des programmes présent dans PHYLIP implémentent l'une ou l'autre de ces méthodes. Les plus utilisés sont les suivants :

    Table 5.1. 

    DNAPARSpermet de retrouver le ou les arbres optimisant un critère de parcimonie
    DNADIST calcule une matrice de distance à partir de séquences nucléotidiques 
    FITCH calcule la matrice de distance d'arbre (et donc l'arbre) la plus proche (au sens des moindres carrés) d'une matrice de distances observées 
    NEIGHBOR implémente l'algorithme NJ, et permet donc de retrouver un arbre à partir d'une matrice de distance de façon à optimiser un critère d'évolution minimum 
    WEIGHBOR implémente une version modifiée de NJ instaurant une pondération sur les longues branches, de façon à minimiser leur effet généralement néfaste.
    FASTDNAML permet de retrouver l'arbre optimisant un critère de maximum de vraisemblance. 

    Les algorithmes implémentés par ces programmes sont décrits de manière abordable dans le Chapitre 11 de Molecular Systematics (édité par Hillis et al, écrit par Swofford et al). Molecular Evolution and Phylogenetics (écrit par Nei et Kumar, 2000) est également un ouvrage de référence dans le domaine. Plus modestement, l'article publié dans TSI par Caraux et al nommé "Approches informatiques de la reconstruction d'arbres phylogénétiques à partir de données moléculaires" fournit néanmoins une bonne introduction aux algorithmes et stratégies utilisés en reconstruction phylogénétique.

    Quel est les opérations à effectuer pour obtenir un arbre à partir de séquences nucléotidiques?

    Cela dépend de la méthode de reconstruction utilisée :

    Si l'on utilise une méthode de parcimonie ou une méthode de vraisemblance, les étapes seront les suivantes : 1. aligner les séquences pour obtenir un fichier au format PHYLIP 2. construire un arbre à partir des séquences alignées 3. visualiser l'arbre

    Si l'on utilise une méthode de distance, celles-ci seront : 1. aligner les séquences pour obtenir un fichier au format PHYLIP 2. construire une matrice de distances à partir des séquences nucléotidiques alignées 3. construire un arbre à partir de ces distances 4. visualiser l'arbre

    Quel est le format de données en entrée des programmes PHYLIP?

    Les programmes du package PHYLIP original ne gèrent que le format PHYLIP. Le package PHYLIP distribué sous EMBOSS En voici un exemple:
            7       50
    C1         GCCAACCCCA CGGTCACTCT GTTCCCGCCC TCCTGGAGCT CCAAGACAAG
    C2         GCTGCCCCCT CGGTCACTCT GTTCCCGCCC TCCTGGAGCT TCAAGACAAG
    C3         GCTGCCCCCT CGGTCACTCT GTTCCCACCC TCCTGGAGCT TCAAGACAAG
    C4         GAGACACCTT CATCTCCTCT GACCCCAGAG GCAGGGAGCT CCAAGACAAG
    C5         GCCACCCCCT TGGTCACTCT GTTC---CCC TCCTGGAGCT CCAAGACAAG
    C6         GCTGCCCCAT CGGTCACTCT GTTCCCGCCC TCCTGGAGCT TCAAGACAAG
    C7         GCTGCCCCCT CGGTCACTCT GTTCCCACCC TCCTGGAGCT TCAAGACAAG
    
               GCCACACTAG TGTGTCTGAT CAGTGACTTC TACCCGGGAG CCTTGGAAGG
               GCCACACTGG TGTGTCTCAT AAGTGACTTC TACCCGGGAG CCTTGGAAAG
               GCCACACTGG TGTGT-TCAT AAGTGACTTC TACCCGGGAG CCCTGGAAGG
               GCCACAATGG TGTGTCTCAT GAGTGACTTC TACCCGAGAG CCCTGGAAGA
               GCCATGCTGG TGTGTCTCAT AAATGACTTC TACCCAGGAG CCATAGAAGG
               GCCACACTGG TGTGCCTGAT CAGTGACTTC TACCCGGGAG CCCTGGAAGG
               GCCACACTGG TGTGTCTCGT AAGTGACTTC TACCCGGGAG CCCTGGAAGG
    Ce format, décrit dans la documentation de PHYLIP, correspond à la description suivante : la première ligne d'un fichier au format PHYLIP contient le nombre de séquences, suivi de la taille de ces séquences (les séquences ayant été alignées, elles ont nécéssairement toutes la même taille). Viennent ensuite les informations concernant chaque espèce (ou gène), avec en premier lieu le nom de l'espèce sur 10 caractères, suivi d'une premi. Les espaces présents tous les dix sites sont simplement destinés à faciliter la lecture des séquences, et sont donc optionnels. Dans l'exemple ci-dessus, les données sont de type "interleaved", c'est à dire que les données d'une même séquences peuvent se trouver sur des lignes différentes. Un fichier PHYLIP de type "sequential" contient tous les sites d'une même séquence sur une seule ligne (voir ci-dessous).
            7       50
    C1         GCCAACCCCA CGGTCACTCT GTTCCCGCCC TCCTGGAGCT CCAAGACAAG GCCACACTAG TGTGTCTGAT CAGTGACTTC TACCCGGGAG CCTTGGAAGG
    C2         GCTGCCCCCT CGGTCACTCT GTTCCCGCCC TCCTGGAGCT TCAAGACAAG GCCACACTGG TGTGTCTCAT AAGTGACTTC TACCCGGGAG CCTTGGAAAG
    C3         GCTGCCCCCT CGGTCACTCT GTTCCCACCC TCCTGGAGCT TCAAGACAAG GCCACACTGG TGTGT-TCAT AAGTGACTTC TACCCGGGAG CCCTGGAAGG
    C4         GAGACACCTT CATCTCCTCT GACCCCAGAG GCAGGGAGCT CCAAGACAAG GCCACAATGG TGTGTCTCAT GAGTGACTTC TACCCGAGAG CCCTGGAAGA
    C5         GCCACCCCCT TGGTCACTCT GTTC---CCC TCCTGGAGCT CCAAGACAAG GCCATGCTGG TGTGTCTCAT AAATGACTTC TACCCAGGAG CCATAGAAGG
    C6         GCTGCCCCAT CGGTCACTCT GTTCCCGCCC TCCTGGAGCT TCAAGACAAG GCCACACTGG TGTGCCTGAT CAGTGACTTC TACCCGGGAG CCCTGGAAGG
    C7         GCTGCCCCCT CGGTCACTCT GTTCCCACCC TCCTGGAGCT TCAAGACAAG GCCACACTGG TGTGTCTCGT AAGTGACTTC TACCCGGGAG CCCTGGAAGG
    
    
    
    
    
    

    Comment aligner des séquences au format FASTA et obtenir un fichier au format PHYLIP?

    Aligner des séquences au format FASTA peut être effectué au moyen du programme informatique CLUSTALW. Par exemple, si l'on souhaite aligner les séquences contenues dans iglc.seq, on utilisera la commande suivante sous Unix :
    $ clustalw iglc.seq
    Par défaut, CLUSTALW produit des fichiers au format .aln (ici donc un fichier nommé iglc.aln), c'est à dire au format suivant :
     CLUSTAL W (1.8) multiple sequence alignment
    
    C1         GCCAACCCCACGGTCACTCTGTTCCCGCCCTCCTGGAGCTCCAAGACAAG
    C2         GCTGCCCCCTCGGTCACTCTGTTCCCGCCCTCCTGGAGCTTCAAGACAAG
    C3         GCTGCCCCCTCGGTCACTCTGTTCCCACCCTCCTGGAGCTTCAAGACAAG
    C4         GAGACACCTTCATCTCCTCTGACCCCAGAGGCAGGGAGCTCCAAGACAAG
    C5         GCCACCCCCTTGGTCACTCTGTTC---CCCTCCTGGAGCTCCAAGACAAG
    C6         GCTGCCCCATCGGTCACTCTGTTCCCGCCCTCCTGGAGCTTCAAGACAAG
    C7         GCTGCCCCCTCGGTCACTCTGTTCCCACCCTCCTGGAGCTTCAAGACAAG
               *     **        *****  *       *  ****** *********
    
    C1         GCCACACTAGTGTGTCTGATCAGTGACTTCTACCCGGGAGCCTTGGAAGG
    C2         GCCACACTGGTGTGTCTCATAAGTGACTTCTACCCGGGAGCCTTGGAAAG
    C3         GCCACACTGGTGTGT-TCATAAGTGACTTCTACCCGGGAGCCCTGGAAGG
    C4         GCCACAATGGTGTGTCTCATGAGTGACTTCTACCCGAGAGCCCTGGAAGA
    C5         GCCATGCTGGTGTGTCTCATAAATGACTTCTACCCAGGAGCCATAGAAGG
    C6         GCCACACTGGTGTGCCTGATCAGTGACTTCTACCCGGGAGCCCTGGAAGG
    C7         GCCACACTGGTGTGTCTCGTAAGTGACTTCTACCCGGGAGCCCTGGAAGG
               ****   * *****  *  *   * **********        * ***
    Pour obtenir un un fichier au format PHYLIP en sortie, il suffit de lui préciser le type de sortie souhaité gràce à l'option -output. la commande est :
    $ clustalw iglc.seq -output=phylip
    En sortie, le fichier iglc.phy contient les séquences alignées.   Dans le cas où les séquences auraient été préalablement alignées, et stockées dans un format différent du format PHYLIP (par exemple au format ALN ou MSF), il existe des convertisseurs de format tels que readseq, ou bien des éditeurs d'alignements multiples comme seaview, ou GENEDOC. readseq est certainement le plus simple d'utilisation, ainsi pour transformer un fichier au format MSF nommé iglc.msf en un fichier au format PHYLIP nommé iglc.phy, la commande est :
    $ readseq iglc.msf -format=phylip -output=iglc.phy

    Comment calculer une matrice de distance à partir de séquences nucléotidiques ou protéiques ?

    Comme le montre l'exemple ci-dessous, une matrice de distance est simplement un tableau de distances prises 2 à 2. Le calcul d'une distance entre 2 séquences repose sur un modèle de substitution définissant la probabilité de passer d'un nucléotide à un autre au cours d'un temps très court. Il existe de nombreux modèles de substitutions : le plus simple d'entre eux, le modèle de Jukes-Cantor définit de manière uniforme la probabilité de passer d'un nucléotide à l'autre. Le plus utilisé à l'heure actuelle, le modèle de Kimura à deux paramètres, differencie les probabilités de transitions et de transversions. On notera dans l'exemple ci-dessous qu'une matrice de distance est symétrique : les distances de part et d'autres de la diagonale sont identiques.
        7
    C1          0.0000  0.0549  0.0703  0.2196  0.1673  0.0549  0.0701
    C2          0.0549  0.0000  0.0286  0.2206  0.1742  0.0435  0.0507
    C3          0.0703  0.0286  0.0000  0.2072  0.1834  0.0511  0.0508
    C4          0.2196  0.2206  0.2072  0.0000  0.2498  0.1986  0.1975
    C5          0.1673  0.1742  0.1834  0.2498  0.0000  0.1621  0.1656
    C6          0.0549  0.0435  0.0511  0.1986  0.1621  0.0000  0.0587
    C7          0.0701  0.0507  0.0508  0.1975  0.1656  0.0587  0.0000
      Dans PHYLIP, le programme DNADIST  permet de calculer une matrice de distance entre séquences nucléotidiques:
    $ dnadist
    dnadist:  can't read infile
    Please enter a new filename>
    Ici on rentrera un nom de fichier au format PHYLIP, par exemple iglc.phy. Le menu suivant s'affiche alors à l'écran :
    Nucleic acid sequence Distance Matrix program, version 3.573c
    
    Settings for this run:
      D  Distance (Kimura, Jin/Nei, ML, J-C)?  Kimura 2-parameter
      T        Transition/transversion ratio?  2.0
      C   One category of substitution rates?  Yes
      L              Form of distance matrix?  Square
      M           Analyze multiple data sets?  No
      I          Input sequences interleaved?  Yes
      0   Terminal type (IBM PC, VT52, ANSI)?  ANSI
      1    Print out the data at start of run  No
      2  Print indications of progress of run  Yes
    
    Are these settings correct? (type Y or letter for one to change)
    Il est également possible de changer les paramètres de calcul et de présentation des résultats en tapant la lettre associée. Par exemple, il est possible de changer de modèle de substitution en tapant d (on notera toutefois que le modèle par défaut, le modèle "Kimura 2-parameter", fournit de bons résultats sur la plupart des jeux de données). Si tous les paramètres sont corrects, on tape y pour continuer et lancer le calcul. La matrice de distances ainsi calculée est stockée dans le fichier nommé outfile.

    Comment générer un arbre à partir de distances entre séquences?

    Le programme neighbor (qui implémente l'algorithme "Neighbor Joining") permet de générer un arbre à partir de distances entre séquences. IMPORTANT : avant de lancer ce programme, il faut s'assurer que les distances sont stockées dans un fichier dont le nom est différent de outfile (car celui-ci sera écrasé au cours de la procédure). Pour renommer outfile en dists, on utilisera la commande suivante :
    $ mv outfile dists
    On lance ensuite NEIGHBOR :
    $ neighbor
    neighbor:  can't read infile
    Please enter a new filename>
    Ici on tapera le nom du fichier contenant les distances. Le menu suivant s'affiche :
    Neighbor-Joining/UPGMA method version 3.5
    
    Settings for this run:
      N       Neighbor-joining or UPGMA tree?  Neighbor-joining
      O                        Outgroup root?  No, use as outgroup species  1
      L         Lower-triangular data matrix?  No
      R         Upper-triangular data matrix?  No
      S                        Subreplicates?  No
      J     Randomize input order of species?  No. Use input order
      M           Analyze multiple data sets?  No
      0   Terminal type (IBM PC, VT52, ANSI)?  ANSI
      1    Print out the data at start of run  No
      2  Print indications of progress of run  Yes
      3                        Print out tree  Yes
      4       Write out trees onto tree file?  Yes
    
    Are these settings correct? (type Y or the letter for one to change)
    Il n'y a généralement aucun paramètre à modifier à ce stade. On tape donc "y" pour calculer l'arbre. L'arbre obtenu est stocké sous format Newick dans le fichier treefile, et sous forme plus "visuelle" dans le fichier outfile. Voici un exemple d'arbre au format Newick :
    
    (VR-V6:0.11682,VR-V8:0.06318,((VR-V1:0.06853,(VR-V2:0.01681,
    VR-V4:0.03669):0.03887):0.00814,((VR-V3:0.01653,(VR-V5:0.02734,
    VR-V5P:0.04446):0.00437):0.03987,VR-V7:0.06190):0.01172):0.00775);

    Comment visualiser un arbre de manière graphique?

    Pour visualiser un arbre de manière graphique, on peut utiliser les programmes DRAWTREE et DRAWGRAM de PHYLIP.  Ces deux programmes permettent de générer un fichier Postscript contenant la représentation graphique d'un arbre à partir du même arbre au format Newick, issu de NEIGHBOR ou d'un autre programme de reconstruction. DRAWTREE permet de dessiner des arbres non enracinés, tandis que DRAWGRAM permet de dessiner des arbres enracinés (également appelés dendrogrammes). Ces deux programmes permettent de dessiner des arbres en prenant en compte ou pas les longueurs de branches. Rappelons que les longueurs de branches représentent la différence (la distance évolutive) entre espèces ou gènes. Elle apportent donc de l'information lors de la visualisation. Néanmoins, l'expérience montre que si certaines de ces distances sont trop petites relativement aux autres, l'arbre obtenu peut être difficilement lisible du fait du chevauchement des noms de gènes et des branches. Les interfaces de DRAWTREE et DRAWGRAM  sont similaires. Prenons le cas de DRAWTREE :
    $ drawtree
    Si un fichier treefile contenant un arbre au format Newick est présent dans le répertoire courant, il sera automatiquement utilisé par DRAWTREE. Sinon il est demandé de spécifier un nom de fichier.

    L'écran suivant s'affiche:

    Which plotter or printer will the tree be drawn on?
    (many other brands or models are compatible with these)
    
       type:       to choose one compatible with:
    
            L         Apple Laserwriter (with Postscript)
            M         MacDraw PICT format
            R         Rayshade 3D rendering program file
            J         Hewlett-Packard Laserjet
            K         TeKtronix 4010 graphics terminal
            H         Hewlett-Packard 7470 plotter
            D         DEC ReGIS graphics (VT240 terminal)
            B         Houston Instruments plotter
            E         Epson MX-80 dot-matrix printer
            C         Prowriter/Imagewriter dot-matrix printer
            O         Okidata dot-matrix printer
            T         Toshiba 24-pin dot-matrix printer
            P         PC Paintbrush monochrome PCX file format
            X         X Bitmap format
            F         FIG 2.0 format
            U         other: one you have inserted code for
     Choose one:
    On choisira (et tapera) "l" pour sortir un fichier Postscript.  

    L'écran suivant s'affiche alors :

    Which type of screen will it be previewed on?
    
       type:       to choose one compatible with:
    
            N         will not be previewed
            K         TeKtronix 4010 graphics terminal
            D         DEC ReGIS graphics (VT240 terminal)
            U         other: one you have inserted code for
     Choose one:
    Rien de particulier ici, car ces options ne concernent pas les ordinateurs et stations de travail modernes : on tape directement "n". L'écran suivant s'affiche alors :
    Here are the settings:
    
     (1)        Use branch lengths:  Yes
     (2)           Angle of labels:  Fixed angle of  0.0 degrees
     (3)          Rotation of tree:  90.0
     (4)     Angle of arc for tree:  360.0
     (5)   Iterate to improve tree:  Yes
     (6)    Scale of branch length:  Automatically rescaled
     (7)        Horizontal margins:  1.73 cm
     (7)          Vertical margins:  2.24 cm
     (8) Relative character height:  0.3333
     (9)       Enthusiasm constant:  0.11111
     (10)           Font          :  Hershey
    
    
     Do you want to accept these? (Yes or No)
     Type Y or N or the number (1-10) of the one to change:

    Pour obtenir un arbre sans longueurs de branche, on tapera "1" puis "y" pour dessiner l'arbre. Pour obtenir un arbre avec longueurs de branche, on tapera directement  "y".

    Le fichier Postscript obtenu se nomme plotfile . La prochaine étape consiste à visionner ce fichier, avec un visualisateur Postcript (xpsview, gv, ghostview, ...). Par exemple:

    $ xpsview plotfile

    Dessiner des arbres phylogénétuques

    Pour afficher un arbre, ou plus précisément le dessiner a l'écran, on peut utiliser les programmes DRAWTREE et DRAWGRAM fournis avec PHYLIP. PHYLODENDRON, disponible à cette adresse, est également une bonne alternative. Notons qu'il existe une interface web pour PHYLODENDRON a l'adresse suivante. Cette interface peut être exploitée dans un programme Perl. Par exemple, le script suivant récupère une image GIF à partir de ce serveur :
    
    sub fint_execPhylodendron {
    
        my ($filename, $title, $style, $tree) = @_;
        
        if (length($tree) < 4) {
    	print "Arbre invalide ...\n";
    	return 0;
        }
        
        $ua = new LWP::UserAgent;
        $ua->agent("AgentName/0.1 " . $ua->agent);
        
        # Create a request
        my $req = POST 'http://iubio.bio.indiana.edu/cgi-bin/treeprint.cgi',
        Content_type 	=> 'form-data',
        Content	  	=> [ 
    			     'gTreeStyles=fStyle' 	=> "$style",
    			     'TREEAPP_FILE_DATA' 	=> [''],
    			     'TREEAPP_STRING_DATA' 	=> "$tree",
    			     'TITLE'			=> "$title",
    			     'TREEAPP_OUTPUT_FORMAT' => 'image/gif',
    			     'TreeDoc.width'		=> '400',
    			     'TreeDoc.height'	        => '400',
    			     'linklabel'		=> 'true',
    			     'TREEAPP_BASEURL'	=> 'http://iubio.bio.indiana.edu/.bin/genbankq.html',
    			     'font.name'		=> 'Helvetica',
    			     'font.style'		=> 'plain',
    			     'font.size'		=> '8',
    			     'gTreeStyles=fVertical' => 'false',
    			     'gTreeStyles=useLengths'=> 'false',
    			     'gTreeStyles=nodeposition' => '1'
    			     ];
        
    # DEBUG
        #print $req->as_string();
        #return 0;
        
    # Pass request to the user agent and get a response back
        my $res = $ua->request($req);
        
    # Check the outcome of the response
        if ($res->is_success) {
    	#print $res->content;
    	open(FILE, ">/tmp/$filename");
    	print FILE $res->content;
    	close FILE;
    	return 1;
        } else {
    	print "Problème de connexion ... \n";
    	return 0;
    	#print $res->content;
        }
        
    }
    
    
    Ressources:
    Molecular Biological Evolution la revue n°1 dans le domaine de la reconstruction phylogénétique et de l'évolution

    Chapter 6. Analyser les données du transcriptome et les données d'expression de gènes

    Techniques de mesure d'expressions de gènes

    cDNA microarrays

    Les microarrays, introduits par Pat Brown de la Stanford University, sont des lamelles de verre sur lesquelles des gouttes microscopiques de cDNA sont déposées à partir d'échantillons pré-préparés, gràce des robots à haute vitesse. Cette technique convient aux analyses de plusieurs milliers de clones cDNA, suite par exemple à des projets de séquençage d'EST. Elle permet donc, comme ce fut le cas pour la levure, l'analyse d'expression de la totalité des gènes d'une espèce. Son autre avantage (par rapport a l'autre technique de micro-array) est que l'on peut placer dans chaque goutte des sondes longues de plusieurs centaines de bases. Les mesures de micro-arrays sont réalisées par hybridisation différentielle, de façon a minimiser les erreurs expérimentales et celles eventuellement dues aux défaut de fabrication : les mRNA de 2 sources differentes (contrôle et analysée), étiquettées avec des encres fluorescentes différentes (rouges et vertes), sont passées sur le micro-array en simultané. Le signal de fluorescence de chacune des populations de mRNA est évalué de manière indépendante, puis utilisé de façon a obtenir un ratio d'expression analysé/contrôle.

    Puces à oligo-nucléotides

    Ces puces sont également des lamelles de verre à la surface desquelles plusieurs milliers d'oligo-nucléotides courts sont attachés. Ces oligos sont directement synthétisés à la surface des lamelles par photolithographie (comme les puces traditionnelles). Affymetrix commercialise des puces de ce type (GeneChips) pour plusieurs milliers de gènes humains, murins ou de levure. Un des derniers GeneChips (01/06/2002) permet d'analyser l'expression de tous les gènes d'Arabidopsis Thaliana, soit environ 24,000 gènes. Il en résulte des jeux de données de 500,000 points à chaque "run", soit une masse de données incroyablement élévée. L'utilisation d'outils informatiques permettant de retrouver les tendances au sein de cette masse de données est donc cruciale.

    RT-PCR

    Pour mesurer l'expression de gène au moyen de la RT-PCR, le mARN est tout d'abord "reverse" transcrit en cDNA, et le cDNA est alors amplifié à des niveaux mesurables, par PCR. Cette méthode requiert des primers PCR pour l'ensemble des gènes étudiés. Elle n'est pas massivement parallèle, contrairement aux micro-arrays et micro-chips, et requiert donc une automatisation poussée. En revanche elle possède une sensitivité accrue par rapport aux autres méthodes.

    Serial Analysis of Gene Expression (SAGE)

    Tout d'abord, du cDNA double brin est créé à partir du mRNA. Un marqueur, long d'environ 10 bp (pour identifier de manière unique chaque gène) est coupé à un endroit spécifique de chaque cDNA. Puis les marqueurs sont concaténés entre eux de façon a former un long et unique brin, qui peut alors être amplifié et séquencé. Cette méthode présente 2 avantages : la séquence de mRNA ne nécessite pas d'etre connue a priori (on peut donc détecter des gènes précedemment inconnus), et elle utilise une technologie de séquençage répandue et maitrisée.

    De nombreux jeux de données sont disponibles sur le web. Par exemple les données d'une expérimentation pour chaque gène de la levure est disponible à l'adresse http://171.65.26.52/yeast_cell_cycle/full_data.html

    Quelles types d'analyses peut-on faire?

    Exemple de jeu de données (issu de cette adresse )
    UID	DLCL-0001	DLCL-0002	DLCL-0003	DLCL-0004	DLCL-0005	DLCL-0006	DLCL-0007	DLCL-0008	DLCL-0009	DLCL-0010	DLCL-0011	DLCL-0012	DLCL-0013	DLCL-0014	DLCL-0015	DLCL-0016	DLCL-0017	DLCL-0018	DLCL-0020	DLCL-0021	DLCL-0023	DLCL-0024	DLCL-0025	DLCL-0026	DLCL-0027	DLCL-0028	DLCL-0029	DLCL-0030	DLCL-0031	DLCL-0032	DLCL-0033	DLCL-0034	DLCL-0036	DLCL-0037	DLCL-0039	DLCL-0040	DLCL-0041	DLCL-0042	DLCL-0048	DLCL-0049
    1	1.042	0.419	1.285	0.883	-0.056	0.603	2.052	0.884	0.508	0.748	1.048	0.842	-0.175	0.217	-0.702	-0.109	NA	0.633	0.918	0.895	0.608	0.303	0.884	0.52	0.19	NA	1.068	1.02	1.515	0.456	0.657	0.585	NA	NA	NA	NA	NA	1.049	1.248	1.253
    2	-0.097	-0.072	0.563	0.151	-1.524	0.034	1.029	0.17	-0.48	-0.071	0.071	0.141	-0.082	0.19	-0.646	-0.029	NA	0.227	0.031	0.094	0.18	-0.357	-0.091	-0.282	-0.313	NA	0.163	0.134	0.708	0.26	-0.036	0.074	NA	NA	NA	NA	NA	0.131	0.693	-0.01
    3	0.339	-0.337	-0.372	-0.054	-1.371	0.123	0.403	-0.068	0.734	0.528	0.691	0.49	0.757	0.34	0.391	0.134	NA	0.212	0.814	NA	0.407	0.523	1.138	-0.247	0.142	NA	0.691	0.428	0.598	1.112	-0.323	0.365	NA	NA	NA	NA	NA	0.522	0.423	0.881
    4	0.028	0.069	0.209	-0.225	-0.518	0.087	-0.737	0.307	0.222	0.01	0.332	0.245	0.398	0.82	0.63	0.371	NA	0.325	0.039	0.113	0.43	0.551	0.046	0.709	0.1	NA	-0.032	-0.162	-0.29	0.276	-1.639	-0.033	NA	NA	NA	NA	NA	-0.883	0.167	0.29
    5	0.977	-0.979	-0.491	-0.185	0.309	-0.478	1.053	0.132	0.228	0.23	-0.751	0.329	-0.457	-0.916	0.408	-0.098	NA	0.556	-0.003	-3.129	0	-0.014	1	-0.129	-0.045	NA	0.076	-0.144	0.018	-0.43	0.368	-0.065	NA	NA	NA	NA	NA	0.492	-0.272	-0.245
    6	0.061	-0.02	0.319	-0.053	1.032	0.516	-0.155	0.305	-0.525	0.208	0.646	0.361	0.715	1.234	0.653	0.511	NA	0.668	0.307	-0.61	0.722	0.452	0.079	0.964	-0.243	NA	0.01	0.258	-0.092	0.179	-0.637	0.173	NA	NA	NA	NA	NA	-0.796	0.22	0.645
    7	0.502	-0.822	-0.21	0.081	0.19	0.089	0.014	0.252	0.642	-0.026	-0.149	0.309	0.78	-0.62	0.578	0.392	NA	0.504	0.577	-0.267	0.129	0.375	0.785	0.222	0.343	NA	-0.398	0.249	0.187	-0.102	0.521	0.246	NA	NA	NA	NA	NA	0.185	0.317	0.669
    8	0.265	-0.257	0.738	-0.415	0.201	-0.359	0.335	0.335	-0.516	-0.502	-0.714	-0.115	-0.23	0.149	0.271	-0.466	NA	-0.001	-0.72	0.111	0.018	0.028	-0.071	-0.447	0.323	NA	-0.49	-0.204	-0.111	-0.136	-0.55	-0.331	NA	NA	NA	NA	NA	-0.831	0.006	0.417
    9	-0.567	-0.487	0.158	-1.215	0.406	-0.648	-1.313	-0.76	-0.245	-0.317	-0.79	0.013	-0.19	0.612	0.759	-0.752	NA	-0.682	-0.291	-0.024	0.876	0.295	0.082	0.177	1.395	NA	-1.059	-0.442	-0.141	-0.708	-0.019	-0.378	NA	NA	NA	NA	NA	-0.879	0.583	0.164
    10	0.64	-0.108	0.48	0.243	0.496	0.143	0.346	0.194	0.133	-0.378	0.48	0.518	1.088	0.891	0.29	0.37	NA	0.85	-0.022	0.626	0.295	-0.415	0.675	0.543	0.732	NA	0.467	0.649	0.307	0.943	-1.134	-0.03	NA	NA	NA	NA	NA	-0.563	-0.787	1.217
    11	0.487	0.094	-0.62	0.073	0.686	0.087	0.193	0.085	0.749	-0.095	0.205	0.177	0.823	0.144	0.532	0.054	NA	0.358	0.277	-0.193	0.732	0.899	0.628	0.951	1.024	NA	0.377	0.217	0.359	-0.04	-0.324	-0.375	NA	NA	NA	NA	NA	0.228	0.434	1.015
    12	-0.71	-0.799	-0.486	-0.636	-0.278	-1.067	-0.317	0.358	-1.742	-1.19	-1.692	-0.451	-0.455	-0.754	-0.895	-0.893	NA	-0.406	-1.075	-0.384	-1.382	-0.559	-0.245	-0.075	-1.268	NA	-0.396	-0.471	-0.526	-0.123	-0.978	-0.674	NA	NA	NA	NA	NA	-0.62	-1.068	-1.035
    14	0.247	0.22	0.111	0.017	0.717	0.157	-0.008	0.258	0.091	0.266	0.709	0.434	0.805	0.841	0.234	0.458	NA	0.935	0.37	1.425	0.312	0.111	0.178	0.296	0.5	NA	-0.097	0.118	0.49	0.163	0.053	-0.147	NA	NA	NA	NA	NA	-3.262	-0.803	0.172
    16	0.511	0.016	0.143	-0.225	0.487	-0.334	-0.648	-0.122	0.268	-0.127	0	0.2	0.472	0	0.585	0.417	NA	0.239	-0.162	-0.286	-0.152	0.203	-0.205	1.148	0.252	NA	-0.097	-0.082	-0.116	0.193	-0.096	-0.351	NA	NA	NA	NA	NA	-1.44	-0.049	0.322
    18	0.263	-0.728	-0.385	-0.436	0.575	-0.018	-1.034	0.888	0.711	0.154	-0.259	0.841	-0.437	0.393	0.275	-0.485	NA	0.216	0.24	-0.068	0.374	0.916	0.576	1.709	0.848	NA	-0.257	-0.068	-0.444	0.11	0.238	0.571	NA	NA	NA	NA	NA	-1.018	0.286	0.908
    20	0.096	-0.688	-0.238	0.652	0.522	-0.096	-0.402	0.526	0.368	0.285	0.83	0.717	-0.746	-0.434	-0.248	-0.017	NA	0.223	-0.296	1.021	-0.606	-0.218	-0.057	0.141	-0.432	NA	1.287	1.189	0.765	-0.022	-0.165	-0.41	NA	NA	NA	NA	NA	-0.681	-1.684	1.126
    22	-0.91	-0.715	-0.62	-0.665	-1.987	-1.41	-0.64	-0.778	-0.778	-0.936	-0.478	-0.947	-0.5	-0.562	-0.459	-0.425	NA	-0.828	-1.112	-0.54	0.056	-0.096	-0.465	-0.593	0.876	NA	-0.765	-0.697	-0.769	-0.512	0.492	-0.86	NA	NA	NA	NA	NA	-0.445	-0.118	0.011
    24	0.199	-0.035	-0.077	0.228	0.343	0.079	0.249	0.12	-0.855	0.015	-0.66	0.2	0.131	-0.103	-0.429	0.232	NA	-0.156	-0.334	0.583	-0.382	0.062	0.087	-0.208	-0.083	NA	-0.221	0.119	0.222	0.011	0.138	-0.158	NA	NA	NA	NA	NA	-0.492	-0.107	0.137
    25	-0.925	-1.592	-1.944	-0.954	-1.694	-1.284	-0.3	-1.024	-1.006	-2.253	-0.397	-1.839	-1.688	-0.439	-1.561	-1.36	NA	-2.233	-1.574	1.215	-1.377	-0.796	-1.291	-1.804	-1.344	NA	0.064	0.228	-0.393	-0.593	-0.014	-0.177	NA	NA	NA	NA	NA	-0.341	-0.551	-1.509
    27	-0.45	-1.224	-0.956	-0.105	-1.653	-0.448	0.28	-0.071	-1.264	-1.409	-0.623	-0.449	-0.872	-0.986	-1.328	-0.4	NA	-0.59	-0.703	-0.414	-0.988	-0.768	-0.981	-1.767	-0.722	NA	-0.147	-0.015	0.214	-0.645	-0.095	-0.811	NA	NA	NA	NA	NA	0.663	-0.493	-0.894
    29	1.147	0.713	-0.138	0.697	0.156	0.637	0.142	0.439	0.81	-0.087	0.618	-2.439	-0.176	0.129	-0.559	-0.228	NA	0.232	0.091	-1.505	-0.722	-0.727	0.364	-1.203	0.204	NA	-0.004	0.919	0.842	-0.157	-1.179	-0.818	NA	NA	NA	NA	NA	0.727	0.254	1.566
    31	-0.15	-0.187	-1.048	-0.532	-0.467	-0.242	-0.521	-0.485	0.302	-1.281	0.784	-1.337	-0.438	0.305	-0.715	-0.413	NA	-1.489	-0.446	-2.102	0.642	0.103	-1.051	-1.037	0.411	NA	0.243	-0.1	-0.627	-0.144	-0.166	-0.696	NA	NA	NA	NA	NA	-0.84	-0.095	-0.113
    33	-2.193	-0.507	-0.6	-0.211	-0.713	-0.377	0.153	-0.194	-0.626	-0.766	0.122	-0.517	-1.334	0	-0.339	-0.618	NA	-0.751	-1.212	-1.975	0.306	NA	-1.131	-0.468	0.025	NA	0.003	-0.211	-0.874	-0.369	-0.107	-0.748	NA	NA	NA	NA	NA	-0.365	-0.406	-0.091
    35	-0.53	-0.305	0.253	-0.093	-1.097	-0.351	0.491	-0.286	-1.035	0.152	-0.609	-0.12	-0.862	-0.438	-0.51	-0.577	NA	-0.359	-0.451	0.05	-0.845	NA	-0.294	-1.531	-0.451	NA	-0.427	0.112	-0.572	-0.526	-0.66	-0.341	NA	NA	NA	NA	NA	0.354	-0.32	-0.298
    38	0.348	0.013	0.1	-0.019	0.641	-0.125	-0.782	0.026	-0.419	0.257	-0.281	0.03	-0.695	0.197	0.721	-1.093	NA	0.35	-0.234	-4.369	0.678	0.525	-0.176	0.981	-0.468	NA	0.084	0.322	0.142	-0.234	0.32	-0.483	NA	NA	NA	NA	NA	-0.23	0.109	0.376
    39	0.773	0.123	0.655	0.42	0.195	0.503	0.781	1.141	-0.097	0.686	1.148	NA	-0.569	0.363	0.944	0.031	NA	0.73	-0.463	0.309	0.385	1.525	0.994	0.473	0.252	NA	1.463	0.434	0.685	0.309	-0.151	0.246	NA	NA	NA	NA	NA	0.014	0.941	1.265
    40	-0.012	-0.843	-1.277	-0.377	-1.084	-0.838	-1.634	-1.041	-1.072	0.004	0.045	-0.758	-1.692	-1.653	-0.928	-1.939	NA	-0.419	-0.984	-2.233	-1.285	-1.392	-2.033	-0.306	-1.601	NA	-0.143	0	-1.237	0.096	-0.751	-1.585	NA	NA	NA	NA	NA	-0.327	-1.015	-1.528
    
    

    Classification hiérarchique (CAH)

    Le programme neighbor de PHYLIP peut être utilisé pour construire une hiérarchie.

    Cartes de Kohonen (SOM)

    L'algorithme d'apprentissage de cartes auto-organisatrices peut être résumé de la manière suivante :

    1. Initialisation des vecteurs de poids
    2. Présentation d'un vecteur de données (individu) à la couche d'entrée
    3. Détermination du neurone "gagnant", c'est-à-dire le plus proche du vecteur de données
    4. Modification des neurones voisins du gagnant, par descente de gradient
    5. Retour à l'étape 2 jusqu'a ce qu'un critère d'arrêt soit atteint (nombre d'itérations, plus de changement d'affectation, etc)

    L'implémentation ne nécessite pas de routines particulières, et peut tout a fait être réalisée en Perl, malgré ses faibles performances en terme de vitesse d'éxécution. Voici une implémentation de l'algorithme de Kohonen en Perl :

    
    
    
    #!/usr/bin/perl
    
    use Getopt::Long;
    
    my $x_classes    = 5;
    my $y_classes    = 5;
    my $nb_iter      = 30;
    
    my $num_indiv    = 0;
    my $num_vars     = 0;
    
    my $alpha0       = 0.1;
    my $rad0         = 2.5;
    my $radf         = 0.0;
    
    # classes 5x5
    my @neuron = ();
    
    # données 
    my @data    = ();
    
    # distances
    my @dist    = ();
    
    
    # definit le style de sortie
    my $output = 'html'; 
    GetOptions ('output=s' => \$output,
    	    'xdim=s'   => \$x_classes,
    	    'ydim=s'   => \$y_classes,
    	    'iter=s'   => \$nb_iter
    	    );
    
    
    
    # lit les données
    my @values = ();             
    while ($line = <STDIN>) {
        chomp $line;
    
        @values    = split(/[\t\s]+/, $line);
        my @indiv  = ();
        my $nb     = scalar @values;
    
        for (my $i=0; $i<$nb; $i++) {
    	$indiv[$i] = $values[$i];
        }
    
        push(@data, \@indiv);
        $num_indiv++;
    }
    
    
    # evalue le nombre de cols
    $num_vars = scalar(@{$data[0]});
    
    
    # initialise les classes de manière aléatoire 
    srand();
    my @utilises = ();
    for (my $i=0; $i<$x_classes; $i++) {
        for (my $j=0; $j<$y_classes; $j++) {
    	
    	# nombre aléatoire entre 0 et $num_indiv
    	my $r = int(rand($num_indiv));
    	
    	while ($utilises[$r] == 1) {
    	    $r = int(rand($num_indiv));
    	}
    	
    	$utilises[$r]     = 1;
    
    	my @neutmp = @{$data[$r]};
    	$neuron[$i][$j]   = \@neutmp;
    	
        }
    
        
    
    }
    
    
    for ($t=0; $t<$nb_iter; $t++) {
    
        for ($k=0; $k<$num_indiv; $k++) {
    	
    	$mindist = 100000.0;
    	# pour chaque individu, determine le gagnant
    	
    	
    	for ($i=0; $i<$x_classes; $i++) {
    	    for ($j=0; $j<$y_classes; $j++) {
    
    		$dist = distance($data[$k], $neuron[$i][$j]);
    			    
    		# distance neurone (indiv $neuron[$i][$j])  -> individu $k
    		if ($dist < $mindist) {
    		    $xwin    = $i;
    		    $ywin    = $j;
    		    $mindist = $dist;
    		}
    		    		
    	    }
    	}
    
    	# maj les prototypes = rapproche de l'indiv k
    
    	for (my $i=0; $i<$x_classes; $i++) {
    	    for (my $j=0; $j<$y_classes; $j++) {
    		
    		$alp = alpha ($t, $nb_iter, $alpha0);
    		$rad = radius($t, $nb_iter, $rad0, $radf);
    		$dwi = distOnMap($i, $j, $xwin, $ywin);
    		$hwi = neigh($dwi, $rad);
    		
    
    		for (my $l=0; $l<$num_vars; $l++) {
    
    		    $neuron[$i][$j]->[$l] = $neuron[$i][$j]->[$l] + $alp * $hwi * ($data[$k]->[$l] - $neuron[$i][$j]->[$l]);
    		 
    		}
    		
    	    }
    	}
        }
    
    
    
    
            
        
    }
    
    
    
    
    # initialise le tableau d'affectations
    for ($i=0; $i<$x_classes; $i++) {
        for ($j=0; $j<$y_classes; $j++) {
    	my @a_tmp = ();
    	$affect[$i][$j] = \@a_tmp;
        }
    }
    
    # pour chaque individu, determine le gagnant
    for ($k=0; $k<$num_indiv; $k++) {
            
        $mindist = 100000.0;
        # pour chaque individu, determine le gagnant
        
        for ($i=0; $i<$x_classes; $i++) {
    	for ($j=0; $j<$y_classes; $j++) {
    	    	    
    	    $dist = distance($data[$k], $neuron[$i][$j]);
    	
    	    # distance neurone (indiv $neuron[$i][$j])  -> individu $k
    	    
    	    if ($dist < $mindist) {
    		$xwin    = $i;
    		$ywin    = $j;
    		$mindist = $dist;
    	    }
    	    
    	}
        }
        
        push(@{$affect[$xwin][$ywin]},  $k);
    }
    
    
    
    
    if ($output eq "html") {
       # fait peter le HTML !
        print "<table>\n";
        for (my $i=0; $i<$x_classes; $i++) {
    	print "<tr>\n";
    	for (my $j=0; $j<$y_classes; $j++) {
    	    print "<td>\n";
    	    $n = scalar @{$affect[$i][$j]};
    	    for (my $k=0; $k<$n; $k++) {
    		print $affect[$i][$j]->[$k] . "<br>"; 
    	    }
    	    print "</td>\n";
    	    
    	    
    	}
    	print "</tr>\n";
    	
        }
        print "</table>\n";
    
    
    } else {
     
        # affiche les prototypes
        for ($i=0; $i<$x_classes; $i++) {
    	for ($j=0; $j<$y_classes; $j++) {
    	    print(join " ", @{$neuron[$i][$j]});
    	    print "\n";
    	}
        }
        
    }
    
    # fonction alpha
    sub alpha {
        my ($iter, $length, $alp0) = @_;
        
        return ($alp0 * ($length - $iter) / $length);
    }
    
    
    # fonction de rayon "Gaussian"
    sub neigh {
        
        my ($d, $s) = @_;
    
        return (exp(- ($d * $d) / (2.0 * $s * $s)));
    
    }
    
    # fonction de diminution du rayon
    sub radius {
        my ($iter, $length, $rad0, $radf) = @_;
        
        return ($radf + ($rad0 - $radf) * ($length - $iter) / $length);
    }
    
    
    # distance entre 2 individus (ou neurones)
    sub distance {
        
        my ($ind1, $ind2) = @_;
    
        my $sum = 0.0;
        for (my $i=0; $i<scalar(@$ind1); $i++) {
    	$sum += ($ind2->[$i] - $ind1->[$i]) * ($ind2->[$i] - $ind1->[$i]); 
        }
    
        return sqrt($sum);
        
    }
    
    
    # calcule une distance entre deux neurones sur la grille
    sub distOnMap {
        
        my ($x1, $y1, $x2, $y2) = @_;
        
        return sqrt (($x2 - $x1) * ($x2 - $x1) + ($y2 - $y1) * ($y2 - $y1));
        
    }
    
    
    
    
    
    
    

    La ligne de commande permettant de construire une carte de Kohonen 5x5 sous forme de tableau HTML, sur 10 itérations, est la suivante :

    
    
    perl kohonen.pl --output=html --xdim=5 --ydim=5 --iter=10 < an50.txt
    
    
    

    Afin de vérifier la qualité de la carte obtenue, et notamment la présence de défaut toplogiques, on peut projeter la grille sur le plan obtenu par une ACP, et afficher le résultat grâce à GNUPLOT :

    
    
    perl kohonorm.pl --output=html --xdim=5 --ydim=5 --iter=10 < an50.txt | perl pca.pl 3 | perl outgnu.pl 5 5 > data3d.txt && gnuplot plot.plt > kohonen.png
    
    
    

    Voici le contenu du script outgnu.pl :

    
    
    $x = $ARGV[0];
    $y = $ARGV[1];
    
    
    
    $cnt = 1;
    while ($line = <STDIN>) {
        
        print $line;
        print "\n" if (($cnt % $y) == 0);
        
        $cnt++;
    }
    
    

    Celui de plot.plt :

    set terminal png
    set view 0, 0
    splot "data3d.txt" with lines
    

    Voici le fichier PNG obtenu :

    Figure 6.1. Kohonen

    Le problème des cartes de Kohonen est qu'elles permettent uniquement de regrouper les profils similaires. Elles ne permettent pas de détecter les profils décalés dans le temps, ou les profils inversés (régulation négative).

    K-means / Nuées dynamiques

    L'algorithme des nuées dynamiques est une généralisation de l'algorithme des k-means. Le grand interet de cette méthode de classification est sa simplicité, notamment à la mise en oeuvre. En outre, il existe une variante des nuées dynamiques permettant de travailler à partir d'un tableau de distances. Le défaut de cette méthode est qu'il faut obligatoirement fixer le nombre de classes à-priori. Les grandes étapes sont les suivantes :
    • 1. déterminer une partition initiale, c'est-à-dire regrouper les individus de façon arbitraire en k classes
    • 2. calculer les représentants de chacune des classes, c'est-à-dire les individus (existant ou virtuels) optimisant un critère (ex: inertie intra-classe)
    • 3. affecter chaque individu à la classe qui lui est la plus proche
    • 4. retourner à l'étape 2 jusqu'à ce que aucun des individus ne changent de classe.
    Voici le code source en Perl de l'algorithme des nuées dynamiques :
    
    
    #!/usr/bin/perl
    use strict;
    
    my @data         = (); # stocke les données (individus)
    my @classes      = (); # stocke les classes
    my @effectifs    = (); # stocke les effectifs de chaque classe
    my @affectations = (); # stocke l'appartenance d'un indiv a une classe
    
    my $num_classes  = 5;
    my $num_indiv    = 0;
    
    # charge les données
    my $line = <STDIN>;       
    my @values = ();             
    while ($line = <STDIN>) {
        chomp $line;
    
        @values    = split(/[\t\s]+/, $line);
        my @indiv  = ();
        my $nb     = scalar @values;
    
        for (my $i=1; $i<$nb; $i++) {
    	$indiv[$i-1] = $values[$i];
        }
    
        push(@data, \@indiv);
    
    }
    
    srand();
    
    $num_indiv  = scalar @data;
    my $num_vars   = scalar @{$data[0]};
    
    # initialise les classes avec des individus
    
    my @utilises = ();
    for (my $i=0; $i<$num_classes; $i++) {
        # nombre aléatoire entre 0 et $num_indiv
        my $r = int(rand($num_indiv));
    
        while ($utilises[$r] == 1) {
    	$r = int(rand($num_indiv));
        }
        $utilises[$r] = 1;
    
        # copie l'individu $r vers la classe $i
        for (my $j=0; $j<$num_vars; $j++) {
    	$classes[$i]->[$j] = $data[$r]->[$j];
        }
    
    
        #print "Classe $i initialisée avec individu $r\n";
    }
    
    
    
    # itère tant qu'il y a des changements d'affectations
    my $change = 1;
    while ($change) {
        $change = 0;
        @effectifs = ();
        # regarde, pour chaque individu, la  classe a laquelle il appartient
        for (my $i=0; $i<$num_indiv; $i++) {
    	my $affect  = -1;
    	my $mindist = 100000.0;
    	for (my $j=0; $j<$num_classes; $j++) {
    	    my $dist = euclidDist($classes[$j], $data[$i]);
    	    if ($dist < $mindist) {
    		$affect  = $j;
    		$mindist = $dist;
    	    }
    	}
    
    	
    	$change = 1 if ($affectations[$i] != $affect); 
    	#print "Individu $i va dans la classe $affect\n";
    	$affectations[$i] = $affect;
    	$effectifs[$affect]++;
        }
    
        #for (my $i=0; $i<$num_classes; $i++) {
        #	print "effectif de la classe $i = " . $effectifs[$i] . "\n";
        #}
    
        # recalcule les centres des classes
        @classes = ();
        for (my $i=0; $i<$num_indiv; $i++) {
    	# ajoute l'individu a sa classe
    	
    	for (my $j=0; $j<$num_vars; $j++) {
    	   $classes[$affectations[$i]]->[$j] += $data[$i]->[$j];
    	}
        }
    
        for (my $i=0; $i<$num_classes; $i++) {
    		
    	for (my $j=0; $j<$num_vars; $j++) {
    	    $classes[$i]->[$j] /= $effectifs[$i];
    	}
        }
    
        # divise les composantes de chaque classe par leur effectif
    }
    
    my @resultat = ();
    for (my $i=0; $i<$num_indiv; $i++) {
        $resultat[$affectations[$i]] .= "$i ";
    }
    
    for (my $i=0; $i<$num_classes; $i++) {
    	# affiche les prototypes
    	#for (my $j=0; $j<$num_vars; $j++) {
    	#print $classes[$i]->[$j] . " ";
    	#}
        print "Classe " . ($i+1) . " : " . $resultat[$i] . "\n";
    }
    
    
    # distance euclidienne
    sub euclidDist {
        my ($din1, $din2) = @_;
    
        my ($nb1, $nb2, $sum);
        $nb1 = scalar @{$din1};
        
        
    
        $nb2 = 0;
        for (my $i=0; $i<$nb1; $i++) {
    	$sum += ($din1->[$i] - $din2->[$i]) * ($din1->[$i] - $din2->[$i]);
    	$nb2 ++;
        }
        
        $sum = $sum / $nb2;
        return sqrt($sum);
    }
    
    
    
    
    

    Analyse en Composantes Principales (ACP)

    L'ACP nécessite notamment l'accès à des routines de calcul de valeurs et vecteurs propres d'une matrice. Pour cela, nous utiliserons le module Perl PDL (http://pdl.perl.org), qui fournit entre autres un ensemble de routines de manipulations de matrices. Le code Perl permettant de réaliser une réduction de dimensionalité de N dimensions vers 2 dimensions est le suivant. Il prend en entrée une matrice de n individus décrits par k variables, et renvoie une matrice de ces mêmes individus décrits par 2 variables, car projetés sur le plan formé par les 2 premiers vecteurs propres.
    
    #!/usr/bin/perl -W
    # effectue la projection en 2D d'un nuage de points n Dimensions
    # inspiré de http://stein.cshl.org/genome_informatics/expression/express_pl.txt
    use PDL;
    
    my @input = <STDIN>;
    
    my @data  = ();
    
    # nombre de lignes
    my $nrow = scalar(@input);
    
    # evalue le nombre de cols
    @line = split(/\s+/, $input[0]);
    my $ncol = scalar(@line);
    
    
    # crée une nouvelle matrice 
    my $data = PDL->zeroes($nrow,$ncol);
    
    # charge la matrice de points
    for (my $i = 0; $i < $nrow; $i++) {
        @line = split(/\s+/, $input[$i]);
        
        for (my $j = 0; $j < $ncol; $j++) {
    	set($data, $i, $j, $line[$j]);
        }
    }
    
    # calcule la matrice de covariance (devrait utiliser PDL plutôt)
    my $covar = PDL->zeroes($ncol,$ncol);
    
    
    # calcule la moyenne pour chaque colonne
    for ($j = 0; $j < $ncol; $j++) {
        $mean[$j] = 0.0;
        
        for ($i = 0; $i < $nrow; $i++) {
    	$mean[$j] += at($data, $i, $j);
        }
        $mean[$j] /= $nrow;
    }
    
    
    # centre les données
    for ($i = 0; $i < $nrow; $i++) {
        for ($j = 0; $j < $ncol; $j++) {
    	set($data, $i, $j,  at($data, $i, $j) - $mean[$j]);
        }
    }
    
    # calcule la matrice de cov
    for ($j1 = 0; $j1 < $ncol; $j1++) {
        for ($j2 = $j1; $j2 < $ncol; $j2++) {
    	set($covar, $j1, $j2, 0.0);
    	for ($i = 0; $i < $nrow; $i++) {
    	    set($covar, $j1, $j2, at($covar, $j1, $j2) + at($data, $i, $j1) *  at($data, $i, $j2));
    	}
    	
    	set($covar, $j1, $j2, at($covar, $j1, $j2) / $nrow);
    	set($covar, $j2, $j1, at($covar, $j1, $j2));
    	
        }
    }
    
    
      
    # dé-centre les données
    for ($i = 0; $i < $nrow; $i++) {
        for ($j = 0; $j < $ncol; $j++) {
    	set($data, $i, $j,  at($data, $i, $j) + $mean[$j]);
        }
    }
    
    
    # calcule eigenvalues et eigenvecteurs
    my ($e, $lambda) = PDL::Math::eigens($covar);
    my $ix = qsorti($lambda);
    
    # quelques affichages 
    print "Eigenvalues :\n";
    for (my $i = $ncol-1; $i >= 0; $i--) {
        print at($lambda,at($ix,$i)) . " ";
    }
    print "\n";
    
    print "Eigenvectors (3 premiers) :\n";
    print $e->slice(":,(" . at($ix, $ncol - 0 - 1) . ")"); print "\n";
    print $e->slice(":,(" . at($ix, $ncol - 1 - 1) . ")"); print "\n";
    print $e->slice(":,(" . at($ix, $ncol - 2 - 1) . ")"); print "\n";
    
    
    # cree une matrice de points projetés en 2D
    $proj = PDL->zeroes($nrow, 2);
    
    
    for (my $i = 0; $i < $nrow; $i++) {
        for (my $k = 0; $k < 2; $k++) {
    	for (my $k2 = 0; $k2 < $ncol; $k2++) {
    	    set($proj, $i, $k,  at($proj, $i, $k) +at($data, $i, $k2) * at($e, $k2, at($ix, $ncol - $k - 1)));
    	}
        }
    }
    
    
    
    # affiche les points projetés
    for (my $i = 0; $i < $nrow; $i++) {
        for (my $k = 0; $k < 2; $k++) {
    	print at($proj, $i, $k) . " ";
        }
        print "\n";
    
    }
    
    
    
    
    Suite à ce programme, il est possible, toujours avec gnuplot d'afficher les points projetés sur le plan formé par les 2 premiers axes ACP :
    
    pca.pl 2 < an50.txt > data2d.txt && gnuplot plot2D.plt > 2D.png
    
    
    Voici le contenu du script GNUPLOT plot2D.plt :
    set terminal png
    plot "data2d.txt"
    
    Voici le fichier PNG obtenu :

    Figure 6.2. Projection

    Programmes d'analyse des données d'expression

    Parmi les programmes permettant d'analyser l'expression de gènes provenant de microarrays se trouve J-Express (http://www.ii.uib.no/~bjarted/jexpress/). Celui-ci offre les techniques suivantes : CAH, SOMs, PCA, K-means, Profile search, ainsi que différents outils de visualisation (par exemple 3D grace a VRML).

    On notera que chacun possède son propre format de sauvegarde des données d'expression. Il existe cependant des tentatives de standardisation, ainsi que des propositions/implémentations de bases de données de données d'expressions de gènes. Ressources:

    mini tutorial sur GeneCluster
    Interpreting patterns of gene expression with self-organizing maps: methods and application to hematopoietic differentiation par Tamayo et al
    Gene network inference
    Gene Expression Informatics par Joel S. Bader, Ph.D.
    Algorithms for gene expression and proreomics

    Chapter 7. Programmer en Perl

    Introduction à Perl et premiers pas

    Perl possède plusieurs avantages : tout d'abord, il est installé sur la quasi-totalité des environnements Unix. Ensuite, les scripts ne nécessitent pas de compilation, et sont donc parfaitement portables d'un système à l'autre (Windows vers Linux par exemple). Perl implémente également de nombreux types de données très utiles comme les tables de hachage (tableaux associatifs), qui évitent au programmeurs de réinventer la roue. Il supporte les expressions régulières, ce qui lui permet d'effectuer des traitements compliqués sur les chaines de caractères (recherche et remplacement de texte par exemple). Perl possède maintenant un nombre incalculable de modules, tous disponibles dans le doamine public, et couvre ainsi tous les domaines de l'informatique. Il est facile de débuter la programmation avec Perl.

    Ouvrir avec Emacs un fichier nommé hello.pl, puis taper la ligne suivante, sauver le fichier puis sortir d'Emacs.

    [olly@mplpc16 bioinfo]$ emacs hello.pl& 
    print "Hello!\n";
    

    [olly@mplpc16 bioinfo]$ perl hello.pl
    

    Maintenant, ouvrez le fichier avec emacs et ajoutez-y la ligne suivante :

    #!/usr/bin/perl
    $str = "Hello";
    print "$str tout le monde!\n";
    

    Ensuite, rendez le fichier éxécutable

    [olly@mplpc16 bioinfo]$ chmod +x hello.pl
    

    Vérifions que le fchier est bien executable (il contient trois "x")

    [olly@mplpc16 dtgen]$ ll hello.pl 
    -rwxr-xr-x   1 olly     olly           18 Jun  5 23:19 hello.pl*
    

    Et maitenant, on éxécute ce script!

    [olly@mplpc16 dtgen]$ hello.pl
    

    concepts fondamentaux de la syntaxe Perl

    La syntaxe du Perl est relativement proche de celle du C (pour ceux qui connaissent ce langage). Ainsi, Perl est sensible à la casse (print est différent de PRINT par exemple). En Perl, chaque ligne est terminée par un point-virgule. Tous ce qui suit le caractère # est considére comme des commentaires.

    Il existe trois types de variables en Perl : les scalaires, les listes et les hachages. Une variable de type scalaire débute par le signe $ (par exemple $count), une variable de type liste débute par le signe @ (par exemple @tableau), tandis qu'une variable de type hachage débute par le signe % (par exemple %hash).

    Une variable de type scalaire peut contenir un nombre (entier ou réel) ou bien une chaîne de caractères. Par exemple :
    $num = 12;
    $taille = 3.3;
    $str = "salut";
    
    Perl réalise l'interpolation de variable scalaire dans les chaînes de caractère. Par exemple le script suivant affiche le message "je mesure 1.87 m" :
    $taille = 1.87;
    print "je mesure $taille m";
    
    Il n'y a pas de typage en Perl, cela signifie qu'une variable prend le type de ce qui lui est affectée. Par exemple il est possible de faire les opérations suivantes :
    $var = 3
    $var = "salut";
    print $var;
    
    ce qui affichera "salut" et non pas 3. Comme dans de construction de réferences Après avoir passé en revue les constructions de bases, : Perl possède également comme particularité de définir une série variables spéciales : $_ que veut dire "my" syntaxe générale Une liste (ou un tableau) est une variable contenant elle-même une série d'objets (variables, listes, etc.). Chaque objet (ou élément) d'un tableau est repéré par sa position au sein du tableau. Par exemple, le premier élément d'un tableau est à la position 0. Le cinquième élément est à la position 4.
    @tableau = (12, "abc", 56, "rtt");
     
    print $tableau[0];       # affiche 12
    print $tableau[3];	 # affiche rtt
    
    Il est possible avec la fonction map d'effectuer une ou plusieurs opérations sur chacun des éléments d' un tableau @tab2 = map {$_ * 2} @tab; ou @tab2 = map(function, @tab); On peut également parcourir les éléments d'un tableau grace à l'instruction foreach :
    foreach $item (@tableau) {
      print $item;
    }
    
    Les tableaux associatifs De même qu'un tableau, un tableau associatif associe une clé à un élément. En revanche la clé n'est pas restreinte à un chifrre, il peut d'agir d'une chaine de caractères. Pour parcourir un tableau associatif nommé %asso, on procèdera de la manière suivante :
    foreach $item (%asso) {
      # instructions ...
      print $item;
    }
    
    Il existe une notion de contexte en Perl, c'est à dire qu'il n'est pas toujours utile de spécifier explicitement les paramètres d'une fonction d'abord les regexp, puis les fichiers Par exemple, la ligne suivante affichera la séquence contenue dans $seq si celle-ci contient le motif TTATA :
    print $seq if ($seq =~ /TTATA/)
    
    L'interactivité avec l'utilisateur est nécéssaire pour bien des programmes conviviaux. Néanmoins elle Il y a deux moyens d'interagir avec des données externes. La première consiste à ouvrir et créer des fichiers externes, la seconde à utiliser les entrées et sorties standard. Perl gère de manière simple les entrées sorties standards... très utile pour réaliser des traitements rapides sur des fichiers texte. Par exemple, supposons que l'on souhaite extraire les accession numbers du fichier suivant, nommé nucleo.seq :
    >X14543
    AATTTATGCGCTATATATATTTTG
    >X14544
    AATTTATGCGCTATGTATATTTTG
    >X14545
    AATTTATGCGCGATATATATTTTG
    
    Le script numacc.pl permettant de réaliser cette tache est le suivant :
    
    while (<STDIN>) {
      # affiche l'accession number si la ligne commence par >
      print $1 if (/^>(.*)$/);
    }
    
    
    L'usage de ce programme est le suivant :
    cat nucleo.seq | numacc.pl
    
    écrire une nouvelle routine :
    
    sub maRoutine {
      my ($arg1, $arg2) = @_;
    
      print "argument passés : $arg1 et $arg2";
    
      return $arg1+ $arg2;
    }
    
    parser les options de la ligne de commande avec le module Getopt::Long. Supposons que l'on souhaite demander à l'utilisateur le type de sortie qu'il souhaite, et ce au travers de la ligne de commande :
    script.pl --output=html
    
    
    use Getopt::Long;
    
    
    # definit le style de sortie, html par défaut
    my $output = ''; 
    GetOptions ('output=s' => \$output);
    $output = "html" if ($output eq ''); 
    
    if ($output eq "html") {
       print "<b>Hello !</b>";
    } else {
       print "Hello !"; 
    }
    
    Par exemple, essayons d'extraire des séquences les portions comprises entre les motifs TTA et TTC Pour extraire les 10 premiers acides aminées de chaque séquence, on utilisera la fonction substr. Par exemple : substr($seq, 0, 10) Les expressions régulières Redirection des E/S Définition et utilisation des descripteurs de fichiers APPLICATION DE MOTIFS ET OPÉRATEURS Expressions régulières Perl Extraction d'informations textuelles importantes Utilisation d'expressions régulières UNIX Modification des données avec des substitutions Décodage des extensions "egimosx" $ fin de ligne ? 0 ou 1 fois ^ début de ligne Installer un module Perl Parser la sortie de Blast gràce à Perl Si le module CPAN.pm est installé sur votre machine, il est possible d'installer de nouveaux modules de manière quasi-automatique. Par exemple, pour installer le module SOAP::Lite, il suffit de taper la commande suivante (en tant que super-utilisateur):
    perl -MCPAN -e 'install SOAP::Lite'
    
    Notons que l'interface CPAN permet de chercher des modules Perl parmi ceux installables. Ainsi, pour chercher tous les modules contenant la chaîne
    perl -MCPAN -e 'shell'
    i /Bio/
    
    Autrement, il est nécessaire de télécharger l'archive en .tar.gz, de la decompresser, et de taper les commandes suivantes dans le répertoire créé :
    perl Makefile.PL
    make
    make test
    su
    make install
    
    Ressources: tutorial Perl en français chez ftls.org http://www.ftls.org/fr/initiation/perl/ Un excellent Learning Perl O'Reilly Perl permet de créer et d'accéder à la librairie GNU Database Manager. Il s'agit d'une librairie installée sur tous les systèmes Linux, dont les routines permettent de gérer des fichiers contenant des paires clé/données. On l'utilise couramment pour stocker des données et pour pouvoir les récupérer rapidement. Utile par exemple pour construire un petit moteur de recherche. GNU dbm is a library of routines that manages data files that contain key/data pairs. The access provided is that of storing, retrieval, and deletion by key and a non-sorted traver­ sal of all keys. A process is allowed to use multiple data files at the same time. Ecrire une base de données:
    use GDBM_File;
    tie(my(%indexdb),'GDBM_File',"index.db", &GDBM_WRCREAT, 0644);
    $indexdb{"bioinformatique"} = "file.html";
    untie(%indexdb);
    
    Lire une base de données:
    use GDBM_File;
    tie(my(%indexdb),'GDBM_File',"index.db", &GDBM_WRCREAT, 0644);
    $indexdb{"bioinformatique"} = "file.html";
    untie(%indexdb);
    
    La fonction sort permet de trier un tableau, c'est à dire de ranger les éléments de ce tableau dans un ordre spécifié. Par exemple, supposons que l'on souhaite trier le fichier suivant, nommé specif.txt par ordre lexicographique :
    Phenyl[1-(1-N-succinylamino)pentyl] phosphonate
    Neuraminidase [influenza virus]; residues: 82-468
    Lysozyme [hen egg white](HEL) EC:3.2.1.17 D18A
    Cyclopentadienyl ferrocene (exo Diels-Alder reaction inhibitor)
    Human rhinovirus (serotype 2) VP2 (viral capsid protein) peptide; residues: 156-170
    Transition State Analogue (Bicyclo[2.2.2]octene derivative)
    4-hydroxy-3-nitrophenyl acetate
    4-hydroxy-5-iodo-3-nitrophenyl acetate
    Aspartame
    HIV-1 gp120; residues: 308-332
    Autoantigen IgG4 Fc Rea
    HIV-1 p24 (capsid protein); residues: 1-151
    Thromboplastin (synonym: tissue factor, TF, coagulation factor III) extracellular domain
    HIV-1 V3 loop constrained peptide analogue (Aib142)
    5-(para-nitrophenyl phosphonate)-pentanoic acid
    Cytochrome c oxidase [Paracoccus denitrificans] EC:1.9.3.1
    2,2,6,6-tetramethyl-1-piperidinyloxy-dinitrophenyl
    HIV-1 p24 epitope-homologous peptide
    Lysozyme [bobwhite quail egg white] EC:3.2.1.17
    Lysozyme [hen egg white]
    Rnase A
    Lysozyme [hen egg white] (HEL) EC:3.2.1.17
    Traseolide [musk odorant fragrance] (hydrophobic hapten)
    HIV-1 reverse transcriptase (HIV-1 RT) EC:2.7.7.49 M184I/double-stranded DNA (ds) complex
    
    Le tri de ce fichier se fait en utilisant le programme Perl suivant :
    
    #!/usr/bin/perl -w
    
    @fichier = <STDIN>;
    @result = sort @fichier;
    print STDOUT @result;
    
    
    Ligne de commande :
    
    sort.pl < specif.txt > specif_triees.txt
    
    
    Par défaut, le tri est effectué par ordre lexicographique, mais sort peut faire appel à une fonction de comparaison externe. Par exemple, pour trier les lignes de ce fichier par ordre de repX croissant :
    
      6  50
    rep1      CTGACATTGGAAAGTACTTTATACGACAAGACAAACTGAAGGTGCAAGTCCTTTTTGTCATACTATTCAT
    rep5      CTGACACCGGAAAGTACTTTATACGTCAAGACAAACTGAAGGTGCAAGTCCTTTTTGTCATACTATTCAT
    rep2      CTGACATTGGAAAGTACTTTATACGTCGAGACGGACTGAAGGTGCAAGTCCTTTTTGTCATACTATTCAT
    rep6      CTGACACCGGGGAGTACTTTATACGACAAGACAAACTGAAGGTGCAAGTCCTTTTTGTCATACTATTCAT
    rep4      CTGACATTGGAAAGTACTTTATACGACAAGACAAACTGAAGGTGCAAGTCCTTTTTGTCATACTATTCAT
    rep3      CTGACATTGGAAAGTACTTTATACGACAAGACAAACTGAAGGTGCAAGTCCTTTTTGTCATACTATTCAT
    
    On utilisera le programme suivant :
    #!/usr/bin/perl
    
    #recupère la première ligne
    $ln = <STDIN>;
    
    #recupère les autres lignes
    @lines = <STDIN>;
    
    
    #sortie
    print $ln;
    @sorted_lines = sort sortlines @lines;
    foreach $line (@sorted_lines) {
        print "$line"; 
    }
    
    sub sortlines {
        $a =~ /^rep(\d+)/;
        $a1 = $1;
        $b =~ /^rep(\d+)/;
        $b1 = $1;
        return $a1 <=> $b1;
    }
    
    

    Applications en bioinformatique

    Mettre de l'information au format souhaité

    exemple : format bizarre -> format fasta

    Récupérer l'information à partir de fichiers de sorties de programmes externes

    Construction automatique de pages web

    Le programme le plus simple possible est le suivant :
    print "Bonjour je m'appelle Olivier\n";
    
    Tout comme il est possible d'écrire du texte à l'écran, il est également possible d'écrire du HTML :
    
    print "<html><body>\n";
    print "font color=\"red\">Bonjour je m'appelle Olivier</font>\n";
    print "</body></html>\n";
    
    
    Redirigeons la sortie de ce script vers un fichier nommé page.html (avec la commande print.pl > page.html), puis visualisons ce dernier avec netscape. Notons que Perl permet de séparer certaines données du code HTML proprement dit, grace a l'usage de variables. Par exemple :
    
    $couleur = "red";
    $texte   = "Bonjour je m'appelle Olivier";
    
    print "<html><body>\n";
    print "font color=\"$couleur\">$texte</font>\n";
    print "</body></html>\n";
    
    

    BioPerl

    BioPerl correspond à une série de modules destinés à automatiser certaines taches communes en bioinformatique. Par exemple, il permet de lire des fichiers FASTA, de lancer des BLAST et de récupérer des séquences à partir des bases de données online.

    Installation

    L'installation de BioPerl peut se faire de la manière suivante, via le module CPAN.pm :

    [root@MPLPC18 olly]# perl -MCPAN -e shell
    
    cpan shell -- CPAN exploration and modules installation (v1.52)
    ReadLine support enabled
    
    cpan> install "B/BI/BIRNEY/bioperl-0.7.1.tar.gz"
    

    Un tutorial complet sur BioPerl est disponible à l'adresse http://bio.perl.org/Core/POD/bptutorial.html

    Récupérer des séquences à partir de fichiers FASTA, EMBL, etc.

    Exemple : lire et afficher les séquences d'n fichier FASTA :
    use Bio::SeqIO;
    
    $seqio  = Bio::SeqIO->new ( '-format' => 'Fasta' , -file => $ARGV[0]);
    while $seq = $seqio->next_seq;
    
    
    
    Autre exemple : lire et afficher les séquences d'n fichierau format EMBL :
    use Bio::SeqIO;
    
    $seqio  = Bio::SeqIO->new ( '-format' => 'embl' , -file => '../new_seq.dat');
    
    while ($seqobj = $seqio->next_seq()) {
            print ">" . $seqobj->accession_number . "\n";
            print $seqobj->seq . "\n";
    }
    
    Meme chose, mais avec stockage des sequences dans une base GDBM :
    
    
    use Bio::SeqIO;
    
    
    use GDBM_File;
    
    tie(my(%indexdb),'GDBM_File',"sequences.db", &GDBM_WRCREAT, 0644);
    
    $seqio  = Bio::SeqIO->new ( '-format' => 'embl' , -file => '../new_seq.dat');
               
    $cnt = 0;
    while (($seqobj = $seqio->next_seq()) && ($cnt++ < 100)) {
            print ">" . $seqobj->accession_number . "\n";
            print $seqobj->seq . "\n";
            $indexdb{$seqobj->accession_number} = $seqobj->seq;
    }
    
    untie(%indexdb);
    
    
    
    Lecture des infos stockées :
    
    
    use GDBM_File;
    
    tie(my(%indexdb),'GDBM_File',"sequences.db", &GDBM_WRCREAT, 0644);
    
               
    while (($k, $v) = each %indexdb) {
            print ">" . $k . "\n";
            print $v . "\n";
    }
    
    untie(%indexdb);
    
    
    

    Récuperer des séquences dans GenBank

    use Bio::DB::GenBank;
    
    $gb = new Bio::DB::GenBank;
    $seq = $gb->get_Seq_by_acc($ARGV[0]);
    
    print $seq->seq;
    

    Utiliser le module d'alignement multiple (SW)

    #!/usr/bin/perl
    
    
    
    use Bio::Tools::pSW;
    use Bio::Seq;
    
    
    $factory = new Bio::Tools::pSW( '-matrix' => 'blosum62.bla',
                                       '-gap' => 12,
                                       '-ext' => 2, );
                                                                                                        
    
    $seq1    = Bio::Seq->new( -seq => 'WLGQRNLVSSTGGNLLNVWLKDW');
    $seq2    = Bio::Seq->new( -seq => 'WMGNRNVVNLLNVWFRDW');
    
    $factory->align_and_show($seq1, $seq2, STDOUT);
                                                                                                             
        
    $aln = $factory->pairwise_alignment($seq1, $seq2);
    
    
    
    
    Ce qui devrait donner la sortie suivante :
    
    seq1        1     WLGQRNLVSSTGGNLLNVWLKDW                           
                      W+G RN+V     NLLNVW +DW                           
    seq2        1     WMGNRNVV-----NLLNVWFRDW 
    
    
    Batir une interface graphique avec TK
    #!/usr/bin/perl -w
    use Tk;
    use strict;
    new MainWindow -> Button(-text => 'Press me!', -command => sub{print "Merci\n"})
     -> pack;
    MainLoop;
    
    comp.lang.perl.tk FAQ
    Ressources:
    Débuter en Perl par François Dagorn et Olivier Salaun
    Practical Perl Programming par A. D. Marshall, 1999

    programmer en C

    Quels sont les points clé du langage C?

    Le premier point-clé est la portabilité du code sous différents systèmes : en effet le langage C correspond à un standard, standard respecté par la majeure partie des compilateurs. Le code objet performant puisque qu'il s'agit de langage machine, directement interprétable par le noyau système. Il s'agit d'un langage de programmation structurée, c'est à dire que. En fin la compilation des modules peut être faite de manière séparée, ce qui réduit considérablement les temps de recompilation par rapport à une compilation globale.Les compilateurs C fournissent des bibliothèques de fonction standard, c'est à dire communes du point de vue interface d'un compilateur à l'autre. Enfin le C permet l'accès aisé aux fonctions matériel et système, ce qui présente néanmoins peu d'importance pour le bioinformaticien.

    Quel environnement de programmation?

    Les compilateurs

    Un exemple de programme (bonjour.c)
    #include <stdio.h>
    
    void main(void) {
       int age = 25;
       printf("Bonjour tout le monde, j'ai %d ans!", age);
    }
    
    Pour compiler ce programme, on utilise la commande suivante :
    cc bonjour.c -o bonjour
    Cela aura pour effet de créer l'éxécutable bonjour.

    Les éditeurs et outils logiciels

    parler de KDevelop : permet de naviguer facilement entre les fichiers, les fonctions, les classes et les méthodes, permet de lancer la compilation de manière simple, génère un ensemble de fichiers "squelettes". emacs (ou xemacs) permet de lancer les compilations grâce à des raccourcis clavier. emacs interface également RCS, qui permet de gérer plusieurs versions successives d'un même fichier (revenir à des versions antérieures par exemple)

    strtok ou comment récupérer un fichier de données séparées par des espace ou des points-virgules...

    Utiliser les Makefiles

    http://home.tvd.be/cr25754/make.htm construire une Makefile simple les macros Makefile (macro?) $@ est remplacé par la cible courante (a gauche du :) $< est remplacé par le fichier source de la dépendance courante

    Chasser les erreurs de programmation (débugger)

    Il existe de très nombreuses erreurs de programmations chaque fonction doit être testée. Le plus difficile est généralement de cerner l'endroit ou se produit l'erreur. Un débugage simple consiste à placer des instructions Exemple de programme produisant une erreur: free() On pourra également utiliser une fonction C qui permet de tester une condition et d'arrêter le programme si la condition n'est pas remplie : la fonction assert() Exemple:

    #include <assert.h>
    
    void assert (int expression);
    

    gdb, kdbg,

    Résolution de problèmes bioinformatique en C

    Génération de nombres aléatoires en C

    #include <stdio.h>
    #include <time.h>
    
    int main(void) {
            srand(time(NULL));
            printf("%d\n", rand()); 
            return 0;
    }
    

    Pour générer des nombres aléatoires provenant de distribution plus complexes (Gamma, exponentielle, etc.), on utilisera la ranlib, ou encore la GSL (GNU Scientific Library). ex : identifier les TATA box?

    programmer en Java

    Les bases de la programmation et de l'algorithmique par Robert Cori et Jean-Jacques Lévy et François Morain, école Polytechnique

    Installer un kit de développement Java

    Il faut ensuite mettre a jour son CLASSPATH sous bash,
    export CLASSPATH=$CLASSPATH:.
    on peut ajouter cette ligne dans le fichier .bashrc (sous $HOME), puis faire source $HOME/.bashrc pour mettre à jour les variables d'environnement.

    Compiler et éxécuter un programme Java

    Un programme peut faire partie d'un ce qu'on appelle un package. Dans ce cas-là, il faut placer le fichier en .class dans un répertoire portant le nom du package. Par exemple, supposons que l'on ait le code source suivant. Ce programme doit être placé dans le répertoire nommé Bioinfo.
    package Bioinfo;
    
    class HelloWorld {
      public static void Main(String []) {
        System.out.println("Bioinfo!");
      }
    
    } 
    
    Ce fichier peut etre compilé a partir du repertoire ou il se trouve :
    javac HelloWorld.java
    Pour l'éxécuter, il faut se placer dans le répertoire contenant le répertoire Bioinfo, puis taper la commande :
    java Bioinfo.HelloWorld

    Construire un programme en langage Java

    HashTable StreamFormater? (possède un algorithme de tri en 0(n2)) StringTokenize Vector Comment trier un Vector? les objets stockés doivent avoir des méthodes supérieur et inférieur

    Exemple de code Java pour la bioinformatique

    http://www.biojava.org il s'agit d'un projet "open source" destiné à fournir des outils Java pour la manipulation de séquences et des divers formats rencontrés en bioinformatique, la programmation dynamique, et des routines statistiques simples Récuperer une séquence dans GenBank à partir de son "accession number"
    import java.net.*;
    import java.io.*;
    
    public class GenBank {
        public GenBank() {
    
        }
    
       
        public String get_Seq_by_acc(String uid) {
    	StringBuffer seq = new StringBuffer();
    	try {
    	    URL ncbi = new URL("http://www.ncbi.nlm.nih.gov/htbin-post/Entrez/query?db=n&form=6&dopt=f&html=no&title=no&uid=" + uid);
    	    BufferedReader in = new BufferedReader(new InputStreamReader(ncbi.openStream()));
    	    
    	    String inputLine;
    	    while ((inputLine = in.readLine()) != null)
    		seq.append(inputLine);
    	    in.close();
    
    	  
    	} catch (Exception e) { System.out.println(e); }
    	return seq.toString();
        }
        
        
        static void main(String [] argv) {
    	GenBank gb = new GenBank();
    	String seq = gb.get_Seq_by_acc("X92210");
    	System.out.println(seq);
        }
        
    }
    

    programmer avec XML

    Etant donné que de plus en plus de données sont disponibles au format XML, il devient nécessaire de savoir développer des programmes et interfaces utilisant ou générant du XML. La génération de XML ne nécéssite pas d'outil particulier, il s'agit d'une tache similaire à la génération de pages HTML. En revanche l'utilsation de données XML dans un programmme peut se voir facilité par certains outils. L'outil de base est le parseur XML.

    Utiliser un parseur XML en Perl

    xmldb.pl

    programmation Corba

    Néanmoins CORBA est en grosse perte de vitesse et de nouveau standard basé sur XML permettent de faire dialoguer deux Ressources:

    CORBA Tutorial

    programmation parallèle

    Discussions sur la mise en place d'un cluster Beowulf de machines faisant tourner Blast

    utile lors de calcul de bootstrap

    PVM : Parallel Virtual Machine

    Installer PVM

    Créer et compiler un programme simple

    Il s'agit d'un système organisé en maitre-esclave, cad qu'une machine dite "maitre" demande a une série d'autres machine d'effectuer leur part de calcul. Elle envoie les données et recupère le résultat.

    MPI : Message Passing Interface

    Distribuer ses programmes

    scritps, licencses...

    Chapter 8. La programmation d'applications web

    HTML

    structure générale d'un fichier HTML

    mise en page de divers éléments (images, textes)

    Les tableaux

    Notons qu'il est possible et souvent nécessaire d'imbriquer des tableaux afin d'obtenir des mises en pages. Pour des mises en pages plus raffinées, on utilisera directement des images, souvent incluses dans des tableaux afin de les positionner avec précision.

    Création de formulaires HTML

    Javascript pour la validation de formulaires HTML

    Utiliser Perl pour le développement d'application web dynamiques

    traitement de formulaires avec le module CGI

    Bien pratique, $cgi->url() permet de récupérer l'URL du script.

    templates avec HTML::Template

    Les templates permettent de séparer complètement présentation et programmation. On pourra par exemple éditer des templates HTML avec des outils du style Dreamweaver, Webexpert ... sans avoir a modifier le fichier contenant la logique (le script Perl).
    use Date::Manip;
    use HTML::Template;
    
    $template = HTML::Template->new(filename => 'template_selected.html');
    $template->param(DATE    => UnixDate("today"));
    $template->param(NOM     => "Elemento");
    $template->param(PRENOM  => "Olivier");
    
    print $template->output;
    
    Et voici un template correspondant :
    
    
    
    <TMPL_INCLUDE NAME="header.inc">
    <table>
    <tr>
    <td>Annotateur : <TMPL_VAR     NAME="PRENOM"> <TMPL_VAR     NAME="NOM"></td><td align="right"><TMPL_VAR     NAME="DATE"></td></td>
    </tr>
    
    <tr>
    <td colspan="2">
    <form>
    <textarea name="seq"></textarea>
    <imput type="submit">
    </form>
    </td>
    </tr> 
    </table>
    
    <TMPL_INCLUDE NAME="footer.inc">
    
    
    
    
    Comme l'indique cet example, il est possible d'inclure des fichiers externes au sein de templates.
    
      # a couple of arrays of data to put in a loop:
              my @words = qw(I Am Cool);
              my @numbers = qw(1 2 3);
    
              my @loop_data = ();  # initialize an array to hold your loop
    
              while (@words and @numbers) {
                my %row_data;  # get a fresh hash for the row data
    
                # fill in this row
                $row_data{WORD} = shift @words;
                $row_data{NUMBER} = shift @numbers;
    
                # the crucial step - push a reference to this row into the loop!
                push(@loop_data, \%row_data);
              }
    
              # finally, assign the loop data to the loop param, again with a
              # reference:
              $template->param(THIS_LOOP => \@loop_data);
    
           The above example would work with a template like:
    
              <TMPL_LOOP NAME="THIS_LOOP">
                 Word: <TMPL_VAR NAME="WORD">     <br>
                 Number: <TMPL_VAR NAME="NUMBER"> <p>
              </TMPL_LOOP>
    
    
    
    Par défaut, le module HTML::Template ne vous autorise pas à appeller la méthode $template->param(param_name => 'value') si 'param_name' n'existe pas dans le template correspondant. Pour pallier à cela, il faut mettre le paramètre die_on_bad_params à 0 lors de l'appel au module.
    use HTML::Template;
    
    $template = HTML::Template->new(filename          => 'template_selected.html'
                                    die_on_bad_params => '0'
                                   );
    
    
    De même, les variables simples ne sont généralement pas valables à l'intérieur d'un loop. Pour que cela soit le cas et avoir des variables globales, il faut mettre le paramêtre global_vars à 1 :
    use HTML::Template;
    
    $template = HTML::Template->new(filename          => 'template_selected.html'
                                    global_vars => '1'
                                   );
    
    

    sessions avec Apache::Session

    Une session permet de stocker des paramètres, des variables liées à un de vos visiteurs, et ce tout au long de sa visite sur vos pages.
    use Apache::Session::File;
    
    my %session;
    my $id = undef;
    
    
    # numero de la session
    $id = $query->cookie(-name=>"IMGT_SESSION");
    
    
    # cree une session (cree un id dans $session{_session_id} si $id == undef )
    tie %session, 'Apache::Session::File', $id, { 
        Directory => "/tmp/",
        LockDirectory => "/tmp/"
        };
    
        
    # cree un cookie si il n'existe pas deja    
    if ($id == undef) {
        $cookie = $query->cookie( -name=>'IMGT_SESSION',
    			      -value=>$session{_session_id},
    			      -expires=>'+1h');
    }
    
    # id de la session quoiqu'il en soit
    $id = $session{_session_id};
    
    
    

    interaction avec une base de données MySQL

    Utiliser MySQL pour stocker les données

    CGI applications can be written in any language that can be executed on a Web platform such as: C/C++, Perl, Tcl, Python, Shell Scripts(UNIX), Visual Basic and Applescript. Your choice depends on what you have to do because different languages may be specialized for different purposes. Perl, for instance, is great for string and file manipulation, while C is better for bigger, more complex programs. Perl and C are probably the most used languages for CGI programming. We all know how CGI interacts with Perl. In Perl, we used $queryString = $ENV{'QUERY_STRING'} to access the environmental variable. In C, you could call the library function "getenv()", which is defined in standard library . Here is a simple example of how to call this function: débugger un script CGI en Perl. On peut l'éxécuter en local. Pour fournir des paramêtres au CGI, on peut taper ces paramêtre sous la forme param=3 Pour terminer, on tape Ctrl D. Il est également possible d'examiner les logs du serveur web.

    Chapter 9. Méthodes et algorithmes en bioinformatique

    Structures de données

    Listes chainées

    Tableaux

    Arbres

    Files

    Graphes

    Détermination des composantes connexes d'un graphe

    Les composantes connexes d'un graphe sont les ensembles de sommets accessibles les uns depuis les autres. On peut utiliser les algorithmes de parcours de graphes pour déterminer les composantes connexes d'un graphe. Pour cela, on utilise l'algorithme de parcours en profondeur d'abord et on colorie les sommets rencontrés avec une couleur correspondant à la composante connexe courante.

    Composantes-Connexes
    1. Partir d'un sommet s
    2. S'il est colorié
          ne rien faire
       sinon
          choisir une couleur
          appliquer profondeur d'abord en marquant avec la couleur
    

    Les algorithmes de tri

    Le premier est très simple à implémenter mais généralement lent (sauf quand les données sont presque ordonnées), le second est plus rapide mais plus complexe. complexité des algorithmes de tri? - bubble sort
    //tri simple de type bubble sort
    void bubbleSort(short *a, int n) {
      int tmp, i, j;
      
      for (i=0; i<n-1; i++) {
        for (j=0; j<n-1-i; j++)
          if (a[j+1] < a[j]) {  /* compare the two neighbors */
    	tmp = a[j];         /* swap a[j] and a[j+1]      */
    	a[j] = a[j+1];
    	a[j+1] = tmp;
          }
      }
    
    - quicksort repérer les séquences croissantes...

    Algorithmes de recherche et optimisation

    http://www.cs.cf.ac.uk/User/S.U.Thiel/ra/section3_7.html#SECTION0007000000000000000 Quelle méthode d'optimisation pour quel problème?

    recuit simulé

    donner un exemple avec la GSL http://wwwinfo.cern.ch/pdp/ose/asis/products/GNU.MATH/gsl-0.3b/gsl-ref_7.html

    algorithmes génétiques

    monte-carlo

    descente de gradient

    tabu search

    http://www.winforms.phil.tu-bs.de/winforms/research/tabu/tabu.html http://www.cs.sandia.gov/opt/survey/ts.html

    Modèles de Markov

    Les modèles de Markov cachés sont aujourd'hui largement utilisés pour la recherche de gènes et de divers signaux dans les séquences génétiques. Ils sont également le modèle de référence dans des domaines bien différents, comme la parole, et ils sont de plus en plus fréquemment utilisés pour le traitement de données textuelles. Dans toutes ces applications, le modèle appris possède une architecture (ensemble des transitions autorisées entre états) fixe. L'apprentissage se résume alors à l'optimisation d'un jeu de paramètres numériques, définissant les probabilités de transition et d'émission. Le problème de l'apprentissage de l'architecture est NP-difficile, et il n'existe que peu d'heuristiques efficaces. Pourtant, il a été démontré dans des articles récents que les architectures construites à la main sont souvent sous-optimales. HMMER est un programme implémentant ce que l'on appelle des "Profile HMM" pour séquences protéiques : ils permettent de réaliser des recherches dans les bases de données avec une bonne précision, à partir d'une description statistique d'un consensus d'une famille de séquences. HMMER est disponible à cette adresse.

    Analyse de données et data mining

    Analyse en Composantes Principales

    Qu'est ce qu'un tableau de contingence?

    Un tableau de contingence, ou tableau à double entrée, est un cas particulier de tableau élémentaire où les lignes et les colonnes jouent un rôle symétrique et où le contenu des cases correspond à des effectifs qui peuvent être sommés en ligne et en colonne. Tout tableau de contingence est en fait le résultat de la transformation d'un tableau élémentaire constitués de deux caractères discrets X et Y décrivant le même ensemble E. Le nombre de ligne d'un tableau de contingence (k) correspond au nombre de modalités du premier caractère discret (X) et le nombre de colonnes (p) correspond au nombre de modalités du second caractère discret (Y). L'effectif d?une case, noté Nij, correspond au "nombre d'éléments du tableau élémentaire E qui prennent simultanément la modalité i de X et la modalité j de Y".
    probas, stats (estimation, régression, test d'hypothèses, méthodes multidimenseionnelles, visualisation

    Que sont les "règles d'association" (et comment les induire)?

    Techniques de classification supervisée

    suppose que l'on puisse affecter chacun des individus a sa classe Réseaux de neurones, SVM phase d'apprentissage

    Techniques de classification non supervisée

    Qu'est-ce qu'une méthode divisive de classification?

    C'est une méthode qui permet de faire de la classification hiérarchique tout en extrayant des règles à partir des jeux de données. En gros elles permettent de définir pourquoi tel données est classé dans tel cluster. Ce type de méthode est peu utilisé du fait de sa complexité (il peut être nécéssaire d'évaluer chaque bipartition d'une classe à chaque étape de l'algorithme). Au point de vue algorithmique, on part d'un cluster contenant tous les objets, qu'on subdivise progressivement en clusters plus petits, jusqu'à atteindre le nombre de classes voulues. Une telle méthode est dite monothétique, car elle utilise les caractèristiques des données une par une, à l'inverse de méthodes dites polythétique

    Qu'est-ce qu'une méthode de classification agglomérative?

    C'est une méthode dans laquelle on place chaque objet dans son cluster, puis on agglomére ces clusters en clusters plus larges

    Qu'est ce qu'un arbre de décision?

    Ce sont des arbres qui permettent d'extraire des règles à partir de données. Les algorithmes ID3, C5.0 permettent de créer des arbres de décisions

    Qu'est ce qu'un arbre de régression?

    CART permet de créer des arbres de régression
    Quels sont les meilleurs logiciels "open source" ou gratuit d'analyse statistique? - the R package (l'équivalent GNU de S-Plus) Télécharger R-1.2.3.tgz (sources) - ADE-4 Ou trouver une initiation à S-plus (et donc à R)? - Initiation au langage Splus par André Carlier, Alain Croquette Ou trouver des documents sur la classification de données multidimensionnelles? - Analyse des Données Multidimensionnelles par André Carlier, Alain Croquette cela consiste a créer les classes
    Ressources: http://ultralix.polytechnique.fr/~cori/Majeure/documents.html

    Chapter 10. Prédiction de structure 3D

    Prédiction de structure

    Utilisation du profil hydrophylique

    Les principales caractèristiques physico-chimiques d'un acide aminé sont le volume, l'accessibilité au solvant, l'hydrophobicité, la taille (petit, gros), et l'aromaticité. Le profil hydrophylique (ou hydropathique) d'une séquence protéique permet d'obtenir quelques indices concernant la structure secondaire de la protéine correspondante. Par exemple, les acides aminés hydrophobiques tendent à se trouver à l'intérieur des protéines globulaires. Dans les protéines transmembranaires, ceux-ci ont tendance à se trouver au niveau de la membrane. Les péridicités au niveau du profil peuvent également indiquer la présence d'hélices alpha. Un tel profil permet également de prédire la présence d'épitopes antigéniques.

    Figure 10.1. Profil hydrophobique de la Rhodopsin humaine (tiré de http://lectures.molgen.mpg.de/Individual/Intro/)

    Le profil hydrophobique d'une protéine peut être généré à partir du programme toppred, dédié à la prédiction de topologie de protéines membranaires. Cet outil est disponible sous la forme d'une interface web à cette adresse.
    IBM va batir un ordinateur parallèle extrèmement puissant dédié à la simulation du repliement protéique. Le projet folding@home a d'ors et deja permi de simuler le repliement d'une petite proteine en des temps record. Ce projet est basé sur la mise a disposition de milliers d'ordinateurs distants. Un autre projet du même type, le Intel-United Devices Cancer Research Project, a pour but de trouver des molécules cibles dans le traitement du cancer. Il s'agit d'un processus appelé "screening virtuel", basé sur un logiciel nommé THINK. THINK crée un modèle 3D de la molécule et tente, en changeant sa forme (conformation), d'en effectuer le "docking" au sein de la protéine cible. Quand une conformation y parvient, et declenche une interaction avec la protéine, on considère qu'il s'agit d'un "hit", et donc une molécule thérapeutique potentielle (si tant est que l'on peut la synthétiser). L'originilalité du projet tient dans le fait que le logiciel THINK est intégré a un economisateur d'ecran, et que celui-ci, librement telechargeable, permet d'utiliser les ressources non-utilisées d'un PC classique.

    Visualisation de structures 3D

    Il existe de nombreux logiciels permettant de visusaliser des fichiers PDB de coordonnées atomiques. Par exemple : - MolMol - Rasmol - cn3d dispobible sur le site FTP du NCBI - QuickPDB QuickPDB is a lightweight applet with two major functions: (i) Find a structure in the PDB based upon a text or sequence search. (ii) Render that structure with ability to mark up fragments in sequence and see them accordingly in structure view. QuickPDB accesses the most current (nightly updated) version of the PDB database located on San Diego Supercomputer Center (SDSC) servers and uses the new index-based database structure for fast search and retrieval which was developed at SDSC Pour obtenir de plus amples renseignements et éventuellement le droit d'utiliser le programme, contacter Phil Bourne (bourne@sdsc.edu). Le code de QuickPDB est quant à lui disponible à l'adresse http://www.sdsc.edu/pb/Software.html il s'agit d'une applet. Le fichier HTML permettant de faire appel à cette applet est le suivant :
    <HTML>
    <HEAD>
    <TITLE> Applet QuickPDB </TITLE>
    </HEAD>
    <BODY BGCOLOR="#FFFFFF">
    <CENTER><H2> Applet QuickPDB </H2></CENTER><BR>
    <CENTER><APPLET CODE="QuickPDB.class" WIDTH="200" HEIGHT="50">
    <PARAM name="moose_db" value="/projects/nbcr/shindyal/db_2016/db_moose"> 
    <PARAM name="html_url" value="http://cl.sdsc.edu"> 
    <PARAM name="cgi_url" value="http://cl.sdsc.edu/cgi-bin"> 
    <PARAM name="rcsb_explore_url" value="http://www.rcsb.org/pdb/cgi/import.cgi?pdbIds"> 
    </APPLET></CENTER>
    <BR><CENTER><I>Press button to start QuickPDB</I>
    </CENTER>
    </BODY>
    </HTML>
    
    les représentations WebMol sont un peu moins belles. CEpandant il est plus puissant et plus complet. Ressources Blue Gene: A vision for protein science using a petaflop supercomputer

    Chapter 11. Le stockage des données et les bases de données

    certaines de ces bases (SwissProt) sont disponibles de manière locale, ce à destination des entreprises qui ne souhaiteraient pas que leur requètes soient connues. Le problème qui se pose alors est la mise à jour automatique des mirroirs

    Les bases de données

    Les bases de données généralistes

    GenBank

    SwissProt

    Les format de données

    XML

    XML fournit une moyen pour implementer des ontologies. Une ontologie est un vocabulaire structuré, in the form of a directed acyclic graph such that each term is descended from its parent by some defined relationship such as "part of." It is a network where the children can have many parents and, in turn, be parents themselves. The objectives of the Gene Ontology Consortium are to define these structured hierarchical vocabularies, to describe biological objects using these terms, and to provide computing tools to manipulate these ontologies and connect them to databases.

    GEML : Gene Expression Markup Language

    http://www.geml.org provide a standard method of exchanging gene expression data along with the associated gene and experiment annotation donner un exemple:

    linkOut LinkOut est une fonctionalité d'Entrez permettant à des tiers de lier des entrées Entrez (donc des entrées PubMed, Protein, Nucleotide, Genome, Structure, PopSet, Taxonomy et OMIM) à des informations online externes. Dans ce cadre, IMGT pourrait intervenir comme fournisseur de ressources non-bibilographiques. Pour ceci il faut fournir au NCBI deux types de fichiers XML : - un fichier d'identité, décrivant le site fournisseur d'information externe (IMGT) Ce fichier serait de ce type :
    
    
    <xml version="1.0"?> 
    <!DOCTYPE Provider PUBLIC "-//NLM//DTD LinkOut 1.0//EN" "LinkOut.dtd"> 
    <Provider> 
        <ProviderId>777</ProviderId> 
        <Name>The International ImMunoGeneTics Database</Name> 
        <NameAbbr>IMGT</NameAbbr> 
        <SubjectType>curated immunogenetics data</SubjectType> 
        <Url>http://imgt.cines.fr</Url> 
        <IconUrl>http://imgt.cines.fr/logo.png</IconUrl> 
        <Brief>online provider of curated immunogenetics data ..</Brief> 
    </Provider> 
    
    
    le champ ProviderId est fourni par NCBI. - un (ou plusieurs ?) fichiers de ressources, permettant de décrire les objets NCBI sur lesquels ajouter les liens, et l'adresse complète du lien sur IMGT correspondant. En voici un exemple : le lien (link) du fichier XML suivant permet de lier 3 sequences de Genbank (numéros 3810674,1217583, 1181594) à la page "Locus representation: Human IGH" ... Il est semble-t-il possible de faire plus compliquer, c'est-a-dire d'associer des liens à des requètes Entrez complexes (ex : human [orgn] AND "IGHV")
    
    
    <?xml version="1.0"?> 
    <!DOCTYPE LinkSet PUBLIC "-//NLM//DTD LinkOut 1.0//EN" "LinkOut.dtd" 
     <!ENTITY icon.url "http://imgt.cines.fr/logo.png"> 
    <!ENTITY base.url "http://imgt.cines.fr/cgi-bin/query.jv?">]> 
    <LinkSet> 
    <Link> 
        <LinkId>1</LinkId> 
        <ProviderId>777</ProviderId> 
        <IconUrl>&icon.url;</IconUrl> 
        <ObjectSelector> 
            <Database>Nucleotide</Database> 
            <ObjectList> 
                <ObjId>3810674</ObjId> 
                <ObjId>1217583</ObjId> 
                <ObjId>1181594</ObjId> 
            </ObjectList> 
        </ObjectSelector> 
        <ObjectUrl> 
            <Base>http://imgt.cines.fr:8104/textes/IMGTrepertoire/LocusGenes/locus/human/IGH/Hu_IGHmap.html</Base> 
            <Rule></Rule> 
        </ObjectUrl> 
    </Link> 
    </LinkSet> 
    
    
    
    Ces 2 fichiers XML doivent etre transmis au NCBI par FTP à cette adresse ftp-private.ncbi.nih.gov SOURCES : - http://www.ncbi.nlm.nih.gov/entrez/linkout/doc/nonbiblinkout.html

    Passer d'un format XML à un autre grâce aux transformations XSLT

    Example concret : transformer la sortie XML de blast en fichier FASTA. Seul Blast NCBI fournit ce type de sortie.
    
    <?xml version="1.0"?>
    <!DOCTYPE BlastOutput PUBLIC "-//NCBI//NCBI BlastOutput/EN" "NCBI_BlastOutput.dtd">
    <BlastOutput>
      <BlastOutput_program>blastn</BlastOutput_program>
      <BlastOutput_version>blastn 2.2.2 [Dec-14-2001]</BlastOutput_version>
      <BlastOutput_reference>~Reference: Altschul, Stephen F., Thomas L. Madden, Alejandro A. Schaffer, ~Jinghui Zhang, Zheng Zhang, Webb Miller, and David J. Lipman (1997), ~&quot;Gapped BLAST and PSI-BLAST: a new generation of protein database search~programs&quot;,  Nucleic Acids Res. 25:3389-3402.</BlastOutput_reference>
      <BlastOutput_db>drosoph</BlastOutput_db>
      <BlastOutput_query-ID>lcl|1_9533</BlastOutput_query-ID>
      <BlastOutput_query-def>R11 Ubi&gt;R11 UbiA repeat unit 11</BlastOutput_query-def>
      <BlastOutput_query-len>228</BlastOutput_query-len>
      <BlastOutput_param>
        <Parameters>
          <Parameters_expect>10</Parameters_expect>
          <Parameters_include>0</Parameters_include>
          <Parameters_sc-match>1</Parameters_sc-match>
          <Parameters_sc-mismatch>-3</Parameters_sc-mismatch>
          <Parameters_gap-open>5</Parameters_gap-open>
          <Parameters_gap-extend>2</Parameters_gap-extend>
          <Parameters_filter>L;</Parameters_filter>
        </Parameters>
      </BlastOutput_param>
      <BlastOutput_iterations>
        <Iteration>
          <Iteration_iter-num>1</Iteration_iter-num>
          <Iteration_hits>
            <Hit>
              <Hit_num>1</Hit_num>
              <Hit_id>gi|7292381|gb|AE003479.1|AE003479</Hit_id>
              <Hit_def>Drosophila melanogaster genomic scaffold 142000013386045 section 13 of 17, complete sequence</Hit_def>
              <Hit_accession>AE003479</Hit_accession>
              <Hit_len>309883</Hit_len>
              <Hit_hsps>
                <Hsp>
                  <Hsp_num>1</Hsp_num>
                  <Hsp_bit-score>214.587</Hsp_bit-score>
                  <Hsp_score>108</Hsp_score>
                  <Hsp_evalue>6.54084e-55</Hsp_evalue>
                  <Hsp_query-from>204</Hsp_query-from>
                  <Hsp_query-to>1</Hsp_query-to>
                  <Hsp_hit-from>214917</Hsp_hit-from>
                  <Hsp_hit-to>215120</Hsp_hit-to>
                  <Hsp_pattern-from>0</Hsp_pattern-from>
                  <Hsp_pattern-to>0</Hsp_pattern-to>
                  <Hsp_query-frame>1</Hsp_query-frame>
                  <Hsp_hit-frame>-1</Hsp_hit-frame>
                  <Hsp_identity>180</Hsp_identity>
                  <Hsp_positive>180</Hsp_positive>
                  <Hsp_gaps>0</Hsp_gaps>
                  <Hsp_align-len>204</Hsp_align-len>
                  <Hsp_density>0</Hsp_density>
                  <Hsp_qseq>TGAAGTGTCGACTGCTTTTGGATGTTGTAATCGGATAGAGTGCGTCCATCCTCGAGCTGCTTTCCAGCAAAGATCAAACGTTGCTGATCTGGTGGGATTCCCTCCTTATCCTGGATTTTGGCTTTGACATTCTCAATGGTGTCCGAAGCTTCGACCTCGAGAGTGATGGTTTTTCCAGTCAAAGTCTTGACGAAGATCTGCATA</Hsp_qseq>
                  <Hsp_hseq>TGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCAGCGAAGATCAGACGCTGCTGATCTGGGGGGATTCCCTCCTTATCCTGAATCTTGGCCTTCACATTCTCAATGGTGTCCGATGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA</Hsp_hseq>
                  <Hsp_midline>||||| || |||| ||| ||||||||||||||||| || |||||||||||||| |||||||| ||||| ||||||| ||| ||||||||||| |||||||||||||||||||| || ||||| || |||||||||||||||||||| |  || |||||||| |||||||| ||||| ||||||||||| |||||||||||||||</Hsp_midline>
                </Hsp>
                <Hsp>
                  <Hsp_num>2</Hsp_num>
                  <Hsp_bit-score>198.729</Hsp_bit-score>
                  <Hsp_score>100</Hsp_score>
                  <Hsp_evalue>3.8871e-50</Hsp_evalue>
                  <Hsp_query-from>204</Hsp_query-from>
                  <Hsp_query-to>1</Hsp_query-to>
                  <Hsp_hit-from>214005</Hsp_hit-from>
                  <Hsp_hit-to>214208</Hsp_hit-to>
                  <Hsp_pattern-from>0</Hsp_pattern-from>
                  <Hsp_pattern-to>0</Hsp_pattern-to>
                  <Hsp_query-frame>1</Hsp_query-frame>
                  <Hsp_hit-frame>-1</Hsp_hit-frame>
                  <Hsp_identity>178</Hsp_identity>
                  <Hsp_positive>178</Hsp_positive>
                  <Hsp_gaps>0</Hsp_gaps>
                  <Hsp_align-len>204</Hsp_align-len>
                  <Hsp_density>0</Hsp_density>
                  <Hsp_qseq>TGAAGTGTCGACTGCTTTTGGATGTTGTAATCGGATAGAGTGCGTCCATCCTCGAGCTGCTTTCCAGCAAAGATCAAACGTTGCTGATCTGGTGGGATTCCCTCCTTATCCTGGATTTTGGCTTTGACATTCTCAATGGTGTCCGAAGCTTCGACCTCGAGAGTGATGGTTTTTCCAGTCAAAGTCTTGACGAAGATCTGCATA</Hsp_qseq>
                  <Hsp_hseq>TGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGGATTCCCTCCTTATCTTGAATCTTGGCCTTCACATTCTCAATGGTGTCCGATGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA</Hsp_hseq>
                  <Hsp_midline>||||| || |||| ||| ||||||||||||||||| || |||||||||||||| |||||||| || || ||||||| ||| ||||||||||| ||||||||||||||||| || || ||||| || |||||||||||||||||||| |  || |||||||| |||||||| ||||| ||||||||||| |||||||||||||||</Hsp_midline>
                </Hsp>
                <Hsp>
                  <Hsp_num>3</Hsp_num>
                  <Hsp_bit-score>186.834</Hsp_bit-score>
                  <Hsp_score>94</Hsp_score>
                  <Hsp_evalue>1.47952e-46</Hsp_evalue>
                  <Hsp_query-from>222</Hsp_query-from>
                  <Hsp_query-to>1</Hsp_query-to>
                  <Hsp_hit-from>214443</Hsp_hit-from>
                  <Hsp_hit-to>214664</Hsp_hit-to>
                  <Hsp_pattern-from>0</Hsp_pattern-from>
                  <Hsp_pattern-to>0</Hsp_pattern-to>
                  <Hsp_query-frame>1</Hsp_query-frame>
                  <Hsp_hit-frame>-1</Hsp_hit-frame>
                  <Hsp_identity>190</Hsp_identity>
                  <Hsp_positive>190</Hsp_positive>
                  <Hsp_gaps>0</Hsp_gaps>
                  <Hsp_align-len>222</Hsp_align-len>
                  <Hsp_density>0</Hsp_density>
                  <Hsp_qseq>CGAAGACGAAGAACGAGATGAAGTGTCGACTGCTTTTGGATGTTGTAATCGGATAGAGTGCGTCCATCCTCGAGCTGCTTTCCAGCAAAGATCAAACGTTGCTGATCTGGTGGGATTCCCTCCTTATCCTGGATTTTGGCTTTGACATTCTCAATGGTGTCCGAAGCTTCGACCTCGAGAGTGATGGTTTTTCCAGTCAAAGTCTTGACGAAGATCTGCATA</Hsp_qseq>
                  <Hsp_hseq>CGAAGACGAAGGACCAAGTGAAGGGTGGACTCCTTCTGAATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGAATTCCCTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATGGTGTCCGAAGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA</Hsp_hseq>
                  <Hsp_midline>||||||||||| || |  ||||| || |||| ||| || |||||||||||||| || |||||||||||||| |||||||| || || ||||||| ||| ||||||||||| || ||||||||||| || ||||| || || || ||||||||||||||||||||||  || |||||||| |||||||| ||||| ||||||||||| |||||||||||||||</Hsp_midline>
                </Hsp>
    	    ...
    
    
    
    
    
    <?xml version="1.0"?> 
    <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> 
    <xsl:output method="text" encoding="iso-8859-1"/>
    
    <xsl:template match="/"> 
    <xsl:apply-templates select="BlastOutput/BlastOutput_iterations/Iteration/Iteration_hits/Hit">
    </xsl:apply-templates>
    </xsl:template> 
    
    <xsl:template match="BlastOutput/BlastOutput_iterations/Iteration/Iteration_hits/Hit"> 
    <xsl:if test="Hit_num=1">
    <xsl:apply-templates select="Hit_hsps/Hsp">
    <xsl:sort data-type="number" select="Hsp_hit-from"/>
    </xsl:apply-templates>
    </xsl:if>
    </xsl:template> 
    
    
    <xsl:template match="Hit_hsps/Hsp"> 
    >seq<xsl:value-of select="Hsp_num"/>-<xsl:value-of select="Hsp_hit-from"/>-<xsl:value-of select="Hsp_hit-to"/>
    <xsl:text>
    </xsl:text>
    <xsl:value-of select="Hsp_hseq"/>
    </xsl:template> 
    
    </xsl:stylesheet> 
    
    
    
     
    >seq4-213091-213294
    TGAAGGGTCGATTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGAATTCCCTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATGGTGTCCGAGGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq6-213319-213523
    TGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATGCTGGGGGAATTCCCTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATGGTGTCCGAAGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq8-213548-213751
    TGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGAATTCCCTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATTGTGTCCGATGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq5-213758-213980
    CGAAGACGAAGGACCAAGTGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACTGCTGCTGATCTGGGGGAATTCCCTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATGGTGTCCGAAGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq2-214005-214208
    TGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGGATTCCCTCCTTATCTTGAATCTTGGCCTTCACATTCTCAATGGTGTCCGATGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq9-214233-214436
    TGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGAATTCCCTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATTGTGTCCGATGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq3-214443-214664
    CGAAGACGAAGGACCAAGTGAAGGGTGGACTCCTTCTGAATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGAATTCCCTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATGGTGTCCGAAGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq7-214689-214892
    TGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGAATTCCCTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATTGTGTCCGATGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq1-214917-215120
    TGAAGGGTGGACTCCTTCTGGATGTTGTAATCGGACAGGGTGCGTCCATCCTCAAGCTGCTTGCCAGCGAAGATCAGACGCTGCTGATCTGGGGGGATTCCCTCCTTATCCTGAATCTTGGCCTTCACATTCTCAATGGTGTCCGATGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACGAAGATCTGCATA 
    >seq10-215145-215347
    TGAAGGGTGGACTCCTTCTGAATGTTGTAATCGGACAGGGTGCGTCCGTCTTCCAGTTGCTTGCCGGCGAAGATCAGACGCTGCTGATCTGGGGGAATTCCTTCCTTGTCTTGGATCTTAGCCTTAACATTCTCAATGGTGTCCGAGGGCTCTACCTCGAGGGTGATGGTCTTTCCGGTCAAAGTCTTCACAAAGATCTGCAT
    
    D'autres balises XSL :
    
    <xsl:if test="truc="bleu"">
    
    </xsl:if>
    
    
    
    définir un attribut toto="gogo" pour la balise entourante
    
    <table>
    <xsl:attribute name="width">100%</xsl:attribute>
    </table>
    cela donne :
    <table width="100%">
    
    </table>
    
    
    

    Xalan

    Utilisation :

    java org.apache.xalan.xslt.Process -in bioinfo.xml -xsl docbook.xsl -out bioinfo.html
    

    Sablotron

    sabcmd sheet.xsl arg:/the_input "the_input=<a/>" "$use_defaults=1"

    Ressources: Documentation de Sablotron, Gingerall Inc.

    Chapter 12. Construction de base de données

    Avant de commencer la construction d'une base de données d'objets biologiques, il est nécessaire de se poser un certain nombre de questions. Par exemple :

    ce type de base existe-t-il deja? si oui, quel avantage y a-t-il à proposer une nouvelle base de données?

    Comment se déroulera le recueil de l'information et l'entrée de ces informations dans la base ? d'ou viennent les données et qui va les rentrer? cela va-t-il se faire de manière automatique, ou bien faudra-t-il une armée d'annotateurs aux connaissances pointues? L'expérience montre que le tout automatique ne fournit pas des résultats de qualité, du fait de manque de standardisation, des imprécisions, ou des erreurs dans la chaîne de saisie. D'une manière générale, l'annotation automatique est aujourd'hui difficile voire impossible.

    Quelles requètes et quels types de sorties seront nécéssaires ? à quel public se destine cette base de données? il faut pour cela étudier des interfaces utilisateurs conviviales, faciles à utiliser, et adaptées au public visé.

    Pour illustrer , nous allons construire une simple base de données de protéines et d'interactions protéine-protéine. Ce type de base de données existe bien évidemment déjà (ProNet par exemple). Néanmoins, une telle base peut avoir un interet dans un domaine spécifique.

    Une telle base de données définit un type principal d'objet : la protéine. Une protéine peut être décrite par un très grand nombre de critères. Dans le cadre de cette base, nous décrirons une protéine comme possédant un nom complet et un nom raccourci, une fonction sous la forme d'un texte descriptif, une séquence d'acides aminés, un code PDB correspondant à une structure associée dans la base de données PDB, ainsi qu'un numéro d'accès SWISSPROT.

    Nous considérerons également qu'une protéine peut se voir associer un nombre variable de publications, représentées par leur numéro d'accès dans PUBMED.

    Enfin, nous considérerons que les protéines peuvent interagir deux à deux, et que cette interaction peut faire l'objet d'une description ou commentaire dans la base.

    Choix technologiques

    • le système de gestion de base de données : il s'agit du coeur des bases de données. Il existe trois types de bases de données: les bases de données relationnelles, les bases de données purement objet (ozone), et les bases de données relationnel-objet. Un quatrième type de base de données est néanmoins en train d'emerger, il s'agit de bases permettant de stocker des données au format XML de manière native.
    • la plateforme ou système d'exploitation
    • le serveur web, si cette base de données doit être accessible au travers d'un interface web (soumission de données ou interrogation)
    • le serveur d'application, dont le role est de permettre l'extraction de données à partir de la base en fonction des requètes effectuées par l'utilisateur, puis la construction automatique de pages HTML à partir de ces mêmes données.

    Figure 12.1. PROTDB

    Nous utiliserons, dans l'exemple qui suit, un serveur web Apache, le serveur applicatif Perl, ainsi qu'une base de données MySQL. Ces logiciels sont gratuits, très performants et utilisés dans de très nombreux projets de base de données. Autre argument important, tous ces logiciels sont disponibles pour les plateformes courantes (Windows, Linux, etc.).

    Pourquoi Apache ?

    En ce qui concerne le serveur web, le choix est plutot restreint. Outre sa gratuité et sa disponibilité, Apache a depuis longtemps fait les preuves de sa robustesse, de sa rapidité et de sa stabilité. En outre, il offre une sécurité maximale sous Windows comme sous Unix.

    Pourquoi Perl ?

    Très utilisé dans le domaine de la bioinformatique, Perl est certainement l'un langage de programmation les plus simples à apprendre. Il existe de nombreux modules Perl (Ex : BioPerl) dont le but est de simplifier les taches routinières du bioinformaticien. Perl possède également des modules permettant d'interroger la plupart des bases de données

    Pourquoi MySQL ?

    MySQL (ou son principal concurrent PostgreSQL) est à ce jour suffisament élaboré pour être utilisé dans de très nombreux cas. Leur fiabilité est généralement excellente, leur disponibilité totale, et en plus ils sont gratuits. MySQL permet de créer des tables contenant plusieurs milliards d'enregistrements.

    Création de la base de données

    Conception Merise et diagrammes

    La méthodologie MERISE fournit un cadre pour la conception efficace de bases de données. Cette méthodologie s'articule autour de trois grandes étapes :

    • établir un modèle conceptuel de données ou MCD
    • établir un modèle logique de données ou MLD
    • établir un modèle physique ou MP

    Le MCD est un formalisme permettant de décrire les données intervenant dans le problème et les liens existant entre ces informations de façon claire, simple, complète et non ambiguë. Les formalismes utilisés se situent délibérément en dehors de considérations techniques de stockage informatique des données. Un MCD comprend des entités, des relations, des propriétés, des cardinalités, des identifiants. Une relation peut etre nommée (ex : etre, avoir, represente, etc.). Certaines clés sont plus faciles a manipuler (numéros, codes, etc.). De même, pour une seule entité, plusieurs attributs peuvent avoir le statut de clé.

    Le MCD se représente habituellement à l'aide de diagrammes, qu'il est possible de dessiner grace au programme dia. Par exemple :

    Figure 12.2. PROTDB

    Le modèle logique des données (MLD) consiste à décrire la structure de données utilisée sans faire référence à un langage de programmation. Il s'agit donc de préciser le type de données utilisées lors des traitements. Ainsi, le modèle logique est dépendant du type de base de données utilisé.

    Le MP correspond à la traduction du MLD en langage comprehensible par la machine (ex : SQL). C'est ce que nous ferons dans la prochaine section.

    Ressources:
    • Initiation aux bases de données http://www.grappa.univ-lille3.fr/polys/access-1997/access.html Dominique Gonzalez
    • Conception de base de données http://www.commentcamarche.net/merise/concintro.php3

    Création de la base de données et des tables

    Créons la base de données :

    $ mysql 
    Welcome to the MySQL monitor.  Commands end with ; or \g.
    Your MySQL connection id is 21 to server version: 3.23.36
    
    Type 'help;' or '\h' for help. Type '\c' to clear the buffer
    
    mysql> CREATE DATABASE protdb
    

    Voici les tables devant être créées : les principaux types de données :

    • INT
    • FLOAT
    • VARCHAR
    • CHAR
    • TEXT
    • ENUM

    Remarque : il n'existe pas de type BOOLEAN. Pour cela, on utilise généralement TINYINT ou ENUM('true', 'false')

    
    CREATE TABLE PROTEINES (
    PROTEINE_ID            int not null auto_increment,
    PROTEINE_NOM           varchar(100),
    PROTEINE_DESCRIPTION   varchar(255),
    PROTEINE_FONCTION      text,
    PROTEINE_AASEQUENCE    text,
    PROTEINE_PDBID         varchar(20),
    PROTEINE_SPID          varchar(10),
    primary key(PROTEINE_ID)
    );
    
    CREATE TABLE INTERACTIONS (
    INTER_ID		int not null auto_increment primary key,
    INTER_PROTEINEID1    int,
    INTER_PROTEINEID2    int,
    INTER_COMMENTAIRE  text
    );
    
    CREATE TABLE PUBLICATIONS (
    PUBLI_PROTEINEID    int,
    PUBLI_PUBMEDID      varchar(10)
    );
    
    

    Avec votre éditeur de texte favori, créez un fichier nommé protdb.sql (par exemple), puis insérez-y les commandes SQL ci-dessus. La création physique des tables se fait alors au moyen de la commande :

    $ mysql protdb < protdb.sql
    

    Remarque : il peut être utile, si le schéma de la base est appelé à être modifié souvent de préceder les instructions CREATE TABLE XXX par la commande DROP TABLE IF EXISTS XXX; permettant de supprimer la table. Par exemple :

    DROP TABLE IF EXISTS PUBLICATIONS;
    CREATE TABLE PUBLICATIONS (
    PUBLI_PROTEINEID    int,
    PUBLI_PUBMEDID      varchar(10) not null primary key
    );
    
    

    Entrer des données dans la base

    Entrer de nouvelles données via SQL

    La commande SQL pour insérer de nouvelles données dans une table est la commande INSERT. Par exemple, pour insérer la protéine GADD45a dans notre base de données :
    
    INSERT INTO PROTEINES (PROTEINE_NOM, 
                           PROTEINE_DESCRIPTION, 
                           PROTEINE_FONCTION, 
    		       PROTEINE_AASEQUENCE, 
                           PROTEINE_PDBID, 
                           PROTEINE_SPID) VALUES (
                           'GADD45a',
    		       'growth arrest and DNA damage inducible protein GADD45, alpha',
    		       'MTLEEFSAGEQKTERMDKVGDALEEVLSKALSQRTITVGVYEAAKLLNVDPDNVVLCLLAADEDDDRDVALQIHFTLIQAFCCENDINILRVSNPGRLAELLLLETDAGPAASEGAEQPPDLHCVLVTNPHSSQWKDPALSQLICFCRESRYMDQWVPVINLPER*',
    		       'BINDS TO PROLIFERATING CELL NUCLEAR ANTIGEN. MIGHT AFFECT PCNA INTERACTION WITH SOME CDK (CELL DIVISION PROTEIN KINASE) COMPLEXES; STIMULATES DNA EXCISION REPAIR IN VITRO AND INHIBITS ENTRY OF CELLS INTO S PHASE',
    		       '',
    		       'P24522');
    
    
    Maintenant, interrogeons la base de données pour voir l'effet de cette commande :
    
    mysql> select * from PROTEINES\G 
    *************************** 1. row ***************************
             PROTEINE_ID: 1
            PROTEINE_NOM: GADD45a
    PROTEINE_DESCRIPTION: growth arrest and DNA damage inducible protein GADD45, alpha
       PROTEINE_FONCTION: MTLEEFSAGEQKTERMDKVGDALEEVLSKALSQRTITVGVYEAAKLLNVDPDNVVLCLLAADEDDDRDVALQIHFTLIQAFCCENDINILRVSNPGRLAELLLLETDAGPAASEGAEQPPDLHCVLVTNPHSSQWKDPALSQLICFCRESRYMDQWVPVINLPER*
     PROTEINE_AASEQUENCE: BINDS TO PROLIFERATING CELL NUCLEAR ANTIGEN. MIGHT AFFECT PCNA INTERACTION WITH SOME CDK (CELL DIVISION PROTEIN KINASE) COMPLEXES; STIMULATES DNA EXCISION REPAIR IN VITRO AND INHIBITS ENTRY OF CELLS INTO S PHASE
          PROTEINE_PDBID: 
           PROTEINE_SPID: P24522
    1 row in set (0.00 sec)
    
    mysql> 
    
    
    
    On notera que la requète INSERT précédente ne portais pas sur le champ PROTEINE_ID, de type INT NOT NULL AUTO_INCREMENT. Or nous voyons bien que celui-ci a automatiquement mis à 1 pour la protéine GADD45a. Insérons maintenant les données suivantes :
    
    INSERT INTO PROTEINES (PROTEINE_NOM, 
                           PROTEINE_DESCRIPTION, 
                           PROTEINE_FONCTION, 
    		       PROTEINE_FONCTION, 
                           PROTEINE_AASEQUENCE, 
                           PROTEINE_PDBID, 
                           PROTEINE_SPID) VALUES (
                           'PCNA',
    		       'proliferating cell nuclear antigen',
    		       'MFEARLVQGSILKKVLEALKDLINEACWDISSSGVNLQSMDSSHVSLVQLTLRSEGFDTYRCDRNLAMGVNLTSMSKILKCAGNEDIITLRAEDNADTLALVFEAPNQEKVSDYEMKLMD LDVEQLGIPEQEYSCVVKMPSGEFARICRDLSHIGDAVVISCAKDGVKFSASGELGNGNI KLSQTSNVDKEEEAVTIEMNEPVQLTFALRYLNFFTKATPLSSTVTLSMSADVPLVVEYKIADMGHLKYYLAPKIEDEEGS*',
    		       'THIS PROTEIN IS AN AUXILIARY PROTEIN OF DNA POLYMERASE DELTA AND IS INVOLVED IN THE CONTROL OF EUKARYOTIC DNA REPLICATION BY INCREASING THE POLYMERASE'S PROCESSIBILITY DURING ELONGATION OF THE LEADING STRAND',
    		       '1AXC',
    		       'P12004');
    
    
    mysql> select * from PROTEINES\G
    *************************** 1. row ***************************                                                          
             PROTEINE_ID: 1
            PROTEINE_NOM: GADD45a
    PROTEINE_DESCRIPTION: growth arrest and DNA damage inducible protein GADD45, alpha
       PROTEINE_FONCTION: MTLEEFSAGEQKTERMDKVGDALEEVLSKALSQRTITVGVYEAAKLLNVDPDNVVLCLLAADEDDDRDVALQIHFTLIQAFCCENDINILRVSNPGRLAELLLLETDAGPAASEGAEQPPDLHCVLVTNPHSSQWKDPALSQLICFCRESRYMDQWVPVINLPER*
     PROTEINE_AASEQUENCE: BINDS TO PROLIFERATING CELL NUCLEAR ANTIGEN. MIGHT AFFECT PCNA INTERACTION WITH SOME CDK (CELL DIVISION PROTEIN KINASE) COMPLEXES; STIMULATES DNA EXCISION REPAIR IN VITRO AND INHIBITS ENTRY OF CELLS INTO S PHASE
          PROTEINE_PDBID: 
           PROTEINE_SPID: P24522
    *************************** 2. row ***************************
             PROTEINE_ID: 2
            PROTEINE_NOM: PCNA
    PROTEINE_DESCRIPTION: proliferating cell nuclear antigen
       PROTEINE_FONCTION: MFEARLVQGSILKKVLEALKDLINEACWDISSSGVNLQSMDSSHVSLVQLTLRSEGFDTYRCDRNLAMGVNLTSMSKILKCAGNEDIITLRAEDNADTLALVFEAPNQEKVSDYEMKLMD LDVEQLGIPEQEYSCVVKMPSGEFARICRDLSHIGDAVVISCAKDGVKFSASGELGNGNI KLSQTSNVDKEEEAVTIEMNEPVQLTFALRYLNFFTKATPLSSTVTLSMSADVPLVVEYKIADMGHLKYYLAPKIEDEEGS*
     PROTEINE_AASEQUENCE: THIS PROTEIN IS AN AUXILIARY PROTEIN OF DNA POLYMERASE DELTA AND IS INVOLVED IN THE CONTROL OF EUKARYOTIC DNA REPLICATION BY INCREASING THE POLYMERASE'S PROCESSIBILITY DURING ELONGATION OF THE LEADING STRAND
          PROTEINE_PDBID: 1AXC
           PROTEINE_SPID: P12004
    2 rows in set (0.47 sec)
    
    mysql>
    
    

    Tout comme pour GADD45a, nous voyons bien que le champ PROTEINE_ID de PCNA a automatiquement mis à 2.

    Insérons maintenant une interaction entre ces deux protéines :

    
    INSERT INTO INTERACTIONS (INTER_PROTEINEID1, INTER_PROTEINEID2, INTER_COMMENTAIRE)
                              VALUES ('1', '2', 'Using complementary in vivo and in vitro interaction assays the N-terminal (1-46) and middle (100-127) regions of PCNA were identified as harboring MyD118- and Gadd45 interacting domains, whereas PCNA interacting domains within MyD118 and Gadd45 were localized to the C termini of these proteins (amino acids 114-156 and 137-165, respectively)');
    
    
    
    
    

    Entrer de nouvelles données via Perl et SQL

    Le script suivant permet de rentrer la description d'une protéine (contenue dans le script) dans la BD :
    #!/usr/bin/perl
    
    use DBI();
    
    $dbh = DBI->connect(    "DBI:mysql:database=protdb;host=localhost", 
                            "", 
                            "",
                            {'RaiseError' => 1}
                    );
    
    my %data = ();
    
    %data = ("PROTEINE_NOM"           => "MTK1",
             "PROTEINE_DESCRIPTION"   => "protein kinase, mitogen-activated, kinase kinase 1",
    	 "PROTEINE_FONCTION"      => "ACTIVATES THE CSBP2, P38 AND JNK MAPK PATHWAYS, BUT NOT THE ERK PATHWAY. SPECIFICALLY PHOSPHORYLATES AND ACTIVATES MAP2K4 AND MAP2K6",
    	 "PROTEINE_AASEQUENCE"    => "
     MREAAAALVPPPAFAVTPAAAMEEPPPPPPPPPPPPEPETESEPECCLAARQEGTLGDSA
     CKSPESDLEDFSDETNTENLYGTSPPSTPRQMKRMSTKHQRNNVGRPASRSNLKEKMNAP
     NQPPHKDTGKTVENVEEYSYKQEKKIRAALRTTERDHKKNVQCSFMLDSVGGSLPKKSIP
     DVDLNKPYLSLGCSNAKLPVSVPMPIARPARQTSRTDCPADRLKFFETLRLLLKLTSVSK
     KKDREQRGQENTSGFWLNRSNELIWLELQAWHAGRTINDQDFFLYTARQAIPDIINEILT
     FKVDYGSFAFVRDRAGFNGTSVEGQCKATPGTKIVGYSTHHEHLQRQRVSFEQVKRIMEL
     LEYIEALYPSLQALQKDYEKYAAKDFQDRVQALCLWLNITKDLNQKLRIMGTVLGIKNLS
     DIGWPVFEIPSPRPSKGNEPEYEGDDTEGELKELESSTDESEEEQISDPRVPEIRQPIDN
     SFDIQSRDCISKKLERLESEDDSLGWGAPDWSTEAGFSRHCLTSIYRPFVDKALKQMGLR
     KLILRLHKLMDGSLQRARIALVKNDRPVEFSEFPDPMWGSDYVQLSRTPPSSEEKCSAVS
     WEELKAMDLPSFEPAFLVLCRVLLNVIHECLKLRLEQRPAGEPSLLSIKQLVRECKEVLK
     GGLLMKQYYQFMLQEVLEDLEKPDCNIDAFEEDLHKMLMVYFDYMRSWIQMLQQLPQASH
     SLKNLLEEEWNFTKEITHYIRGGEAQAGKLFCDIAGMLLKSTGSFLEFGLQESCAEFWTS
     ADDSSASDEIIRSVIEISRALKELFHEARERASKALGFAKMLRKDLEIAAEFRLSAPVRD
     LLDVLKSKQYVKVQIPGLENLQMFVPDTLAEEKSIILQLLNAAAGKDCSKDSDDVLIDAY
     LLLTKHGDRARDSEDSWGTWEAQPVKVVPQVETVDTLRSMQVDNLLLVVMQSAHLTIQRK
     AFQQSIEGLMTLCQEQTSSQPVIAKALQQLKNDALELCNRISNAIDRVDHMFTSEFDAEV
     DESESVTLQQYYREAMIQGYNFGFEYHKEVVRLMSGEFRQKIGDKYISFARKWMNYVLTK
     CESGRGTRPRWATQGFDFLQAIEPAFISALPEDDFLSLQALMNECIGHVIGKPHSPVTGL
     YLAIHRNSPRPMKVPRCHSDPPNPHLIIPTPEGFSTRSMPSDARSHGSPAAAAAAAAAVA
     ASRPSPSGGDSVLPKSISSAHDTRGSSVPENDRLASIAAELQFRSLSRHSSPTEERDEPA
     YPRGDSSGSTRRSWELRTLISQSKDTASKLGPIEAIQKSVRLFEEKRYREMRRKNIIGQV
     CDTPKSYDNVMHVGLRKVTFKWQRGNKIGEGQYGKVYTCISVDTGELMAMKEIRFQPNDH
     KTIKETADELKIFEGIKHPNLVRYFGVELHREEMYIFMEYCDEGTLEEVSRLGLQEHVIR
     LYSKQITIAINVLHEHGIVHRDIKGANIFLTSSGLIKLGDFGCSVKLKNNAQTMPGEVNS
     TLGTAAYMAPEVITRAKGEGHGRAADIWSLGCVVIEMVTGKRPWHEYEHNFQIMYKVGMG
     HKPPIPERLSPEGKDFLSHCLESDPKMRWTASQLLDHSFVKVCTDEE*",
    
    	 "PROTEINE_PDBID"        => "",
    	 "PROTEINE_SPID"         => "Q9Y6R4");
    
    $query = "INSERT INTO PROTEINES (
                           PROTEINE_NOM, 
                           PROTEINE_DESCRIPTION, 
                           PROTEINE_FONCTION, 
    		       PROTEINE_AASEQUENCE, 
                           PROTEINE_PDBID, 
                           PROTEINE_SPID) VALUES (
                           '$data{"PROTEINE_NOM"}',
    		       '$data{"PROTEINE_DESCRIPTION"}',
    		       '$data{"PROTEINE_FONCTION"}',
    		       '$data{"PROTEINE_AASEQUENCE"}',
    		       '$data{"PROTEINE_PDBID"}',
    		       '$data{"PROTEINE_SPID"}');";
    
    $sth = $dbh->do($query);
    
    # le champ PROTEINE_ID, automatiquement affecté par MySQL est stocké dans $sth->{'mysql_insertid'};
    
    print "Protéine " . $sth->{'mysql_insertid'} . " insérée dans la base!\n";
            
    
    Insérons maintenant une interaction entre GADD45a et MTK1, toujours grace à Perl.
    
    #!/usr/bin/perl
    
    $query = "SELECT PROTEINE_ID FROM PROTEINES WHERE PROTEINE_NOM = 'GADD45a' OR PROTEINE_NOM = 'MTK1'";
    
    $sth = $dbh->prepare($query);
    $res = $sth->execute;
            
    $row = $sth->fetchrow_hashref;
    $protein1 = $row->{"PROTEINE_ID"};
    
    $row = $sth->fetchrow_hashref;
    $protein2 = $row->{"PROTEINE_ID"};
    
    $query = "INSERT INTO INTERACTIONS (
                           INTER_PROTEINEID1, INTER_PROTEINEID2, INTER_COMMENTAIRE)
              VALUES ('$protein1',
    	          '$protein2',
    		  'commentaire ...');   
    
    

    Définir un formulaire HTML d'entrée de donnée

    Ce formulaire doit permettre de rentrer une nouvelle protéine, et de lui affecter une interaction avec une ou plusieurs protéines déjà présentes dans la base.

    Figure 12.3. PROTDB

    
    
    #!/usr/bin/perl
    
    #
    # Perl (traitement de données)
    #
    
    use DBI();
    use CGI;
    
    $cgi =new CGI;
    
    $dbh = DBI->connect(    "DBI:mysql:database=protdb;host=localhost", 
                            "", 
                            "",
                            {'RaiseError' => 1}
                    );
    
    $query = "SELECT PROTEINE_NOM, PROTEINE_ID FROM PROTEINES";
    
    $sth = $dbh->prepare($query);
    $res = $sth->execute;
            
    my $select = '<select name="INTERACTIONS" multiple="true">'
    ;
    while ($row = $sth->fetchrow_hashref) {
          $select .= '<option value="' . $row->{PROTEINE_ID} . '">' . $row->{PROTEINE_NOM} . "</option>\n"; 
    }
    
    $select .= "</select>";
          
    
    
    #
    # HTTP header
    #
    print $cgi->header;
    
    #
    # HTML (affichage)
    # 
    print <<STOP;
    <html>
    <body bgcolor="white">
    
    
    <form action="/perl/insert.pl">
    <table>
    
    <tr>
    <td align="right">
    Nom
    </td>
    <td>
    <input type="text" name="PROTEINE_NOM" value="">
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Description
    </td>
    <td>
    <input type="text" name="PROTEINE_DESCRIPTION" value="" size="30">
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Fonction
    </td>
    <td>
    <input type="text" name="PROTEINE_FONCTION" value="" size="30">
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Séquence
    </td>
    <td>
    <textarea name="PROTEINE_AASEQUENCE" cols="40" rows="10"></textarea>
    </td>
    </tr>
    
    
    <tr>
    <td align="right">
    code PDB
    </td>
    <td>
    <input type="text" name="PROTEINE_PDBID" value="" size="30">
    </td>
    </tr>
    
    <tr>
    <td align="right">
    code SWISSPROT
    </td>
    <td>
    <input type="text" name="PROTEINE_SPID" value="" size="30">
    </td>
    </tr>
    
    
    <tr>
    <td align="right">
    Interagit avec
    </td>
    <td>
    $select
    </td>
    </tr>
    
    
    
    <tr>
    <td align="right">
    </td>
    <td>
    <input type="submit" name="" value="Valider">
    
    </td>
    </tr>
    
    </table>
    
    </form>
    
    </body>
    </html>
    
    STOP
    
    
    
    
    
    Ce script perl doit être placé dans le répertoire cgi-bin ou celui correspondant à mod_perl, puis rendu éxécutable grâce à la commande :
    chmod +x protdb_input.pl
    

    Construire le script Perl correspondant

    Cas le plus fréquent et le plus pratique : utiliser le même script pour l'affichage du formulaire et l'insertion des données.
    
    #!/usr/bin/perl
    
    #
    # Perl (traitement de données)
    #
    
    use DBI();
    use CGI;
    
    $cgi =new CGI;
    
    $dbh = DBI->connect(    "DBI:mysql:database=protdb;host=localhost", 
                            "", 
                            "",
                            {'RaiseError' => 1}
                    );
    
    my $select = "";
    
    if ($cgi->param) {
        
        # insere la description de la proteine dans la BD
        $query = "INSERT INTO PROTEINES (
                           PROTEINE_NOM, 
                           PROTEINE_DESCRIPTION, 
                           PROTEINE_FONCTION, 
    		       PROTEINE_AASEQUENCE, 
                           PROTEINE_PDBID, 
                           PROTEINE_SPID) VALUES (
                           '" . $cgi->param("PROTEINE_NOM") . "',
    		       '" . $cgi->param("PROTEINE_DESCRIPTION") . "',
    		       '" . $cgi->param("PROTEINE_FONCTION") . "',
    		       '" . $cgi->param("PROTEINE_AASEQUENCE") . "',
    		       '" . $cgi->param("PROTEINE_PDBID") . "',
    		       '" . $cgi->param("PROTEINE_SPID") . "');";
    
        $sth = $dbh->do($query);
    
        # insere les interaction
    
        # redirige le navigateur vers une autre page
        print $cgi->redirect("ok.html");
        
        
    } else {
        $query = "SELECT PROTEINE_NOM, PROTEINE_ID FROM PROTEINES";
        
        $sth = $dbh->prepare($query);
        $res = $sth->execute;
        
        $select = '<select name="INTERACTIONS" multiple="true">'
    	;
        while ($row = $sth->fetchrow_hashref) {
    	$select .= '<option value="' . $row->{PROTEINE_ID} . '">' . $row->{PROTEINE_NOM} . "</option>\n"; 
        }
        
        $select .= "</select>";
    }   
    
        
    #
    # HTTP header
    #
    print $cgi->header;
    
    #
    # HTML (affichage)
    # 
    
     
    print <<STOP;
    <html>
    <body bgcolor="white">
    
    
    <form action="/perl/protdb_input.pl">
    <table>
    
    <tr>
    <td align="right">
    Nom
    </td>
    <td>
    <input type="text" name="PROTEINE_NOM" value="">
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Description
    </td>
    <td>
    <input type="text" name="PROTEINE_DESCRIPTION" value="" size="30">
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Fonction
    </td>
    <td>
    <input type="text" name="PROTEINE_FONCTION" value="" size="30">
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Séquence
    </td>
    <td>
    <textarea name="PROTEINE_AASEQUENCE" cols="40" rows="10"></textarea>
    </td>
    </tr>
    
    
    <tr>
    <td align="right">
    code PDB
    </td>
    <td>
    <input type="text" name="PROTEINE_PDBID" value="" size="30">
    </td>
    </tr>
    
    <tr>
    <td align="right">
    code SWISSPROT
    </td>
    <td>
    <input type="text" name="PROTEINE_SPID" value="" size="30">
    </td>
    </tr>
    
    
    <tr>
    <td align="right">
    Interagit avec
    </td>
    <td>
    $select
    </td>
    </tr>
    
    
    
    <tr>
    <td align="right">
    </td>
    <td>
    <input type="submit" name="" value="Valider">
    
    </td>
    </tr>
    
    </table>
    
    </form>
    
    </body>
    </html>
    
    STOP
    
    
    

    Constrôle des données entrées via le formulaire

    Quelques lignes de code Javascript permettent d'être sur que certains champs seront systématiquement remplis, et qu'ils seront remplis de la bonne manière. Par exemple, il est possible de s'assurer que le champ PROTEINE_NOM contient au moins 4 caractères (aucun nom de protéine ne possède moins de 4 caractères).

    Interroger la base

    Il importe évidemment de bien définir le type de requète pouvant être soumises a la base. Exemple : fiche de protéine avec ses interactions Exemple de lien vers SWISSPROT : http://www.expasy.ch/cgi-bin/sprot-search-ac?P24522
    
    #!/usr/bin/perl
    
    #
    # Perl (traitement de données)
    #
    
    use DBI();
    use CGI;
    
    $cgi =new CGI;
    
    $dbh = DBI->connect(    "DBI:mysql:database=protdb;host=localhost", 
                            "", 
                            "",
                            {'RaiseError' => 1}
                    );
    
    my $select = "";
    
    if ($cgi->param) {
        
        # recupere la description de la proteine dans la BD
        $query = "SELECT * FROM PROTEINES WHERE PROTEINE_ID = '" . $cgi->param("PROTEINE_ID") . "'";;
        $sth = $dbh->prepare($query);
        $res = $sth->execute;
        
        $proteine = $sth->fetchrow_hashref;
        
    	
        # recupere les protéines qui interagissent avec celle-ci et en fait une liste
        $query = "SELECT t1.* FROM PROTEINES as t1, INTERACTIONS as t2 
                  WHERE (t2.INTER_PROTEINEID2 = '". $cgi->param("PROTEINE_ID") . "' AND t1.PROTEINE_ID = t2.INTER_PROTEINEID1)
                  OR    (t2.INTER_PROTEINEID1 = '". $cgi->param("PROTEINE_ID") . "' AND t1.PROTEINE_ID = t2.INTER_PROTEINEID2)";
        
        $sth = $dbh->prepare($query);
        $res = $sth->execute;
        
        # batit le tableau
        $select = "<table border=1>";
        $select .= "<tr><td>Nom</td><td>code SWWISPROT</td>\n";
        while ($inter = $sth->fetchrow_hashref) {
    	$select .= "<tr><td>" . $inter->{PROTEINE_NOM} . "</td>
            <td><a href=\"http://www.expasy.ch/cgi-bin/sprot-search-ac?" . $inter->{PROTEINE_SPID} . "\">" . $inter->{PROTEINE_SPID} . "</a></td>\n";
        }
        $select .= "</table>";
        
    
            
        
    } else {
        $query = "SELECT PROTEINE_NOM, PROTEINE_ID FROM PROTEINES";
        
        $sth = $dbh->prepare($query);
        $res = $sth->execute;
        
        $select = '<select name="PROTEINE_ID">'
    	;
        while ($row = $sth->fetchrow_hashref) {
    	$select .= '<option value="' . $row->{PROTEINE_ID} . '">' . $row->{PROTEINE_NOM} . "</option>\n"; 
        }
        
        $select .= "</select>";
    }   
    
        
    #
    # HTTP header
    #
    print $cgi->header;
    
    #
    # HTML (affichage)
    # 
    
    if ($cgi->param) { 
    
    
        print <<STOP;
    
    <html>
    <body bgcolor="white">
    
    
    
    <table border="1">
    
    <tr>
    <td align="right">
    Nom
    </td>
    <td>
    $proteine->{PROTEINE_NOM}
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Description
    </td>
    <td>
    $proteine->{PROTEINE_DESCRIPTION}
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Fonction
    </td>
    <td>
    $proteine->{PROTEINE_FONCTION}
    </td>
    </tr>
    
    <tr>
    <td align="right">
    Séquence
    </td>
    <td>
    $proteine->{PROTEINE_AASEQUENCE}
    </td>
    </tr>
    
    
    <tr>
    <td align="right">
    code PDB
    </td>
    <td>
    $proteine->{PROTEINE_PDBID}
    </td>
    </tr>
    
    <tr>
    <td align="right">
    code SWISSPROT
    </td>
    <td>
    $proteine->{PROTEINE_SPID}
    </td>
    </tr>
    
    
    <tr>
    <td align="right">
    Interagit avec
    </td>
    <td>
    $select
    </td>
    </tr>
    
    
    
    <tr>
    <td align="right">
    </td>
    <td>
    <input type="submit" name="" value="Valider">
    
    </td>
    </tr>
    
    </table>
    
    
    
    </body>
    </html>
    
    STOP
    
    } else {
    
        print <<STOP;
    <html>
    <body bgcolor="white">
    
    
    <form action="/perl/protdb_query.pl">
        
    $select
    <input type="submit" value="GO!">    
    </form>
    STOP
    } 
    
    
    

    Figure 12.4. Liste des protéines à consulter

    Figure 12.5. résultats : affichage d'une fiche protéine

    Bonus : utilisation des logs Apache et Perl

    Comment trouver les erreurs dans les scripts Perl ?

    Si Perl est utilisé en CGI, les erreurs lancées par vos scripts se trouvent ajoutées au fichier d'erreurs du serveur web. Celui-ci peut se trouver à divers endroits selon les plateformes. Par exemple, pour Apache sous Linux Mandrake, le fichier contenant les erreurs est situé à /var/log/httpd/errors

    Qui consulte votre base de données ?

    La majorité des serveurs web (dont Apache) sont configurés par défaut de manière à conserver une trace des accès aux pages web et scripts associés. Par exemple, pour Apache sous Linux Mandrake, le fichier contenant les accès est situé à /var/log/httpd/access. Il existe des outils très utiles permettant de générer de véritables rapports à partir de ces logs : en particulier le programme webalizer, disponible à l'adresse suivante qui permet d'obtenir un rapport complet sous la forme de pages web avec divers graphiques et tableaux :

    Figure 12.6. webalizer

    Pour générer ce rapport à partir du fichier de logs /var/log/httpd/access, il suffit de taper :

    webalizer /var/log/httpd/access
    

    Attention : par défaut, webalizer fournit un rapport avec les noms ou adresses IP des machines s'étant connecté à votre site. Pour éviter cela, et présever l'anonymité de vos utilisateurs (par exemple des utilisateurs industriels), il faut introduire les 2 lignes suivantes dans le fichier webalizer.conf (un exemple de fichier est fourni sous le nom de sample.conf) :

      
    TopSites        0
    TopKSites       0
    

    Il est aussi possible de générer plusieurs rapports différents à partir d'un même fichier de logs. Dans ce cas là, ce fichier de logs, ainsi que le répertoire de sortie, et les options des rapports doivent être spécifiés dans plusieurs fichiers de configuration différents, par exemple webalizer-1.conf et webalizer-2.conf. Pour générer ces rapports, on tapera alors :

    webalizer -c webalizer-1.conf
    .
    .
    webalizer -c webalizer-2.conf
    

    Interfacer des outils externes : FASTA

    Le but de cette opération est de permettre a l'utilisateur de faire d'aligner via FASTA une séquence inconnue (qu'il précisera) contre toutes les séquences protéiques de la base de données. Bien que non utilisé ici, il existe un outil fort pratique pour l'adapatation en "services web" de programmes Unix : PISE, développé par Catherine Letondal, de l'Insitut Pasteur.

    L'opération nécessite bien sur d'installer FASTA sur le serveur, cette étape étant décrite plus haut. Contrairement à BLAST, l'utilisation de FASTA en version "standalone" ne nécessite pas la création de bases de donnnées sous un format particulier, un fichier de séquence au format FASTA suffit. Néanmoins, le contenu de la base évoluant, la base de séquence au format FASTA doit etre mise à jour soit à intervalles régulier (par exemple grace a un cronjob), soit a chaque nouvelle entrée d'une séquence dans la base. Nous opterons ici pour la première possibilité, par souci de simplicité.

    1ere étape : récuperation, via un script Perl, d'un fichier FASTA contenant toutes les séquences de la base Il s'agit d'un script très simple, qui charge le contenu de la table PROTEINES dans un fichier.

    2eme étape : création d'une base de données utilisable par BLAST

    3eme étape : définir un formulaire de saisie de séquence

    4eme étape : appel de BLAST et affichage des résultats

    Chapter 13. Sites et listes de diffusion

    Ressources:

    Site de l'IMPG (Informatique Mathématique Physique pour la Génomique)
    S'inscrire (ou se désinscrire) à la liste bioinfo@impg.prd.fr

    Formations:

    DESS Bioinformatique pour la génomique et la post-génomique, Université Blaise PASCAL - Clermont II
    DEA Mathématiques et Informatique Appliquées à la Biologie, Evry
    DESS de BioInformatique, Toulouse

    Cours sur le web :

    CPSC 536A - Bioinformatics Course, Spring 2001
    Computational Molecular Biology
    Bioinformatics