Please enable JavaScript.

Coggle requires JavaScript to display documents.

Rewriting Logic using Strategies for Neural Networks: an Implementation…

- - - - Le constante "idle"
        
        Réussissent toujours
      - Le constante "fail"
        
        Echouent toujours
    - - Appliquer une règle à un terme donné, avec la possibilité de spécifier une substitution pour les variables de la règle.
    - - Parmi ces combinateurs, on trouve la concaténation (;), l'union (|), l'itération (* pour 0 ou plusieurs itérations, + pour 1 ou plusieurs itérations, et ! pour une itération "répéter jusqu'à la fin"). Il existe également un combinateur "si-alors-sinon" généralisé où le premier argument est également une stratégie. Le langage propose également un combinateur "matchrew" qui divise un terme en sous-termes et spécifie comment ces sous-termes doivent être réécrits. La récursion est possible en donnant un nom à une expression de stratégie et en utilisant ce nom dans l'expression de stratégie elle-même ou dans d'autres stratégies associées.
    - - Les stratégies sont exprimées en combinant l'application de règles spécifiques, éventuellement instanciées, avec la concaténation et l'itération "répéter jusqu'à la fin". Un combinateur étendu appelé "one(S)" a été introduit pour des raisons d'efficacité. Lorsqu'il est utilisé sur un terme, ce combinateur renvoie l'une des solutions possibles obtenues en appliquant la stratégie S au terme. Ainsi, une approche simplifiée et optimisée est adoptée pour contrôler le processus de réécriture.
- - - - Chaque nœud dans le réseau est associé à une sortie, et les connexions entre les nœuds ont des poids qui déterminent leur influence. Chaque nœud a également un seuil d'activation, et une fonction de transfert est utilisée pour calculer l'activation du nœud en fonction de ses entrées.
- - - - Par conséquent, nous avons décidé d'utiliser des matrices et des vecteurs de valeurs pour spécifier les seuils et les poids, Et de définir des équations et des règles pour les transformer en représentation orientée objet.
      - Le cœur de notre représentation des perceptrons en Maude tourne autour de la définition de deux classes pour représenter les neurones et les synapses en tant qu'objets individuels :
        
        class Neuron | x : Float, t : Float, st : Nat .
        
        Chaque objet de neurone transporte sa valeur d'activation actuelle x, en fonction de son seuil t, et un attribut st qui sera utilisé pour déterminer si le neurone a déjà été activé ou non
        
        Exemple
        
        Supposons que nous ayons un neurone avec une valeur de seuil t = 0.5. La fonction d'activation utilisée est la fonction sigmoïde, qui renvoie des valeurs dans la plage [0, 1].
        
        Au départ, la valeur d'activation x du neurone est initialement définie à 0.
        
        Un stimulus est envoyé au neurone, et son activation est calculée en utilisant la fonction d'activation sigmoïde.
        
        Si la valeur d'activation obtenue est supérieure au seuil t (0.5 dans notre cas), alors le neurone est considéré comme activé et l'attribut st est mis à une valeur indiquant qu'il a été activé.
        
        Sinon, si la valeur d'activation est inférieure ou égale au seuil t, le neurone n'est pas activé et l'attribut st indique qu'il est toujours en attente d'entrée.
        
        Par la suite, d'autres stimuli peuvent être envoyés au neurone et son activation mise à jour en fonction du nouveau stimulus et du seuil.
        
        Par exemple, si un stimulus donné entraîne une activation de 0.8, qui est supérieure au seuil de 0.5, alors le neurone est considéré comme activé et l'attribut st est mis à une valeur indiquant qu'il a été activé.
        
        class Link | w : Float, st : Nat .
        
        les objets de lien stockent leur poids numérique et contiennent un attribut st pour indiquer si une valeur a déjà transité à travers eux ou non
        
        Les neurones et les liens sont identifiés par un nom. Nous définissons deux opérations qui prennent des nombres naturels en tant qu'arguments et renvoient un identifiant d'objet : pour les neurones, les nombres correspondent à la couche et à la position au sein de la couche ; pour les liens, les nombres correspondent à la couche de sortie et aux positions respectives au sein de chaque couche des neurones connectés.
        
        op neuron : Nat Nat -> Oid .
        
        Pour créer un objet de neurone dans la deuxième couche à la position 3, nous utilisons l'opération neuron(2, 3), qui renverra un identifiant d'objet unique pour ce neurone.
        
        Exemple :op neuron : Nat Nat -> Oid .
        eq neuron(2, 3) = NeuronObj123 .
        
        Dans cet exemple, NeuronObj123 est l'identifiant d'objet unique pour le neurone dans la deuxième couche à la position 3.
        
        op link : Nat Nat Nat -> Oid .
        
        Pour créer un objet de lien qui connecte un neurone dans la première couche à un neurone dans la deuxième couche, à la position 2 dans la première couche et à la position 1 dans la deuxième couche, nous utilisons l'opération link(1, 2, 1), qui renverra un identifiant d'objet unique pour ce lien.
        
        Exemple: op link : Nat Nat Nat -> Oid .
        eq link(1, 2, 1) = LinkObj121 .
        
        Dans cet exemple, LinkObj121 est l'identifiant d'objet unique pour le lien entre le neurone dans la première couche à la position 2 et le neurone dans la deuxième couche à la position 1.
        
        1 more item...
        
        Les règles fournies décrivent l'évaluation du réseau. Les règles "feedForward" et "sigmoid" sont appliquées de manière répétée pour effectuer l'évaluation. Voici une explication de ce que font ces règles :
        
        Règle "feedForward" :
        
        Cette règle calcule la somme pondérée des entrées d'un neurone et met à jour la valeur d'activation (x) et l'état de déclenchement (st) des neurones et des liens impliqués.
        
        Le motif de règle "<neuron(L, I) : Neuron | x:X1, st:1>" correspond à un neurone "neuron(L, I)" avec une valeur d'activation X1 et un état de déclenchement 1.
        
        Le motif de règle "<link(s L, I, J) : Link | w:W, st:0>" correspond à un lien "link(s L, I, J)" avec un poids W et un état de déclenchement 0.
        
        Le motif de règle "<neuron(s L, J) : Neuron | x:X2, st:0>" correspond à un neurone "neuron(s L, J)" avec une valeur d'activation X2 et un état de déclenchement 0.
        
        Lorsque ces motifs sont correspondants, la règle met à jour la valeur d'activation et l'état de déclenchement des neurones et du lien impliqués dans le calcul.
        
        La configuration résultante après l'application de la règle est "<neuron(L, I) : Neuron | x:X1, st:1> <link(s L, I, J) : Link | w:W, st:1> <neuron(s L, J) : Neuron | x:(X2 + (X1 * W)), st:0>".
        
        Règle "sigmoid" :
        
        Cette règle applique la fonction sigmoïde ("sig") à l'entrée nette d'un neurone et met à jour sa valeur d'activation et son état de déclenchement.
        
        Le motif de règle "<neuron(L, I) : Neuron | x:X, t:T, st:0>" correspond à un neurone "neuron(L, I)" avec une valeur d'activation X, un seuil T et un état de déclenchement 0.
        
        Lorsque ce motif est correspondant, la règle applique la fonction sigmoïde à l'entrée nette et met à jour la valeur d'activation et l'état de déclenchement du neurone.
        
        La configuration résultante après l'application de la règle est "<neuron(L, I) : Neuron | x:syg(-(X, T), L), st:1>".
        
        L'évaluation d'un perceptron commence par l'obtention d'un motif d'entrée grâce à la règle "nextPattern", qui est guidée par le message "netStatus". Un message de la forme "netStatus(N0, 0, 0, N1)" signifie que le N0-ème motif doit être considéré, suivi des motifs suivants jusqu'au N1-ème.
        
        La règle "nextPattern"
        
        Lorsque le motif de message "netStatus(N, N1, N2, N0)" est correspondant, la règle incrémente le numéro du motif en cours (s N) et applique les règles d'insertion des motifs d'entrée et de sortie correspondants.
        
        La règle met également à jour les indices pour indiquer les prochains motifs à considérer.
        
        Si N est inférieur à N0, la règle est appliquée.
        
        Avant de commencer le processus de feedforward, les valeurs des neurones dans la couche d'entrée et les poids correspondants sont réinitialisés. Ensuite, la règle "introducePattern" insère le motif d'entrée dans les neurones de la couche d'entrée et les supprime de la configuration.
        
        La règle "introducePattern" :
        
        Lorsque le motif "<neuron(0, I) : Neuron | x:X, st:0>" correspond à un neurone de la couche d'entrée avec une valeur d'activation X et un état de déclenchement 0, et que le motif "inputPattern(N, I, X0)" correspond à un motif d'entrée avec un numéro de motif N, un indice I et une valeur X0, la règle met à jour la valeur d'activation du neurone avec X0 et l'état de déclenchement à 1.
        
        Une fois que nous avons terminé l'évaluation de tous les motifs, nous calculons l'erreur et marquons l'objet net(N) courant comme étant terminé.
        
        La règle "computeError" :
        
        Lorsque le motif "<net(N0) : Net | e:E, st:0>" correspond à un objet net avec une erreur E et un état de déclenchement 0, et que le motif "<neuron(2, I) : Neuron | x:X0, st:1>" correspond à un neurone de la couche de sortie avec une valeur d'activation X0 et un état de déclenchement 1, et que le motif "outputPattern(N, I, X1, 0)" correspond à un motif de sortie avec un numéro de motif N, un indice I, une valeur X1 et un état de déclenchement 0, la règle met à jour l'erreur en fonction de la différence entre X1 et X0.
        L'état de déclenchement du neurone de la couche de sortie est également mis à jour.
  - - - Pour cela, nous devons ajouter des informations supplémentaires aux neurones et aux liens, à savoir les termes d'erreur δj et les poids ajustés ωkij (t+1).
    - - Les nouvelles classes sont définies comme suit :
        
        class LinkTR | w+1 : Float .
        subclass LinkTR < Link .
        
        class NeuronTR | dt : Float .
        subclass NeuronTR < Neuron .
    - - Pour la couche de sortie, la règle correspondante est assez simple
        
        rl [delta2] : outputPattern(N, I, D, 1)
        
        < neuron(2, I) : NeuronTR | x : X , dt : DT , st : 2 >
        
        => < neuron(2, I) : NeuronTR | x : X ,
        
        dt : (X ((-(1.0, X)) (-(D, X))) ) , st : 3 > .
    - - La règle delta1B :
        
        rl [delta1B] : < neuron(1, J) : Neuron | dt : DT1, st : 2 >
        
        < link(2, J, K):Link | w:W, st:2 > < neuron(2, K):Neuron | dt:DT2, st:2 >
        
        => < neuron(1, J) : Neuron | dt : (DT1 + (DT2 * W)), st : 2 >
        
        < link(2, J, K):Link | w:W, st:3 > < neuron(2, K):Neuron | dt:DT2, st:2 > .
      - La règle link1 :
        
        rl [link1] : < neuron(0, I) : Neuron | x : X1, st : 1 >
        
        < link(1, I, J) : Link | w : W, w+1 : W1, st : 1 >
        
        < neuron(1, J) : Neuron | dt : DT, st : 3 >
        
        => < neuron(0, I) : Neuron | x : X1, st : 1 >
        
        < link(1, I, J) : Link | w : W, w+1 : (W + (eta (DT X1))), st : 3 >
        
        < neuron(1, J) : Neuron | dt : DT, st : 3 > .
  - - - Pour contrôler l'ordre d'application des règles dans la spécification et simuler l'évaluation des motifs, nous utilisons des stratégies.
        
        La stratégie principale "feedForwardStrat"
        
        prend un nombre naturel en argument et l'applique à une configuration (c'est-à-dire un perceptron). Elle choisit une couche L' et applique la règle "feedForward" de manière aléatoire et aussi longtemps qu'elle est activée, afin de calculer la somme pondérée des valeurs associées à chaque neurone de la couche. Une fois que toutes les sommes ont été calculées, elle applique la fonction sigmoïde à chacune d'entre elles en utilisant la règle "sygmoid", encore une fois de manière aléatoire et aussi longtemps qu'elle est activée.
        
        strat feedForwardStrat : Nat @ Configuration .
        sd feedForwardStrat(L’) := one(feedForward[L<-L’])!; one(sygmoid[L<-s L’])!.
        
        Il existe également deux stratégies auxiliaires
        
        La stratégie "inputPatternStrat"
        
        s'occupe de rendre les motifs successifs disponibles et de réinitialiser les attributs appropriés des neurones et des liens.
        
        . La stratégie "computeOutput"
        
        est utilisée pour calculer l'erreur une fois qu'un motif a été évalué.
        
        La stratégie d'évaluation "evaluateANN"
        
        combine toutes les stratégies précédentes pour évaluer un motif. Elle insère le prochain motif, calcule les valeurs des neurones dans les couches cachées et de sortie, puis retourne l'erreur.
        
        Code
        
        strat evaluateANN : @ Configuration .
        
        sd evaluateANN := inputPatternStrat ; feedForwardStrat(0) ;
        
        feedForwardStrat(1) ; computeOutput .
        
        Pour forcer l'évaluation des M premiers motifs par le perceptron multicouche, vous pouvez exécuter la commande suivante :
        
        (srew ann netStatus(0, 0, 0, M) using one(evaluateANN) ! .)
        
        Dans cette commande, les motifs d'entrée appropriés doivent avoir été définis et "ann" doit être une expression de la forme :
        
        Code
        
        neuronGeneration(0, input0, threshold0, 0)
        
        neuronGeneration(1, input1, threshold1, 0)
        
        linkGeneration(1, link1, 0, 0)
        
        neuronGeneration(2, input2, threshold2, 0)
        
        linkGeneration(2, link2, 0, 0)
        
        De manière similaire à l'évaluation, nous devons définir une stratégie appropriée pour l'entraînement du perceptron. Une fois que la sortie associée à un motif a été calculée, nous devons ensuite calculer les termes d'erreur, les utiliser pour obtenir les poids ajustés, et les transférer à l'attribut approprié. Cela peut être facilement réalisé en appliquant les règles définies dans la section précédente dans le bon ordre.
        
        Code
        
        strat backpropagateANN : @ Configuration .
        
        sd backpropagateANN := one(delta2) ! ; one(link2) ! ;
        
        one(delta1A) ! ; one(delta1B) ! ; one(delta1C) ! ; one(link1) ! ;
        
        one(switchLink) ! .
        
        Enfin, l'entraînement d'un réseau consiste à évaluer un motif avec la stratégie "evaluateANN", puis à ajuster les poids en conséquence avec la stratégie "backpropagateANN".
        
        strat stratANN : @ Configuration .
        sd stratANN := evaluateANN ; backpropagateANN .