1 Préambule.

L'implémentation du réseaux de neurones que je me propose de réaliser sera en partie grandement inspirée, du moins au début, de l'implémentation proposée par Brian Satterfield.

2 Organisation structurelle des réseaux de neurones.

L'architecture retenue pour l'implémantation de ce réseaux de neurones ce veut proche de la réalité biologique. Cependant, la complexité des réseaux de neurones biologiques est telle qu'il n'est pas possible de la modéliser facilement ; c'est pourquoi on à recourt à un model plus simple :

Le réseau est la structure externe.
Le réseau contient des couches de neurones : deux au moins(input output).
Chaque couche contient n neurones.
Chaque neuron est connecté a l'ensemble des neurones de la couche précédente, et de de façon pondérée : chaque connection interneuronale est quantifié par un poids.

Le schèma suivant devrait préciser plus clairement la stucture d'un tel réseau.

3 Implémentation

3.1 Choix du langage

En regard de la structure physique du réseau de neurones simplifié que l'on veut créer, le choix d'un langage orienté objet s'impose de lui même. Car en effet, il apparaît naturel de créer pour chaque élément/structure du réseau un objet regoupant les propriétés de cet élément et des méthodes associées.

Ensuite, pour un développement rapide, élégant et non complètement optimisé d'un point de vue de la gestion de la mémoire et de la vitesse d'exécution, un langage de haut niveau conviendrait parfaitement.

Enfin, un langage portable serait le bienvenu, afin de pouvoir utiliser et développer le réseau aussi bien sous Linux que sous Windows. Evidemment un tel langage doit être libre, et donc être dotée d'une licence GPL ou BSD.

Objectif Caml (Ocaml), le méta langage développé à l'INRIA, semble donc parfaitement adapté pour répondre à ces exigences. De plus, ce langage permet de programmer de façon élégante, de façon fonctionnel et assez proche des mathématiques. Qui plus est, c'est un langage français :-).

3.2 Représentation des données

Comme on l'a dit précedemment, chaque élément important du réseau (neurone, couche, réseau), sera implémenté sous la forme d'un objet, que l'on stockera dans un module indépendant.

3.2.1 Le neurone

Ci dessous ce trouve le code décrivant l'objet neuron.

class neuron =

object (self)

    val mutable neuron_type = Hidden

    val mutable weights = []

    val mutable bias_weight = 1

    val mutable activation = 0.0

    val mutable error = 0.0

    val mutable error_signal = 0.0

    val mutable theorical_output = 0.0



    method set_weights poids =

      weights <- poids;

    method set_theorical_output theorical_value =

      theorical_output <- theorical_value;

    method set_type n_type =

      neuron_type <- n_type;

    method activate previous_layer_outputs = (*compute the activation by * wheight and previous_oupts*)

      let rec compute x y = match (x,y) with

        ([], []) -> 0.0;

      | (t1::q1, t2::q2) -> (t1*. t2) +. compute q1 q2;

      | (_,_) -> raise Weight_Size_Error;

    in

    activation <- compute previous_layer_outputs weights;

    method get_output (transmittance : float -> float )= transmittance activation;

end;;

La classe reprend donc de façon simple les éléments de la théorie des réseaux de neurones. Seule la méthode d'activation mérite peut-être une brève explication.

Cette fonction calcule l'activation du neurone, c'est à dire qu'elle fait la somme pondérée de la valeur de sortie de chaque neurones de la couhe précédente.

Elle utilise la fonction auxiliaire récursive compute, qui à tous couples de listes de nombres réels ((O_n)_n,(W_n)_n) fait correspondre le produit O₀*W₀ qu'elle somme avec la valeur de retour de compute appliquée aux deux listes précédentes privées de leur premier élément. Losrque les listes sont vides, compute retourne 0.

Cette fonction est un exemple de possibilité de récursion de Ocaml, qui permettent d'effectuer sans boucles des traitements itératifs.

La méthode get_output mérire en fait elle aussi l'attention, car elle prend en paramêtre une fonction, ce qui permet d'avoir pour chaque neurone, ou plus généralement pour chaque couche de neurones une fonction de seuil différente. Ce genre de tricks est assez courant dans les langages fonctionnels, mais aurait aussi pu être impléménté en C avec un pointeur sur une fonction.

This document was translated from L^AT_EX by H^EV^EA.