J'ai rédigé cet article suite a la demande de plusierus membres du forum. J'espere qu'il vous plaira :D . Bonne lecture.
La tortue.
LA BIOINFORMATIQUE
Qu'est-ce que la bioinformatique? La biologie est un domaine extrêmement vaste. Dans ce domaine, on est souvent amené à realiser de grosses séries de calculs. Par exemple, pour prévoir des formes de protéines, pour simuler tel ou tel phénomène, pour repérer tel ou tel motif dans une séquence d'ADN, ... . Toutes ces études sont réalisés à partir d'algos particuliers qui, étant donné la quantitée de données manipulées, ne peuvent pas être traités manuellement. D'où l'utilité d'une discipline intermédiaire qui marie à la fois la biologie et la programmaton: la bioinformatique. Un bioinformaticien est un chercheur (biologiste) qui dispose aussi d'une formation en informatique. En gros, un bioinformaticien est un biologiste qui est aussi un informatitien.
La bioinformatique ne se limite pas à simuler des protéines. Le travail du bioinformatitien consiste également en l'élaboration d'algos et de méthodes statistiques permettant de répondre au mieux à un problème biologique quelconque. Pour illuster ce propos, je vous propose une petite simulaton de neurones suivant le modèle d'Izhikevich. Plusieurs de ces neurones pourraient être reliés entre eux par des synapses pour créer un véritable petit réseau capable "d'aprentissage", tout en serapprochant le plus possible de son modèle biologique (vous le verrez, il n'y a que peu de choses en commum avec des neurones formels).
Remarque: je suis en train d'écrire un générateur de réseaux de neurones. Dès que celui-ci sera achevé, je le posterait sur Hackbbs. Vous pourez ainsi créer vos propres réseaux capabes d'apprentissage.
SIMULATION DE NEURONES
Un neurone est une celule particulière, capable, lorsque son potentiel membrannaire dépasse un certain seuil, d'envoyer une décharge électrique au neurone qui le suit. Cette décharge (PA) est transmise d'un neurone à l'autre par les synapses. (Voir wikipedia pour une définition correcte et complète d'un neurone).
Exemple de simulation d'un neurone simple:
Il existe de nombreux modèles de simulation de neurones, le premier et le plus connu d'entre eux est le modèle de Hodking Huxley. Cependant, les équations de HH font appels à beaucoup de variables, ce qui induit un calcul assez couteux. Le modèle que je vais vous présenter a l'avantage d'être basé sur des équations différentielles très simples. Ce qui permet un calcul d'une grande rapiditée, plus adapté à nos bon vieux PC.
Voici les équations en question:
dv/dt = 0.04 * (v^3) + 5.0 * v + 140 - u + I
du/dt = a * (b*v - u)
Pour la signification des differents paramètres, je vous renvoie à la publication suivante: [url]http://vesicle.nsi.edu/users/izhikevich/publications/spikes.pdf[/url]
On approximera les solutions par une méthode d'Euler (en fait ici, taylor d'ordre deux) (une fois de plus, c'est la simplicitée qui a primé ici):
f(x+h) ~= f(x) + h*(df/dx)(x)+h²*(d²f/dx²)(x)
Si vous voulez un Euler, commentez la seconde partie de l'équation et laissez ceci:
f(x+h) ~= f(x) + h*(df/dx)(x)
(Plus on met un pas faible (plus h tend vers 0), plus la précision est élevée.)
Sur ce, assez de blabla, voici la source (soyez indulgent, je l'ai codée dans le RER)
[code:1:05f926a4b2]#include <stdio.h>
#include <stdlib.h>
/**
*\brief Simulation d'un neurone selon le du modele Izhikevich
*
* Ce code permet de simuler un potentiel d'action.
* L'equation differentielle utilisee est issue du modele Izhikevich.
* L'approximation des resultats est realise a l'aide de la formule de Taylor.
* Ce programme est assez simple, il ne gere pas l'adapativite du pas.
* v est le potentiel en mV, u est un coefficient d'amortissement.
* \file IzhikevichModel2.c
* \version 1.0
*/
double Taylor2_v(double u, double v, double pas, double stim, double A, double B);
double Taylor2_u(double u, double v, double pas, double stim, double A, double B);
void spike(double* v, double* u, double C, double D, double seuil);
void Izhikevitch_Taylor2(double t, double duree, double u, double v, double pas, double stim, double A, double B, double C, double D, double seuil, double temps);
/**
* Les valeurs typiques des constantes sont:
* Stim = 40
* A=0.02
* B=0.2
* u0=30.0
* v0=-50
* seuil = 30.0
* C=-65
* D=2.0
*/
int main(int argc, char* argv[])
{
double stim=0.0;
double pas=0.0;
double duree=0.0;
double t=0.0;
double u=30.0;
double v=-50.0;
double A=0.0;
double B=0.0;
double C=0.0;
double D=0.0;
double seuil=0.0;
double temps=0.0;
if(argc != 12)
{
printf("Mauvaise syntaxe.\n Syntaxe: Izikevitch [Intensitee de la stimulation en V] [taille du pas en ms] [duree de l'enregistrement en ms] [Valeur de A] [valeur de B] [Valeur de u0] [valeur de v0] [valeur de C] [valeur de D] [valeur en mV du seuil du spike] [temps en nombre des pas au bout duquel declencher la stimulation en ms]\n");
exit(42);
}
stim=atof(argv[1]);
pas=atof(argv[2]);
duree=atof(argv[3]);
A=atof(argv[4]);
B=atof(argv[5]);
u=atof(argv[6]);
v=atof(argv[7]);
C=atof(argv[8]);
D=atof(argv[9]);
seuil=atof(argv[10]);
temps=atof(argv[11]);
u=0.2*v;
Izhikevitch_Taylor2(t, duree, u, v, pas, stim, A, B, C, D, seuil, temps);
return 1;
}
/**
* Fonction qui utilise la formule de Taylor au deuxieme ordre pour calculer v au temps + pas.
*/
double Taylor2_v(double u, double v, double pas, double stim, double A, double B)
{
return v+pas*(0.04*v*v+5.0*v+140.0-u+stim)+pas*pas*0.5*((0.08*v+5.0)*(0.04*v*v+5.0*v+140.0-u+stim)-A*(B*v-u));
}
/**
* Fonction qui utilise la formule de Taylor au deuxieme ordre pour calculer u au temps + pas.
*/
double Taylor2_u(double u, double v, double pas, double stim, double A, double B)
{
return u+pas*A*(B*v-u)+pas*pas*0.5*(A*B*(0.04*v*v+5.0*v+140.0-u+stim)-A*A*(B*v-u));
}
/**
* Fonction qui reinitialise les variables lorsque v depasse 30 mV (Spike).
*/
void spike(double* v, double* u, double C, double D, double seuil)
{
if(*v>=seuil)
{
*v=C;
*u=*u+D;
}
}
/**
* Fonction qui lance les calculs pour chaque pas.
*/
void Izhikevitch_Taylor2(double t, double duree, double u, double v, double pas, double stim, double A, double B, double C, double D, double seuil, double temps)
{
double v2=0.0;
double u2=0.0;
double tmp=stim;
stim=0.0;
while(t < duree)
{
if(t>temps)
{
stim=tmp;
}
v2=Taylor2_v(u,v,pas,stim,A,B);
u2=Taylor2_u(u,v,pas,stim,A,B);
v=v2;
u=u2;
printf("%f\t%f\t%f\n",t,u,v);
t+=pas;
spike(&v,&u,C,D,seuil);
}
}
[/code:1:05f926a4b2]
Voici un exemple (tracé avec Gnuplot) d'une simulation:
$> Prog_compile.binary 5 0.01 1000 0.02 0.2 0 -65 -65 8 35 0 > sortie.txt
$> gnuplot
>> plot "sortie.txt" using 2 as lines
Voici la variation du coefficient d'amortissement u:
[img:05f926a4b2]http://img341.imageshack.us/img341/5457/snapshot4qn8.png[/img:05f926a4b2]
[i:05f926a4b2]Figure 1: Variation de u en fonction du temps[/i:05f926a4b2]
Et voici nos précieux spikes (valeur du potentiel v):
[img:05f926a4b2]http://img148.imageshack.us/img148/4923/snapshot5ly1.png[/img:05f926a4b2]
[i:05f926a4b2]Figure 2: Variation de v en fonction du temps[/i:05f926a4b2]
on y voit clairement la décharge électrique (appelé spike) lorsque le potentiel dépasse -60 mV, puis la repolarisation (l'hyperpolarisation n'est pas visible ici) et son retour à sa valeur de repos.
SIMULATION DE DEUX NEURONES CONNECTES PAR UNE SYNAPSE.
Nous allons a présent créer un tout petit "réseau" de deux neurones, ceux-ci seront reliés entre eux par une synapse très simple. En fait, c'est la modification des paramètres du modèle de synapse qui permet au réseau d'apprendre. En gros, si une synapse est empruntée et que l'opération du réseau est un succès, il y aura plus de chance que cette synapse soit reprise au parcours suivant. Bref, ne nous emballons pas. Simulons déjà deux jolis neurones reliés entre eux. Cette partie est un peu plus compliquée que la précédente, notemment au niveau de l'algo du code (Mais ne vous inquiétez pas, avec une feuille et un crayon a coté, ça va tout seul).
Pour le descriptif du modèle de synapse utilisé, je vous renvoie au papier suivant: [Je met la référence dès que je la retrouve]
Remarque: vous verrez que j'ai bidouillé et simplifié le modèle de synapse pour que celui-ci soit plus compréhensible. Alors, ami lecteur, si vous décidez de prendre ce code pour de vrais travaux de biologie, CORRIGEZ LE AVANT !
Une synapse est une sorte de "connecteur" entre deux neurones. Celle-ci permet, via des processus chimiques (ou direcetment électriques) de faire passer l'impultion électerique d'un neurone à son successeur. Le principe est qu'une synapse ne transmet pas fidelement le spike, mais ne produit qu'une faible variation dans le potentiel membranaire du neurone cible. Or, rappelez-vous qu'il faut qu'une limite soit atteinte pour qu'il y ait déclenchement d'un potentiel d'action. Donc, il faut que de nombreuses synapses soient activées plus ou moins au meme moment pour qu'un spike apparaisse. De plus, il existe deux types de synapses, les synapses inhibitrices (qui font diminuer le potentiel) et les synapses exitatrices (qui l'augmente). Donc, ces synapses sont capables d'annuller leur effets mutuellement. Pour conclure, un neurone est un dispositif qui somme les variations qu'il reçoit au niveau de ses synapses.
Vous n'avez pas compris? C'est normal. Pour faire simple, un neurone est un interrupteur qui s'active lorsqu'il reçoit un courant suffisant des interrupteurs qui l'entourent. Les "connections" enter ces interrupteurs sont appelées synapses.
Les sources étant un peu volumineuses, vous les trouverez ici:
le fichier synaptic.h ==> [url]http://hackbbs.pastebin.com/f77c1ba0b[/url]
le fichier synaptic.c ==> [url]http://hackbbs.pastebin.com/f407e2d23[/url]
le fichier IzhikevichModelNetwork.c ==> [url]http://hackbbs.pastebin.com/f3f9b7953[/url]
Remarque: Pour ceux qui ne maitrisent pas la compilation séparée:
$> gcc -c synaptic.c
$> gcc -c IzhikevichModelNetwork.c
$> gcc -Wall -lm *.o -o out.binary
Voici ce que l'on obtient avec une simulation ayant pour paramètres 1 -75 5 10 100 -70 0.01 20 -60 -70 5 30. Que les biologistes éventuels ne s'alarment pas, j'ai volontairement mis des paramètres très élevés, même si ils n'ont plus rien de biologique. Eh oui, rappelez vous, on a ici une seule synapse entre nos deux neurones, alors que dans la nature, on en a plusieurs dizaines de milliers. Il fallait donc que j'exagère les paramètres pour que l'on voit quelquechose sur la simulation.
[img:05f926a4b2]http://img514.imageshack.us/img514/7830/snapshot6bc9.png[/img:05f926a4b2]
[i:05f926a4b2]Figure 3:Simulation de deux neurones reliés par une synapse.[/i:05f926a4b2]
Voici comment sont reliés nos neurones:
[Neurone rouge]------------>[Neurone Vert]
On voit bien sur cette figure qu'une décharge du neurone rouge est suivie par celle du neurone vert. On a bien transmis nos décharges d'un neurone à l'autre.