Rna (3 neurones et 2 entrées) avec rétropropagation

Télécharger le projet
Commenter

Description

C'est une application qui montre comment fonctionne les réseaux de neurones artificiels en utilisant la rétropropagation.
Cette source est en quelque sorte le stade au dessus de :
http://www.vbfrance.com/code.aspx?ID=17703

La rétropropagation est un principe (une formule mathématiques) qui permet un apprentissage extremement plus rapide en changeant les valeurs des poids en parcourant le réseau en sens inverse (c a d : de la droite vers la gauche).

Je suis désolés qu'il n'y ai pas assez de commentaire, mais je n'ai pas le temps de les mettre.(peut-être d'ici quelques jours !!)

Source / Exemple : 


'Voici le code de modRNA.bas :
Option Explicit

'Cette variable est la valeur de combien est changé le poids de chauques neurones :
Const µ As Double = 0.5

Public Poidss(1 To 3, 1 To 3) As Double

Public Function ChangeLesPoids()
    'Cette fonction change les valeurs des poids avec une valeur aléatoire :
    Dim i As Integer
    Dim j As Integer
    Randomize (1987)
    For i = 1 To 3
        For j = 1 To 3
            Poidss(i, j) = (Rnd * 2) - 1
        Next j
    Next i
End Function

Public Function Apprentissage(Entree1 As Double, Entree2 As Double, Cible As Double)
    'Cette fonction prend en argument 2 entrées et un résultat à atteindre (Cible)
    'et "entraine" le réseau de neurones artificiels

    'L'idée est de calculer la sortie du réseau à chaque fois, et en prenant en considération la "Cible",
    'on utilise la 'rétropropagation' pour corriger la différence.
    
    Dim Deltas(1 To 3) As Double
    Dim net1 As Double
    Dim net2 As Double
    Dim net3 As Double
    Dim i As Integer
    
'-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)
    
    'Neurone n°1 : (d'entrée)
    'Poidss(1,1) <=> poids du neurone n° 1 ou polarisation
    'Poidss(2,1) <=> Entree1
    'Poidss(3,1) <=> Entree2
    
    'Neurone n°2 : (d'entrée)
    'Poidss(1,2) <=> poids du neurone n° 2 ou polarisation
    'Poidss(2,2) <=> Entree1
    'Poidss(3,2) <=> Entree2
    
    'Neurone n°3 (de sortie) :
    'Poidss(1,3) <=> poids du neurone n° 3 ou X
    'Poidss(2,3) <=> Neurone n°1 (net1)
    'Poidss(3,3) <=> Neurone n°2 (net2)
    
    'Calcule la valeur de chaques neurones de la couche cachée :
    net1 = Activation(Poidss(1, 1) + Entree1 * Poidss(2, 1) + Entree2 * Poidss(3, 1))
    net2 = Activation(Poidss(1, 2) + Entree1 * Poidss(2, 2) + Entree2 * Poidss(3, 2))
    'Calcule la valeur du neurone de sortie :
    net3 = Activation(Poidss(1, 3) + net1 * Poidss(2, 3) + net2 * Poidss(3, 3))
    
'-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)-=)

    'Rétropropagation :
    '"Delta" est la valeur de l'erreur du neuronne de sortie par rapport à chaques neurones du réseau
    'Il faut calculer les "delta"s pour les deux couches !
    'C'est à dire qu'il faut calculer les erreurs en parcourant le réseau de
    'la droite vers la gauche en partant de neuronne de sortie pour arriver
    'au(x) neurone(s) caché(s).(C'est pourquoi nous partons du neurone n°3 (de sortie))
    
    'Calcul de 'Delta' :
    Deltas(3) = net3 * (1 - net3) * (Cible - net3)
    Deltas(2) = net2 * (1 - net2) * (Poidss(3, 3)) * (Deltas(3))
    Deltas(1) = net1 * (1 - net1) * (Poidss(2, 3)) * (Deltas(3))
    
    'Maintenant on change les poids en conséquence :
    For i = 1 To 2
        'On change donc les poids de chaques neurones cachés :
        Poidss(1, i) = Poidss(1, i) + µ * 1 * Deltas(i) 'Polarisation
        Poidss(2, i) = Poidss(2, i) + µ * Entree1 * Deltas(i)
        Poidss(3, i) = Poidss(3, i) + µ * Entree2 * Deltas(i)
    Next i
    
    'On change les poids du neurones de sortie :
    Poidss(1, 3) = Poidss(1, 3) + µ * 1 * Deltas(3) 'X
    Poidss(2, 3) = Poidss(2, 3) + µ * net1 * Deltas(3)
    Poidss(3, 3) = Poidss(3, 3) + µ * net2 * Deltas(3)
    
    'Permet de faire patienter sans bloquer completement le PC !
    DoEvents
End Function

Public Function Teste(Entree1 As Double, Entree2 As Double) As Double
    'Cette fonction calcule simplement la valeur de chaques neurones
    'et retourne la valeur du neurone de sortie :
    Dim net1 As Double
    Dim net2 As Double
    Dim net3 As Double
    
    net1 = Activation(Poidss(1, 1) + Entree1 * Poidss(2, 1) + Entree2 * Poidss(3, 1))
    net2 = Activation(Poidss(1, 2) + Entree1 * Poidss(2, 2) + Entree2 * Poidss(3, 2))
    net3 = Activation(Poidss(1, 3) + net1 * Poidss(2, 3) + net2 * Poidss(3, 3))
    
    'net3 est le neurone de sortie !
    Teste = net3
End Function

'Permet d'améliorer l'apprentissage :
Private Function Activation(Value As Double)
    Activation = (1 / (1 + Exp(Value * -1)))
End Function

Conclusion :


J'ai mis niveau 2 car il est assez difficile de comprendre le principe des réseaux de neurones artificiels !
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (ZogStriP)