l’apprentissage par réseau de neurones : partie 2...introduction À partir de l’application...

L’apprentissage par réseau de neurones : Partie 2

https://www.altexsoft.com/whitepapers/fraud-detection-how-machine-learning-systems-help-

reveal-scams-in-fintech-healthcare-and-ecommerce/

INTRODUCTION ............................................................................................................................................................. 2

L’ARCHITECHTURE ......................................................................................................................................................... 2

LA PROPAGATION DU GRADIENT DE LA FONCTION D’ERREUR ........................................................................................ 3

7.1 LA DÉRIVÉE DE LA FONCTION SIGMOÏDE ..................................................................................................................................... 4 7.2 LA DÉRIVÉE PARTIELLE DE LA FONCTION D’ACTIVATION SIGMOÏDE ................................................................................................... 4 7.3 LA DÉRIVÉE DE LA FONCTION TANGENTE HYPERBOLIQUE ............................................................................................................... 5 7.4 LA DÉRIVÉE PARTIELLE DE LA FONCTION D’ACTIVATION TANGENTE HYPERBOLIQUE .............................................................................. 5 7.5 LES DÉRIVÉES PARTIELLES DE LA FONCTION D’AGRÉGATION Z ......................................................................................................... 6 7.6 LA DÉRIVÉE DE L’ERREUR QUADRATIQUE .................................................................................................................................... 7 7.5 LA DÉRIVÉE PARTIELLE DE LA FONCTION D’ERREUR QUADRATIQUE ................................................................................................... 7

LA PROPAGATION DE L’ERREUR ..................................................................................................................................... 8

8.1 LA PROPAGATION DE L’ERREUR DE LA FONCTION D’ERREUR C ........................................................................................................ 9 8.2 LA PROPAGATION DE L’ERREUR DE LA FONCTION D’ACTIVATION A ................................................................................................... 9 8.3 LA PROPAGATION DE L’ERREUR DE LA FONCTION D’AGRÉGATION Z ................................................................................................ 10 8.4 LA PROPAGATION ABSTRAITE DES ERREURS SUR PLUSIEURS NEURONES ........................................................................................... 10 8.5 LA PROPAGATION DE L’ERREUR D’UNE COUCHE DE NEURONES ..................................................................................................... 11 8.6 LA PROPAGATION DE L’ERREUR D’UN RÉSEAU ........................................................................................................................... 11

LE GRADIENT DE LA FONCTION D’ERREUR .................................................................................................................... 12

9.1 LA DÉRIVÉE PARTIELLE DE LA FONCTION D’ERREUR C PAR RAPPORT AU BIAIS B ................................................................................. 13 9.2 LA DÉRIVÉE PARTIELLE DE LA FONCTION D’ERREUR C PAR RAPPORT AU POIDS W ............................................................................... 13 9.3 LE GRADIENT DE C POUR DES PARAMÈTRES D’UNE COUCHE ......................................................................................................... 14

L’APPRENTISSAGE DU RÉSEAU ..................................................................................................................................... 14

10.1 L’APPRENTISSAGE ............................................................................................................................................................. 15 10.2 L’APPRENTISSAGE DES BIAIS ................................................................................................................................................ 16 10.3 L’APPRENTISSAGE DES POIDS ............................................................................................................................................... 16

L’ENTRAINEMENT D’UN RÉSEAU .................................................................................................................................. 17

11.1 LE PROTOCOLE D’ENTRAÎNEMENT ......................................................................................................................................... 18 11.2 L’APPRENTISSAGE DE LA TABLE DE VÉRITÉ ET (AND) ................................................................................................................. 18 11.3 L’APPRENTISSAGE DE BREAST CANCER WISCONSIN (DIAGNOSTIC) DATA SET ................................................................................ 19 11.4 L’APPRENTISSAGE DE MNIST DATA SET ............................................................................................................................... 20

CONCLUSION ............................................................................................................................................................... 21

REMISE DU PROGRAMME ............................................................................................................................................ 21

L’apprentissage par réseau de neurones sur 21 Simon Vézina, Collège de Maisonneuve Version 1.2.0

https://www.altexsoft.com/whitepapers/fraud-detection-how-machine-learning-systems-help-reveal-scams-in-fintech-healthcare-and-ecommerce/

https://www.altexsoft.com/whitepapers/fraud-detection-how-machine-learning-systems-help-reveal-scams-in-fintech-healthcare-and-ecommerce/

Introduction À partir de l’application SIMLearning que vous développé dans la 1re partie du laboratoire L’apprentissage par réseau de neurones, vous allez ajouter des nouvelles fonctionnalité permettant à un réseau de neurone d’apprendre par l’implémentation de la descente du gradient.

Durant le laboratoire, vous devrez répondre à des questions conceptuelles. Vous pouvez télécharger le cahier de réponse avec lien suivant :

http://physique.cmaisonneuve.qc.ca/svezina/projet/apprentissage_reseau/download/Cahier-ApprentissageReseau-Partie2.docx

L’architechture L’architechture retenue dans ce programme pour concevoir un réseau de neurone permet de réaliser en séquence, couche par couche, l’ensemble des calculs requis lors de l’activation du réseau et la propagation du gradient.

Dans un réseau de type full connected, on y retrouve une fonction d’agrégation ( )kz suivit d’une fonction d’activation ( )ka permettant de connecter l’ensemble des neurones d’une couche k avec une couche 1+k pour l’ensemble des couches. En appliquant les fonctions en séquence vers l’avant sur les données, nous pouvons réaliser l’activation de la fonction suivante :

http://numahub.com/articles/why-do-you-need-fully-connected-layer

Activation : En séquence de couche ( ) ( ) ( ) ( ) ( ) ( ) ( )LLkk aCoucheCoucheCoucheCoucheCouchea →→→→→→→→ + ...... 110*

Activation : En séquence de fonctions agrégation-activation ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )LLkkkk azazazazaza →→→→→→→→→→→→ ++ ...... 111100*

Cette séquence en cascade peut évalement se faire dans le sens inverse des fonctions. Cependant, on utilisera l’expression de la dérivée de la fonction au lieu de son expression traditionnelle. Cette séquence en ordre inverse permettra de propager une erreur dans le réseau. Cette propagation d’erreur portera le nom de la propagation du gradient. On utilisera cette propagation pour réaliser des apprentissages dans le réseau.

Dans un réseau de type ful connected, nous avons la cascade de fonctions suivantes lors de la propagation de l’erreur :

Propagation du gradient : En séquence de couche ( ) ( ) ( ) ( ) ( ) ( )0011 ...... ∆→→→→→→→→ + couchecouchecouchecouchecoucheC kkL

Propagation du gradient : En séquence de fonction agrégation-activation ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )001111 ...... zazakzkakzkaLzLaLCC ∆→∆→∆→∆→→∆→∆→∆→∆→→∆→∆→∆→ ++

Dans ce calcul, on y retouve un nouvelle fonction C représentant l’erreur entre l’activation ( )La du réseau avec une valeur attendue y . Selon le type de fonction d’erreur choisie, un calcul déterminera l’erreur ( )kC∆ propagée par C . Par la suite, cette erreur sera propagée en cascade dans l’ensemble du réseau en ordre inverse un peu comme l’a été la donnée d’entrée lors de l’activation.






La propagation du gradient de la fonction d’erreur La propagation du gradient de la fonction d’erreur ( )( )yaCC L ,=permet d’obtenir les dérivées partielles

( )kuvwC ∂∂ / et ( )k

ubC ∂∂ /

par rapport à tous les paramètres du réseau pouvant influencer celle-ci comme les poids ( )k

uvw et biais ( )kub nécessaire au calcul de

l’activation ( )La . Par la suite, cette propagation permettra de définir un gradient C∇ qui sera utilisé pour modifier adéquatement les poids et biais du réseau dans le processus d’apprentissage. En appliquant à répétition ce processus d’apprentissage sur plusieurs vecteurs d’entrée ( )*a où une valeur attendue y est associée, on permet au réseau d’apprendre. Cette méthode porte le nom de descente du gradient.

Pour obtenir les équations permettant de calculer nos dérivées partielles, nous pouvons appliquer la différentielle à la fonction

d’erreur ( )( )yaCC L ,= ce qui donne l’expression

( )( ) ( )( )

( )

∑−

= ∂∂

==1

0d,dd

LN

i

LiL

i

L aaCyaCC

https://www.safaribooksonline.com/library/vie

w/statistics-for-machine/9781788295758/f7c6dca2-593c-449d-

8901-b9a98e5fd1c4.xhtml

Illustration de la fonction d’erreur (Error Surface) et de la direction qu’il faut emprunter

pour modifier les poids (w1 et w2) afin de localiser le minimum pour ainsi minimiser

l’erreur et améliorer la prédiction du réseau.

où y est une constante. Pour développer davantage cette expression, nous avons besoin des fonctions mathématiques tel que

l’agrégation ( ) ( ) ( ) ( ) ( )( )ku

kuv

kv

ku

ku bwazz ,,1−= et l’activation ( ) ( ) ( )( )k

uk

uk

u zaa =

où ( )[ ]1...0 −∈ kNu l’indice de sortie (ligne) et ( )[ ]1...0 1 −∈ −kNv l’indice d’entrée (colonne)

pour une couche k du réseau tel que [ ]Lk ...0∈ ayant 1+L couches.

En appliquant la différentielle1 de la fonction d’erreur C , nous obtenons les gradients de niveaux 2=n :

( )

( )

( )

( )

( )

( )( )

( )

( )( )

( )

( )

( )

( )

( )

( )

( )

( )( )

( )

( )( )

( )

( )

( )( )

( )

∂∂

+

∂∂

+∂∂

∂∂

∂∂

+

∂∂

+∂∂

∂∂

∂∂

=

∑

∑∑

∑

∑−

=

−−

−

−

=

−−

−−

−

−

−

=−

−

−

−

=

−

=

−

−

−

−

1

0

22

1

1

0

11

11

1

1

1

01

1

1

1

0

1

0

2

1

1

1

d

dd

dd

d

L

L

L

L

L

N

k

LkL

k

Lj

N

k

LjL

j

LjL

jkLjk

Lj

N

jL

j

Lj

Lj

Li

N

j

LiL

i

LiL

jiLji

Li

N

iL

i

Li

Li

aaz

bbz

wwz

za

az

bbzw

wz

za

aCC

(Équation de la différentielle de la fonction d’erreur jusqu’à la couche de profoncteur 2=n )

1 Une démonstration de cette équation est disponible au lien suivant :

http://physique.cmaisonneuve.qc.ca/svezina/mat/note_mat/MAT_Chap%206.2.pdf


https://www.safaribooksonline.com/library/view/statistics-for-machine/9781788295758/f7c6dca2-593c-449d-8901-b9a98e5fd1c4.xhtml




http://physique.cmaisonneuve.qc.ca/svezina/mat/note_mat/MAT_Chap%206.2.pdf

Nous remarquons ici la présence de plusieurs dérivées partielles appliquées sur l’ensemble de nos fonctions et par rapport à plusieurs paramètres différents. Avant de décortiquer cette grosse équation en plusieurs étapes séquentielles correspondant à la propagation du gradient, nous devrons munir l’ensemble de nos fonctions de l’opérateur dérivée partielle.

7.1 La dérivée de la fonction sigmoïde Fichier à modifier : SNeuralMath.java

Prérequis : auncun

Dans la classe SNeuralMath disponible dans le package sim.nn.function, vous allez programmer la méthode suivante :

public static double derivateSigmoid(double x) L’objectif de cette méthode sera de calculer la dérivée de la fonction sigmoïde :

( ) ( ) ( )σσσσ −== 1d

d'xxx

Présentement, cette méthode retourne une exception de type SNoImplementationException spécifiant que la méthode n’a pas été implémentée. Complétez l’implémentation et retournez le résultat de la dérivée de la fonction sigmoïde.

Pour vérifier vos deux implémentations, exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SNeuralMathTest du package sim.nn.function située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

7.2 La dérivée partielle de la fonction d’activation sigmoïde Fichier à modifier : SSigmoidFunction.java

Prérequis : 7.1

Dans la classe SSigmoidFunction disponible dans le package sim.nn.function.activation, vous allez programmer la méthode suivante :

public double dAdZ(int u)

Le but de cette méthode est de définir la dérivée partielle de la fonction d’activation ( )kua d’un neurone u par

rapport à l’agrégation ( )kuz pour la fonction sigmoïde tel que

( )

( )ku

ku

za∂∂

.

Pour ce faire, vous devrez utiliser la méthode statique

public static double derivateSigmoid(double x)

que vous utiliserez avec le paramètre foward_input en indice u (correspondant à ( )kuz pour cette classe).

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SSigmoidFunctionTest du package sim.nn.function.activation située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.


7.3 La dérivée de la fonction tangente hyperbolique Fichier à modifier : SNeuralMath.java

Prérequis : auncun


public static double derivateTanh(double x) L’objectif de cette méthode sera de calculer la dérivée de la fonction tangent hyperbolique :

( ) ( ) ( )xx

xx 2tanh1d

tanhd'tanh −==

Présentement, cette méthode retourne une exception de type SNoImplementationException spécifiant que la méthode n’a pas été implémentée. Complétez l’implémentation et retournez le résultat de la dérivée de la fonction tangente hyperbolique.

Pour vérifier vos deux implémentations, exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SNeuralMathTest du package sim.nn.function située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

7.4 La dérivée partielle de la fonction d’activation tangente hyperbolique Fichier à modifier : STanhFunction.java

Prérequis : 7.3

Dans la classe STanhFunction disponible dans le package sim.nn.function.activation, vous allez programmer la méthode suivante :

public double dAdZ(int u)

Le but de cette méthode est de définir la dérivée partielle de la fonction d’activation ( )kua d’un neurone u par

rapport à l’agrégation ( )kuz pour la fonction tangente hyperbolique tel que

( )

( )ku

ku

za∂∂

.

Pour ce faire, vous devrez utiliser la méthode statique

public static double derivateTanh(double x)

que vous utiliserez avec le paramètre foward_input en indice u (correspondant à ( )kuz pour cette classe).

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe STanhFunctionTest du package sim.nn.function.activation située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.


7.5 Les dérivées partielles de la fonction d’agrégation Z Fichier à modifier : SAggregationFunction.java

Prérequis : aucun

Dans la classe SAggregationFunction disponible dans le package sim.nn.function.aggregation, vous allez programmer les méthodes suivantes :

public double dZdW(int u, int v) public double dZdA(int u, int v)

public double dZdB(int u) L’objectif de ces méthodes seront d’évaluer les dérivées partielles de l’agrégation

( ) ( ) ( )( )

( )ku

N

v

kv

kuv

ku bawz

k

+= ∑−

=

−− 1

0

11

par rapport à différents paramètres : ( )

( )( )1−=

∂∂ k

vkuv

ku a

wz

(Dérivée partielle par rapport à l’entrée ( )1−kva )

( )

( )( )kuvk

v

ku w

az

=∂∂

−1

(Dérivée partielle par rapport au poids ( )kuvw )

( )

( ) 1=∂∂

ku

ku

bz

(Dérivée partielle par rapport au biais ( )kub )

Dans cette classe, vous pouvez avoir accès à ( )1−kva , ( )k

uvw et ( )kub grâce aux paramètres suivants :

• Le paramètre this.foward_input correspond à ( )1−kva .

• Le paramètre this.W donne accès à ( )kuvw à l’aide de l’appel W.getMatrix( ).

• Le paramètre this.B donne accès à ( )kub à l’aide de l’appel B.getVector( ).

Présentement, ces méthode retourne une exception de type SNoImplementationException spécifiant que la méthode n’a pas été implémentée. Complétez l’implémentation de ces trois méthode et retournez les bonnes valeurs en utilisant judicieusement les indices u et v.

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SAggregationFunctionTest du package sim.nn.function.aggregation située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.


7.6 La dérivée de l’erreur quadratique Fichier à modifier : SNeuralMath

Prérequis : aucun


public static double derivateQuadraticError(double calculated, double expected) L’objectif de cette méthode sera d’évaluer la dérivée partielle de la fonction d’erreur quadratique par rapport à l’activation du réseau ( )L

ua :

( )( )

uL

uLu

yaaC

−=∂∂

où ( )( )221

uL

u yaC −=

Présentement, cette méthode retourne une exception de type SNoImplementationException spécifiant que la méthode n’a pas été implémentée. Complétez l’implémentation et retournez ( )L

uaC ∂∂ / à l’aide de ( )Lua

correspondant à calculated et uy correspondant à expected.

Pour vérifier votre implémentation, exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SNeuralMath du package sim.nn.function située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

7.5 La dérivée partielle de la fonction d’erreur quadratique Fichier à modifier : SEnergyErrorFunction.java

Prérequis : aucun

Dans la classe SEnergyErrorFunction disponible dans le package sim.nn.function.error, vous allez programmer les méthodes suivantes :

public double dCdA(int u)

Le but de cette méthode est de définir la la dérivée partielle de la fonction d’erreur uC d’un neurone u par

rapport à l’activation ( )Lua pour la fonction d’erreur quadratique tel que

( )Lu

u

aC

∂∂

.

Pour compléter votre implémentation, vous devrez utiliser la méthode statique

public static double derivateQuadraticError(double calculated, double expected) disponible dans la classe SNeuralMath que vous avez programmé précédemment. Appliquer la fonction derivateQuadraticError (…) sur l’entrée foward_input en indice u (correspondant à ( )L

ua : la valeur calculated) avec la

valeur attendue y en indice u (correspondant à uy : la valeur expected).

Pour vérifier vos implémentations, exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SEnergyErrorFunction du package sim.nn.function.error située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.


La propagation de l’erreur Lorsque nous avons présenté le calcul de la différentielle de la fonction d’erreur, nous avons obtenu l’équation de la propagation du gradient suivante :

( )

( )

( )

( )

( )

( )( )

( )

( )( )

( )

( )

( )

( )

( )

( )

( )

( )( )

( )

( )( )

( )

( )

( )( )

( )

∂∂

+

∂∂

+∂∂

∂∂

∂∂

+

∂∂

+∂∂

∂∂

∂∂

=

∑

∑∑

∑

∑−

=

−−

−

−

=

−−

−−

−

−

−

=−

−

−

−

=

−

=

−

−

−

−

1

0

22

1

1

0

11

11

1

1

1

01

1

1

1

0

1

0

2

1

1

1

d

dd

dd

d

L

L

L

L

L

N

k

LkL

k

Lj

N

k

LjL

j

LjL

jkLjk

Lj

N

jL

j

Lj

Lj

Li

N

j

LiL

i

LiL

jiLji

Li

N

iL

i

Li

Li

aaz

bbz

wwz

za

az

bbzw

wz

za

aCC

(Équation de la différentielle de la fonction d’erreur jusqu’à la couche de profoncteur 2=n )

Grâce aux étapes précédentes, vous avez intégré à l’ensemble de vos fonctions la possibilité d’évaluer leurs dérivées partielles par rapport à l’ensemble de leurs paramètres. Nous sommes maintenant rendu à l’étape de propager l’erreur depuis la fin du réseau vers le début du réseau.

Nous débuterons notre calcul par la propagation de l’erreur par la fonction d’erreur C afin d’évaluer

( )( )Lu

LCu a

C∂∂

=∆ .

Ensuite, nous propagerons l’erreur de la fonction d’erreur ( )LCu∆ ou toute autre forme d’erreur ( )1+∆ kz

u dans la

fonction d’activation ( )kua afin d’évaluer

( ) ( )( )

( )Lu

LuLC

uLa

u za∂∂

∆=∆ correspondant à ( )LuzC

∂∂

( ) ( )( )

( )ku

kukz

uka

u za∂∂

∆=∆ +1 correspondant à ( )kuzC

∂∂

(propagation de C à la dernière couche) (propagation de la couche k+1 à la couche k)

Finalement, nous propagerons l’erreur de la fonction d’activation ( )kau∆ dans la fonction d’agrégation ( )k

uz afin d’évaluer

( ) ( )( ) ( )

( )1

1

0−

−

= ∂∂

∆=∆ ∑ kv

ku

N

u

kau

kzv a

zk

correspondant à ( )1−∂∂

kvaC

.

Si l’on intègre ces équations à l’équation principale précédente, nous obtenons l’équation simplifiée suivante permettant plus facilement d’évaluer ( )k

uvwC ∂∂ / et ( )kubC ∂∂ / :

( )( )

( )

( )( )

( )( )

( )

( )( )

( )

( )( )

( )

( )( )

( )( )

( )

( )( )

( )

( ) ( )( )

∆+

∂∂

∆+∂∂

∆

+

∂∂

∆+∂∂

∆

=

∑

∑ ∑∑

∑ ∑∑

−

=

−−

−

=

−−

−−

−

=

−−

−−

−

=

−

=

−

=

−

=

−

− −−

−

1

0

21

1

0

11

11

1

0

11

11

1

0

1

0

1

0

1

0

2

1 11

1

d

dd

dd

d

L

L LL

L LL

N

k

Lk

Lzk

N

k

LjL

j

LjLa

j

N

j

LjkL

jk

LjLa

j

N

j

N

j

LiL

i

LiLa

i

N

i

LjiL

ji

LiLa

i

N

i

a

bbz

wwz

bbzw

wz

C

(Équation de la différentielle de la fonction d’erreur avec propagation d’erreur jusqu’à la couche de profoncteur 2=n )


8.1 La propagation de l’erreur de la fonction d’erreur C Fichier à modifier : SErrorFunction.java

Prérequis : 7.5

Dans la classe SErrorFunction disponible dans le package sim.nn.function.error, vous allez programmer la méthode suivante :

public double backward(int u) Le but de cette méthode est d’évaluer la propagation de l’erreur d’un neurone u d’une fonction d’erreur tel que

( )( )Lu

LCu a

C∂∂

=∆ .

Pour ce faire, vous n’aurez qu’à retourner le résultat de la méthode dCdA(int u) pour le neurone u. Bien que cette dernière soit abstraite pour la classe SErrorFunction, elle sera définie pour toutes les fonctions d’erreur héritant de SErrorFunction (comme SEnergyErrorFunction).

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SErrorFunctionTest du package sim.nn.function.error située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

Par la suite, remarquez que la méthode

public double[ ] backPropagation( ) throws IllegalArgumentException permettant de réaliser la propagation de l’erreur pour l’ensemble des neurones a déjà été écrite pour vous. Cependant, pour qu’elle soit fonctionnelle, vous devrez implémenter la méthode backwardPass( ) située dans la classe SAbstractNeuralFunction permettant d’utiliser backward(int u) sur l’ensemble des neurones. Ce calcul est comparable à ce que vous avez déjà réalisé sur la méthode fowardPass( ), mais au lieu de propager les données vers l’avant du réseau (l’activation), vous allez propager une erreur vers l’arrière du réseau (propagation de l’erreur).

8.2 La propagation de l’erreur de la fonction d’activation A Fichier à modifier : SActivationFunction.java

Prérequis : 7.2 et 7.4

Dans la classe SActivationFunction disponible dans le package sim.nn.function.activation, vous allez programmer la méthode suivante :

public double backward(int u) Le but de cette méthode est d’évaluer la propagation de l’erreur d’un neurone u d’une fonction d’activation2 tel que

( )( )

( )ku

ku

uka

u za∂∂

∆=∆ où ( )( )ku

kau z

C∂∂

=∆ et ( )ku

u aC

∂∂

=∆ .

Pour ce faire, utilisez backward_input représentant l’erreur à propager u∆ dans la fonction d’activation et la méthode dAdZ(int u) représentant la dérivée partielle de la fonction d’activation.

2 Il est à noté que cette version de la propagation de l’erreur s’applique à une fonction d’activation de type non full-connected (voir softmax).



public double[ ] backPropagation(double[ ] delta) throws IllegalArgumentException permettant de réaliser la propagation de l’erreur pour l’ensemble des neurones a déjà été écrite pour vous.

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SActivationFunctionTest du package sim.nn.function.activation située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

8.3 La propagation de l’erreur de la fonction d’agrégation Z Fichier à modifier : SAggregationFunction.java

Prérequis : 7.5

Dans la classe SAggregationFunction disponible dans le package sim.nn.function.aggregation, vous allez programmer la méthode suivante :

public double backward(int v) Le but de cette méthode est d’évaluer la propagation de l’erreur d’un neurone v d’une fonction d’agrégation

tel que

( )( ) ( )

( )1

1

0−

−

= ∂∂

∆=∆ ∑ kv

ku

N

uu

kzv a

zk

où ( )( )1−∂∂

=∆ kv

kzv a

C et ( )k

uu z

C∂∂

=∆ .

Pour ce faire, utilisez backward_input représentant l’erreur à propager u∆ dans la fonction d’agrégation et la méthode dZdA(int u, int v) représentant la dérivée partielle de la fonction d’agrégation.


public double[ ] backPropagation(double[ ] delta) throws IllegalArgumentException permettant de réaliser la propagation de l’erreur pour l’ensemble des neurones a déjà été écrite pour vous.

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SAgregationFunctionTest du package sim.nn.function.aggregation située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

8.4 La propagation abstraite des erreurs sur plusieurs neurones Fichier à modifier : SAbstractNeuralFunction.java


Dans la classe SAbstractNeuralFunction disponible dans le package sim.nn.function, vous allez programmer la méthode suivante :

protected double[ ] backwardPass( ) Cette méthode a pour but de généraliser, pour n’importe quel type de fonction (agrégation, activation et erreur), le calcul de la propagation de l’erreur pour l’ensemble des neurones de la fonction.

Pour ce faire, vous devrez utiliser la méthode abstraite

abstract protected double backward(int u) disponible dans cette classe calculant la propagation de l’erreur pour le neurone u.


Pour réaliser votre implémentation, utilisez le champ3local de la classe

protected double[ ] backward_output correspondant à la sortie de la fonction en mode vers l’arrière pour enregister vos calculs réalisés par la méthode backward(int u) pour chacun des u neurones. Lorsque la propagation de l’erreur pour vos neurones aura été calculée, retournez ce résultat (return backward_output).

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SAbstractNeuralFunctionTest du package sim.nn.function située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

8.5 La propagation de l’erreur d’une couche de neurones Fichier à modifier : SFullConnectedLayer.java


Dans la classe SFullConnectedLayer disponible dans le package sim.nn.layer, vous allez programmer la méthode suivante :

public double[ ] backPropagation(double[ ] delta) Le but de cette méthode est d’évaluer la propagation de l’erreur d’une couche de neurones ayant une fonction d’agrégation Z et un fonction d’activation A .

Pour réaliser la propagation de l’erreur (propagation vers l’arrière), utilisez delta représentant l’erreur à propager dans vos fonctions Z et A . Utilisez la méthode

public double[ ] backPropagation(double[ ] delta ) throws IllegalArgumentException

sur vos objets A et Z de votre classe pour réaliser vos calculs. N’oubliez pas que l’activation était dans l’ordre AZ → . Ainsi, la propagation de l’erreur sera dans l’ordre ZA → .

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SFullConnectedLayerTest du package sim.nn.layer située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

8.6 La propagation de l’erreur d’un réseau Fichier à modifier : SFullConnectedNetwork.java

Prérequis : 8.5

Dans la classe SFullConnectedNetwork disponible dans le package sim.nn.network, vous allez programmer la méthode suivante :

public double[ ] backPropagation(double[ ] delta) Le but de cette méthode est d’évaluer la propagation de l’erreur d’un réseau de plusieurs couches.

Pour avoir accès à l’ensemble de vos couches de votre réseau, utilisez le champ

private final SFullConnectedLayer[ ] layers représentant vos couches organisées dans un tableau dans l’ordre de l’activation.

3 Le champ backward_output correspond à l’erreur propagé ( )kzu∆ par la fonction d’agrégation ( )k

uz dans la classe SAggregationFunction.


Pour réaliser la propagation de l’erreur (propagation de l’erreur vers l’arrière), utilisez delta représentant l’erreur à propager depuis la dernière couche du réseau d’indice L jusqu’à la 1re couche de celui-ci d’indice 0 . Dans les faits, delta correspondant à l’erreur propagagée par la fonction d’erreur elle-même. Lorsque vous aurez évaluez l’erreur propagée par la couche layers[0] (la dernière), retournez ce résultat.

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SFullConnectedNetworkTest du package sim.nn.network située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

Le gradient de la fonction d’erreur Afin d’évaluer le gradient de la fonction d’erreur C∇ à partir d’une fonction d’erreur

( )( )yaCC L ,=

où l’activation du réseau ( )La dépend d’un vecteur d’entrée ( )*a et de l’ensemble des poids ( )kuvw et biais ( )k

ub du réseau, nous avons effectué la différentielle de cette fonction d’erreur pour obtenir l’expression

( )( )

( )

( )( )

( )( )

( )

( )( )

( )

( )( )

( )

( )( )

( )( )

( )

( )( )

( )

( ) ( )( )

∆+

∂∂

∆+∂∂

∆

+

∂∂

∆+∂∂

∆

=

∑

∑ ∑∑

∑ ∑∑

−

=

−−

−

=

−−

−−

−

=

−−

−−

−

=

−

=

−

=

−

=

−

− −−

−

1

0

21

1

0

11

11

1

0

11

11

1

0

1

0

1

0

1

0

2

1 11

1

d

dd

dd

d

L

L LL

L LL

N

k

Lk

Lzk

N

k

LjL

j

LjLa

j

N

j

LjkL

jk

LjLa

j

N

j

N

j

LiL

i

LiLa

i

N

i

LjiL

ji

LiLa

i

N

i

a

bbz

wwz

bbzw

wz

C

(Équation de la différentielle de la fonction d’erreur avec propagation d’erreur jusqu’à la couche de profoncteur 2=n )

En effectuant l’ensemble des sommations de l’équation, nous obtenons les composantes du gradient

( )( )

( )

( )kuv

kuka

ukuv w

zwC

∂∂

∆=∂∂

et ( )( )

( )

( )ku

kuka

uku b

zbC

∂∂

∆=∂∂

pour l’ensemble des paramètres du réseau. Mathématiquement, le gradient de la fonction d’erreur C∇correspond au vecteur suivant :

( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )

∂∂

∂∂

∂∂

∂∂

∂∂

∂∂

∂∂

∂∂

∂∂

∂∂

=∇ −− Li

Lji

Lj

Lkj

ku

kvuxxyyzy b

CwC

bC

wC

bC

wC

bC

wC

bC

wCC ,,,,...,,,...,,,, 111100

Ce vecteur donnera la direction opposée4 dans laquelle il faut faire varier les poids ( )kuvw et ( )k

ub pour que

l’erreur occasionnée par la différence entre ( )La et y diminue. Si l’erreur diminue après modification des poids et biais, on pourra affirmer que le réseau à « bien appris » à reproduire l’activation désirée.

4 C’est pour cette raison que l’on retrouvera un terme « négatif » dans l’équation de l’apprentissage.


9.1 La dérivée partielle de la fonction d’erreur C par rapport au biais b Fichier à modifier : SAggregationFunction.java

Prérequis : 7.5


public double dCdB(int u) Les buts de ces deux méthodes est d’évaluer les dérivées partielles de la fonction d’erreur par rapport au biais ( )k

ub :

( )( )

( )

( )ku

kuka

uku b

zbC

∂∂

∆=∂∂

(Dérivée partielle par rapport au biais ( )k

ub )

Pour ce faire, utilisez backward_input représentant l’erreur ( )kau∆ dans la classe SAggregationFunction et la

méthodes dZdB(int u) représentant la dérivée partielle de la fonction d’agrégation par rapport au biais.


9.2 La dérivée partielle de la fonction d’erreur C par rapport au poids w Fichier à modifier : SAggregationFunction.java

Prérequis : 7.5


public double dCdW(int v, int u) Les buts de ces deux méthodes est d’évaluer les dérivées partielles de la fonction d’erreur par rapport au poids ( )k

uvw :

( )( )

( )

( )kuv

kuka

ukuv w

zwC

∂∂

∆=∂∂

(Dérivée partielle par rapport au poids ( )k

uvw )

Pour ce faire, utilisez backward_input représentant l’erreur ( )kau∆ dans la classe SAggregationFunction et les

méthodes dZdW(int u, int v) représentant la dérivée partielle de la fonction d’agrégation par rapport au poids.



9.3 Le gradient de C pour des paramètres d’une couche Fichier à modifier : SFullConnectedGradientLayer.java


Dans la classe SFullConnectedGradientLayer disponible dans le package sim.nn.gradient, vous allez programmer les méthodes suivantes :

protected void add(SFullConnectedLayer layer) L’ojectif de cette méthode sera d’ajouter à un gradient la contribution des dérivées partielles de la fonction d’erreur C par rapport à l’ensemble des poids ( )k

uvw et biais ( )kub d’une couche d’un réseau.

Cette méthode réalise d’une certaine façon une sauvegarde du gradient de la fonction d’erreur, mais en accumulant plusieurs gradient provenant de différentes propagations d’erreur issus de l’activation de plusieurs donnée. Cette accumulation sera éventuellement utilisée lors de la descente du gradient dans le processus de l’apprentissage.

Pour ce faire, vous devrez :

1) Accéder à la fonction d’agrégation de la couche layer pour avoir accès à vos dérivées partielles. 2) Utiliser la méthode

protected void addGradientWeight(int v, int u, double value) afin d’ajouter à l’ensemble des entrée v et sortie u de la couche la contribution de ( )k

uvwC ∂∂ / . 3) Utiliser la méthode

protected void addGradientBias(int u, double value)

afin d’ajouter à l’ensemble des sorties u de la couche la contribution de ( )kubC ∂∂ / .

Exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SFullConnectedGradientLayerTest du package sim.nn.gradient située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

L’apprentissage du réseau L’apprentissage d’un réseau consiste à modifier les poids (weights) et biais (bias) de toutes les couches de neurones dans la direction opposée au gradient de la fonction d’erreur obtenu par la descente du gradient. En modifiant les paramètres du réseau de la sorte, on réduit l’erreur de celui-ci en lien avec le vecteur d’entraînement utilisé lors de la descente. Si ce processus est suffisamment répété sur un échantillon assez grand et varié de vecteurs d’entraînement, le réseau pourra bien représenter la fonction mathématique désirée.

https://www.quora.com/Does-Gradient-Descent-Algo-always-converge-

to-the-global-minimum

Illustration d’une descente du gradient avec mise à jour d’une fonction afin de minimiser sa valeur.

Dans cette section du laboratoire, vous devrez implémenter l’algorithme de l’apprentissage en lien avec le taux d’apprentissage (learning rate) et l’appliquer au poids et biais d’un réseau.


https://www.quora.com/Does-Gradient-Descent-Algo-always-converge-to-the-global-minimum

https://www.quora.com/Does-Gradient-Descent-Algo-always-converge-to-the-global-minimum

10.1 L’apprentissage Fichier à modifier : SNeuralMath.java

Prérequis : aucun


public static double learning(double V, double gradient, double alpha)

Le rôle de cette méthode sera de permettre la mise à jour les paramètres ( )kuvw et ( )k

ub de votre réseau correspondant ainsi à l’apprentissage. Vous utiliserez cette méthode dans le but de réaliser les calculs suivants :

( ) ( )( )kuv

kuv

kuv w

Cww∂∂

−= α~

(mise à jour d’un poids)

et ( ) ( )

( )ku

ku

ku b

Cbb∂∂

−= α~

(mise à jour d’un biais)

Dans ces deux équations, on remarque la présence d’un signe négatif. Cela signifie que l’on veut modifier nos valeurs ( )k

uvw et ( )kub dans le sens opposé au gradient ce qui aura pour but de réduire l’erreur, car le gradient

point dans la direction où il y aura augmentation de l’erreur.

Afin de réduire la programmation à réaliser, vous généralisez ces deux équations5 par l’expression

vCvv∂∂

−= α~

(mise à jour du paramètre v)

où v correspond au paramètre V, vC ∂∂ / correspond au paramètre gradient et α correspond au paramètre alpha.

Présentement, cette méthode retourne une exception de type SNoImplementationException. Complétez l’implémentation afin d’obtenir une valeur modifiée par l’apprentissage.

Pour vérifier votre implémentation, exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SNeuralMath du package sim.nn.function située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

5 Dans un réseau de neurones dont l’activation se fait par batch (batch-activation), il existe une fonction de normalisation (batch-normalization) qui utilise deux autres paramètres : scale et shift.


10.2 L’apprentissage des biais Fichier à modifier : SBias.java


Dans la classe SBias disponible dans le package sim.nn.parameter, vous allez programmer la méthode suivante :

protected void learn(SFullConnectedGradientLayer gradient, double learning_rate)

Le rôle de cette méthode sera de réaliser l’apprentissage pour tous les biais ( )kub d’une couche. Présentement,

cette méthode retourne une exception de type SNoImplementationException spécifiant que la méthode n’a pas été implémentée.

Complétez l’implémentation en utilisant la méthode

public static double learning(double V, double gradient, double alpha) disponible dans la classe SNeuralMath programmée précédemment afin de calculer vos nouveaux biais. Utilisez la variable gradient pour accéder à ( )k

ubC ∂∂ / de chaque biais. Utilisez la méthode

public void set(int u, double value) throws SNaNValueException pour affecter vos nouveaux biais à la structure de données, car elle est plus sécuritaire (elle vérifie la présente de valeur NaN).

Pour vérifier votre implémentation, exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SBiasTest du package sim.nn.parameter située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

10.3 L’apprentissage des poids Fichier à modifier : SWeights.java


Dans la classe SWeights disponible dans le package sim.nn.parameter, vous allez programmer la méthode suivante :

protected void learn(SFullConnectedGradientLayer gradient, double learning_rate)

Le rôle de cette méthode sera de réaliser l’apprentissage pour tous les poids ( )kuvw d’une couche.

Présentement, cette méthode retourne une exception de type SNoImplementationException spécifiant que la méthode n’a pas été implémentée.

Complétez l’implémentation en utilisant la méthode

public static double learning(double V, double gradient, double alpha) disponible dans la classe SNeuralMath programmée précédemment afin de calculer vos nouveaux poids. Utilisez la variable gradient pour accéder à ( )k

uvwC ∂∂ / de chaque poids. Utilisez la méthode

public void set(int v, int u, double value) throws SNaNValueException pour affecter vos nouveaux poids à la structure de données, car elle est plus sécuritaire (elle vérifie la présente de valeur NaN). Faîtes attention à vos indices v et u !


Pour vérifier votre implémentation, exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe SWeightsTest du package sim.nn.parameter située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

L’entrainement d’un réseau Un réseau de neurones entraîné est composé de couches de neurones dont les valeurs des poids et biais ont été fixées avec des valeurs réelles judicieusement déterminées. En réalisant l’activation de ce type de réseau avec un vecteur d’entrée quelconque, le résultat obtenu correspond habituellement à un résultat attendu. La qualité du résultat varie selon plusieurs facteurs : la quantité d’entraînement, la qualité des vecteurs d’entraînement, l’architecture du réseau, etc.

Dans cette partie du laboratoire, vous allez entraîner un réseau de neurones avec différentes collections de données et analyser la qualité des activations générés par le réseau.

https://www.linkedin.com/pulse/artificial-intelligence-how-do-

neural-networks-work-better-vignali

Un réseau de neurones entraîné permet d’établir des liens entre les différents paramètres d’un vecteur d’entrée ce qui correspond

à réaliser un apprentissage.

Dans un protocole d’entraînement de base6, vous retrouverez les paramètres suivants :

• Données d’entraînement (data) :

Nombre de données utilisées pour améliorer le réseau. Dans un entraînement de base, on utilise une seule donnée à la fois pour réaliser le calcul de la propagation du grandient.

• Époque (epoch) :

Nombre de fois que l’ensemble des données d’entraînement ont été utilisées pour entraîner le réseau.

• Entraînement (training) :

Nombre de fois qu’il y a eu modification des paramètres du réseau. Cet étape correspond à un pas de la descente du gradient de la fonction d’errreur.

• Iteration (iteration) :

Bloc d’entraînement à réaliser avant d’évaluer le taux de classification du réseau.

• Cycle (cycle) :

Nombre de bloc d’entraînement à réaliser avant de compléter l’entraînement du réseau.

• Taux d’apprentissage (learning rate)

Facteur multiplicatif correspondant à un taux de modification des paramètres du réseau. Ce facteur est utilisé dans la phase de l’apprentissage du réseau.

6 Un protocole avancé utilisera le mini-batch et le batch-activation pour évaluer le gradient moyen de la fonction d’erreur à chaque étape de la descente du gradient. De plus, on peut réaliser la descente du gradient en utilisant un gradient avec moment (avec inertie).


https://www.linkedin.com/pulse/artificial-intelligence-how-do-neural-networks-work-better-vignali

https://www.linkedin.com/pulse/artificial-intelligence-how-do-neural-networks-work-better-vignali

11.1 Le protocole d’entraînement Fichier à modifier : STrainingAlgorithm.java


Dans la classe STrainingAlgorithm disponible dans le package sim.trainer, vous allez programmer la méthode suivante :

public static void training(SFullConnectedNetwork network, SErrorFunction error_function, SErrorFunctionGradient gradient, SNNData data, double learning_rate)

L’objectif de cette méthode sera de réaliser l’entraînement du réseau à l’aide d’une donnée.

Pour ce faire, vous devrez :

1) Vider le gradient (gradient.clear( )) afin de vous assurer que celui-ci est bien vide avant de l’utiliser dans vos calculs.

2) Réaliser l’activation du réseau network avec le vecteur (vector) associé à la donnée data. 3) Évaluez l’erreur avec la fonction d’erreur error_function en utiliser l’activation du réseau et l’activation

attendue (expected) de la donnée. 4) Obtenir la propagation de l’erreur de la fonction d’erreur. 5) Propager l’erreur de la fonction d’erreur dans le réseau. 6) Intégrer au gradient gradient la propagation du gradient calculée dans le réseau à l’aide de l’instruction

gradient.add(network); 7) Réaliser l’apprentissage du réseau en utilisant le gradient et le taux d’apprentissage learning_rate.

Pour vérifier votre implémentation, exécutez la batterie de tests unitaires de java JUnit Test disponible dans la classe STrainingAlgorithmTest du package sim.nn.trainer située dans le répertoire test/src. Corrigez au besoin votre implémentation afin de satisfaire les tests.

11.2 L’apprentissage de la table de vérité ET (and) Fichier à modifier : SIMLearning.java

Prérequis : 11.1

Dans la classe SIMLearning disponible dans le package sim.application, vous allez réaliser l’apprentissage de la table de vérité ET avec un réseau 2 x 1.

Dans la méthode

private static void learningAnd( ) de la classe SIMLearning, vous aurez le loisir de modifier les deux constantes

final int EPOCH; final double LEARNING_RATE;

afin de réaliser l’apprentissage de la table de vérité sous différents scénarios d’apprentissage.

Dans le protocole d’apprentissage par défaut, il y aura entraînement sur 5 époques (EPOCH = 5) utilisant les 4 données d’entraînements disponible. Le taux d’apprentissage sera de 0.1 (LEARNING_RATE = 0.1). L’entraînement complet aura visité 20 données.

Exécutez le programme SIMLearning et choisir l’option (6) Apprentissage de la table de vérité ET (AND). À l’aide de l’affichage console, répondez aux questions ci-dessous. Modifier vos paramètres et relancez l’exécution afin de varier les scénarios d’apprentissage pour répondre à toutes les questions.


Répondez aux questions suivantes dans le cahier de réponse :

Question 11.2.1 :

Avec le protocole d’entraînement tel que EPOCH = 5 et LEARNING_RATE = 0.1, est-ce que l’entraînement est suffisant pour bien reproduire la table de vérité (taux de classification de 100%) avec le réseau de neurones ? Si l’entraînement est insuffisant, identifiez une solution.

Question 11.2.2 :

Avec le protocole d’entraînement tel que EPOCH = 25 et LEARNING_RATE = 0.5,

a) Environ combien de vecteurs d’entraînement est-il nécessaire d’utiliser pour obtenir un réseau ayant un taux de classification de 100% ?

b) Est-ce que la réponse en a) est variable d’un réseau non entraîné à un autre ? Réalisez plusieurs autres entraînements afin de répondre à la question.

11.3 L’apprentissage de Breast Cancer Wisconsin (Diagnostic) Data Set Fichier à modifier : SIMLearning.java

Prérequis : 11.1

Dans la classe SIMLearning disponible dans le package sim.application, vous allez réaliser l’apprentissage de la base de données Breast Cancer Wisconsin Data Set avec un réseau 10 x 1.

Dans la méthode

private static void learningWDBC( ) de la classe SIMLearning, vous aurez le loisir de modifier les deux constantes

final int CYCLE; final double LEARNING_RATE;

Dans le protocole d’apprentissage par défaut, il y aura 50 cycles d’entraînement (CYCLE = 50) avec une itération par cycle utilisant une donnée choisie aléatoirement dans la collection des vecteurs d’entraînement. Le taux d’apprentissage sera de 0.1 (LEARNING_RATE = 0.1). L’entraînement complet aura visité 50 données.

Exécutez le programme SIMLearning et choisir l’option (7) Apprentissage Breast Cancer Wisconsin (Diagnostic) Data Set. À l’aide de l’affichage console, répondez aux questions ci-dessous. Modifier vos paramètres et relancez l’exécution afin de varier les scénarios d’apprentissage pour répondre à toutes les questions.


Question 11.3.1 :

Avec le protocole d’entraînement tel que CYCLE = 50 et LEARNING_RATE = 0.1, est ce que vous avez suffisamment de vecteurs d’entraînement pour obtenir un taux de classification raisonnable ? Justifiez votre réponse.


Question 11.3.2 :

Est-il possible d’atteindre un taux de classification de plus de 95% ? Si oui, combien de vecteur d’entraînement ont été nécessaire et à quel taux d’apprentissage ?

Question 11.3.3 :

Pour obtenir un taux de classification supérieur à 95%, est-il nécessaire de réaliser un entraînement sur l’ensemble des vecteurs d’entraînement (683 vecteurs disponibles) ? Justifiez votre réponse.

Question 11.3.4 :

Est-il possible d’utiliser moins de 50 vecteurs d’entraînement et obtenir un taux de classification de plus de 90 % ? Si oui, quel taux d’apprentissage (LEARNING_RATE) avez-vous utilisé ?

11.4 L’apprentissage de MNIST Data Set Fichier à modifier : SIMLearning.java

Prérequis : 11.1

Dans la classe SIMLearning disponible dans le package sim.application, vous allez réaliser l’apprentissage de la base de données MNIST Data Set avec un réseau 784 x 16 x 16 x 10.

Dans la méthode

private static void learningMNIST( ) de la classe SIMLearning, vous aurez le loisir de modifier les trois constantes

final int CYCLE; final int ITERATION;

final double LEARNING_RATE; afin de réaliser l’apprentissage de la base de données MNIST sous différents scénarios d’apprentissage.

Dans le protocole d’apprentissage par défaut, il y aura 100 cycles (CYCLE = 100) avec 100 itérations (ITERATION = 100) par cycle utilisant une donnée choisie aléatoirement dans la collection des vecteurs d’entraînement. Le taux d’apprentissage sera de de 0.1 (LEARNING_RATE = 0.1). L’entrainement complet aura visité 10 000 données.

Avant d’exécuter le programme, vous devrez installer la collection d’images.

Pour ce faire, vous allez :

1) Télécharger le fichier mnist_png.zip au lien

http://physique.cmaisonneuve.qc.ca/svezina/projet/apprentissage_reseau/download/mnist_png.zip

2) Déplacer le fichier mnist_png.zip dans le répertoire /SIM de votre workspace. 3) Décompresser le fichier mnist_png.zip.


http://physique.cmaisonneuve.qc.ca/svezina/projet/apprentissage_reseau/download/mnist_png.zip

Exécutez le programme SIMLearning et choisir l’option (8) Apprentissage MNIST Data Set. À l’aide de l’affichage console, répondez aux questions ci-dessous. Modifier vos paramètres et relancez l’exécution afin de varier les scénarios d’apprentissage pour répondre à toutes les questions.


Question 11.4.1 :

Avec le protocole d’entraînement tel que CYCLE = 100, ITERATION = 100 et LEARNING_RATE = 0.1, est ce que vous avez suffisamment de vecteurs d’entraînement (10 000 vecteurs) pour obtenir un taux de classification raisonnable ? Justifiez votre réponse.

Question 11.4.2 :

Selon vous, avec un protocole d’entraînement tel que LEARNING_RATE = 0.1,

a) Quel est le meilleur taux de classification que le réseau 784 x 16 x 16 x 10 peut obtenir ? Modifiez au besoin les paramètres CYCLE et ITERATION pour faire varier votre protocole d’entraînement.

b) Combiens de vecteur d’entraînement ont été nécessaire pour obtenir ce meilleur taux de classification ?

Question 11.4.3 :

Avec le protocole d’entraînement CYCLE = 100, ITERATION = 100, et LEARNING_RATE = 0.9, le taux de classification du réseau évolue tout au long de l’entraînement de façon particulier. Identifiez

a) Une caractéristique positive. b) Une caractéristique négative.

Conclusion Félicitations ! Vous avez compléter l’implémentation de votre réseau de neurones et vous êtes apte à l’entraîner sous différent protocole d’entraînement.

Remise du programme Pour effectuer la remise de votre programme, envoyer le fichier ci-dessous à l’adresse suivante :

[email protected]

• Le répertoire SIM de votre projet dans un format compressé « zip » sous le nom

SIM-ApprentissageReseau.zip

comme vous l’avez initialement téléchargé.


mailto:[email protected]

l’apprentissage par réseau de neurones : partie 2...introduction À partir de l’application...

Documents